（立下flag）每日10道前端面试题-03

1.如何避免重绘或者重排？

集中改变样式

我们往往通过改变class的方式来集中改变样式

使用DocumentFragment

我们可以通过createDocumentFragment创建一个游离于DOM树之外的节点，然后在此节点上批量操作，最后插入DOM树中，因此只触发一次重排

提升为合成层

将元素提升为合成层有以下优点：

• 合成层的位图，会交由 GPU 合成，比 CPU 处理要快

• 当需要 repaint 时，只需要 repaint 本身，不会影响到其他的层

• 对于 transform 和 opacity 效果，不会触发 layout 和 paint

提升合成层的最好方式是使用 CSS 的 will-change 属性：

2.DNS劫持是什么？

DNS劫持是一种恶意攻击，DNS劫持也称为DNS重定向，通过覆盖计算机的TCP / IP设置，将个人查询重定向到域名服务器DNS。这可以通过使用恶意软件或修改服务器的设置来实现，一旦执行DNS劫持的个人控制了DNS，他们就可以使用它来将流量引导到不同的网站。

要执行攻击，犯罪者要么在用户计算机上安装恶意软件，要么接管路由器，要么拦截或破解DNS通信。DNS劫持可用于域欺骗（在此上下文中，攻击者通常会显示不需要的广告以产生收入）或用于网络钓鱼（显示虚假版本的网站用户访问和窃取数据或凭据）。

DNS劫持的四种基本类型：

1.本地DNS劫持 ：攻击者在用户的计算机上安装木马恶意软件，并更改本地DNS设置以将用户重定向到恶意站点。

2.路由器DNS劫持：许多路由器都有默认密码或固件漏洞，攻击者可以接管路由器并覆盖DNS设置，从而影响连接到该路由器的所有用户。

3.中间 DNS攻击的人：攻击者拦截用户和DNS服务器之间的通信，并提供指向恶意站点的不同目标IP地址。

4.流氓DNS服务器：攻击者攻击DNS服务器，并更改DNS记录以将DNS请求重定向到恶意站点。

DNS劫持如何运作？

DNS将域名（例如www.simcf.cc）映射到其对应的IP地址，DNS服务器通常由ISP和其他私人企业组织拥有。在正常情况下，您的计算机的设置方式使其能够使用来自您的ISP或其他信誉良好的组织的DNS。

如果您的计算机已被设法更改您的PC DNS设置的黑客或恶意软件程序感染，它将无法再正确建立域名与其原始IP地址之间的连接，这意味着您将被引导至您尝试访问的某些网站的虚假版本。

为什么使用DNS劫持？

1.ISP DNS劫持

一些ISP使用这种技术，声称这是一种改善用户体验的方法。这意味着当通过某些ISP连接到互联网时，如果您键入不存在或不再可用的网站的URL，而不是在浏览器中看到错误页面，您将被重定向到其他网站。这转化为ISP的更多收入，因为他们很可能控制您被重定向到的页面并从该网站上的广告中赚取相当多的钱。

2.针对域欺骗的DNS劫持

这是通过将网站的流量重定向到虚假流量来完成的。作为示例，我们可以采用这样的场景：用户通过在浏览器中键入URL来尝试连接到社交网络平台，而不是访问平台，但是出现了另一个网站，一个充满了弹窗和广告，黑客通过广告展示或点击产生收入的广告。

3.用于网络钓鱼

其中用户被定向到着名网站的恶意副本，该网站看起来与原始网站完全相同，例如，如果银行的网站被黑客入侵并重定向其DNS，则意味着用户最终会在虚假网站上引入他们的登录信息，这些网站由将使用其银行信息窃取资金的人拥有。

3.JS跨域方案JSONP与CORS的各自优缺点以及应用场景？

两者优点与缺点大致互补，放在一块介绍：

1. JSONP的主要优势在于对浏览器的支持较好；虽然目前主流浏览器支持CORS，但IE10以下不支持CORS。

2. JSONP只能用于获取资源（即只读，类似于GET请求）；CORS支持所有类型的HTTP请求，功能完善。（这点JSONP被玩虐，但大部分情况下GET已经能满足需求了）

3. JSONP的错误处理机制并不完善，我们没办法进行错误处理；而CORS可以通过onerror事件监听错误，并且浏览器控制台会看到报错信息，利于排查。

4. JSONP只会发一次请求；而对于复杂请求，CORS会发两次请求。

5. 始终觉得安全性这个东西是相对的，没有绝对的安全，也做不到绝对的安全。毕竟JSONP并不是跨域规范，它存在很明显的安全问题：callback参数注入和资源访问授权设置。CORS好歹也算是个跨域规范，在资源访问授权方面进行了限制（Access-Control-Allow-Origin），而且标准浏览器都做了安全限制，比如拒绝手动设置origin字段，相对来说是安全了一点。
   但是回过头来看一下，就算是不安全的JSONP，我们依然可以在服务端端进行一些权限的限制，服务端和客户端也都依然可以做一些注入的安全处理，哪怕被攻克，它也只能读一些东西。就算是比较安全的CORS，同样可以在服务端设置出现漏洞或者不在浏览器的跨域限制环境下进行攻击，而且它不仅可以读，还可以写。

应用场景：

如果你需要兼容IE低版本浏览器，无疑，JSONP。

如果你需要对服务端资源进行谢操作，无疑，CORS。

其他情况的话，根据自己的对需求的分析和对两者的理解来吧。

DOM相关

4.dom事件模型

DOM之事件模型分脚本模型、内联模型(同类一个，后者覆盖)、动态绑定(同类多个) demo

5.什么是自定义事件

在日常开发中，我们习惯监听页面许多事件，诸如：点击事件（​​click​​​）、鼠标移动事件（​​mousemove​​​）、元素失去焦点事件（​​blur​​）等等。

事件本质是一种通信方式，是一种消息，只有在多对象多模块时，才有可能需要使用事件进行通信。在多模块化开发时，可以使用自定义事件进行模块间通信。

当某些基础事件无法满足我们业务，就可以尝试 自定义事件来解决。

????二、实现方式介绍

==========

目前实现自定义事件的两种主要方式是 JS 原生的​​Event()​​​ 构造函数和​​CustomEvent()​​构造函数来创建。

1. Event()

​​Event()​​​构造函数, 创建一个新的事件对象​​Event​​。

1.1 语法

let myEvent = new Event(typeArg, eventInit);

1.2 参数

​​typeArg​​  ：​​DOMString​​ 类型，表示创建事件的名称；

​​eventInit​​ ：可选配置项，包括：

1.3 演示示例

1.4 兼容性

图片来源：https://caniuse.com/

2. CustomEvent()

​​CustomEvent()​​​构造函数, 创建一个新的事件对象​​CustomEvent​​。

2.1 语法

let myEvent = new CustomEvent(typeArg, eventInit);

2.2 参数

​​typeArg​​  ：​​DOMString​​类型，表示创建事件的名称；

​​eventInit​​：可选配置项，包括：

2.3 演示示例

我们也可以给自定义事件添加属性：

myEvent.age = 18;

2.4 兼容性

图片来源：https://caniuse.com/

2.5 IE8 兼容

分发事件时，需要使用​​dispatchEvent​​​ 事件触发，它在 IE8 及以下版本中需要进行使用​​fireEvent​​ 方法兼容：

3. Event() 与 CustomEvent() 区别

从两者支持的参数中，可以看出：

​​Event()​​适合创建简单的自定义事件，而​​CustomEvent()​​支持参数传递的自定义事件，它支持​​detail​​ 参数，作为事件中需要被传递的数据，并在​​EventListener​​获取。

注意:

当一个事件触发时，若相应的元素及其上级元素没有进行事件监听，则不会有回调操作执行。 

当需要对于子元素进行监听，可以在其父元素进行事件托管，让事件在事件冒泡阶段被监听器捕获并执行。此时可以使用​​event.target​​获取到具体触发事件的元素。

????三、使用场景

========

事件本质是一种消息，事件模式本质上是观察者模式的实现，即能用观察者模式的地方，自然也能用事件模式。

1.场景介绍

比如这两种场景：

• 场景1：单个目标对象发生改变，需要通知多个观察者一同改变。

如：当微博列表中点击“关注”，此时会同时发生很多事：推荐更多类似微博，个人关注数增加...

• 场景2：解耦多模块开协作。

如：小王负责A模块开发，小陈负责B模块开发，模块B需要模块A正常运行之后才能执行。

2. 代码实现

2.1 场景1实现

场景1：单个目标对象发生改变，需要通知多个观察者一同改变。

本例子模拟三个页面进行演示：

1.微博列表页（Weibo.js）

2.粉丝列表页（User.js）

3.微博首页（Home.js）

在微博列表页（Weibo.js）中，我们导入其他两个页面，并且监听【关注微博】按钮的点击事件，在回调事件中，创建一个自定义事件 ​​focusUser​​，并在​​document​​ 上使用​​dispatchEvent​​ 方法派发自定义事件。

接下来两个页面实现的代码基本一致，这里为了方便观察，设置了两者不同输出日志。

点击【关注微博】按钮后，看到控制台输出如下日志信息：

最终实现了，在微博列表页（Weibo.js）组件负责派发事件，其他组价负责监听事件，这样三个组件之间耦合度非常低，完全不用关系对方，互相不影响。

其实这也是实现了观察者模式。

2.2 场景2实现

场景2：解耦多模块开协作。

举个更直观的例子，当微博需要加入【一键三连】新功能，需要产品原型和UI设计完后，程序员才能开发。

本例子模拟四个模块：

1.流程控制（Index.js）

2.产品设计（Production.js）

3.UI设计（Design.js）

4.程序员开发（Develop.js）

在流程控制（Index.js）模块中，我们需要将其他三个流程的模块都导入进来，然后监听【开始任务】按钮的点击事件，在回调事件中，创建一个自定义事件 ​​startTask​​​，并在​​document​​​上使用​​dispatchEvent​​方法派发自定义事件。

6. 如何在ES5环境下实现let

对于这个问题，我们可以直接查看​​babel​​​转换前后的结果，看一下在循环中通过​​let​​定义的变量是如何解决变量提升的问题

babel在let定义的变量前加了道下划线，避免在块级作用域外访问到该变量，除了对变量名的转换，我们也可以通过自执行函数来模拟块级作用域

7. 如何在ES5环境下实现const

实现const的关键在于​​Object.defineProperty()​​​这个API，这个API用于在一个对象上增加或修改属性。通过配置属性描述符，可以精确地控制属性行为。​​Object.defineProperty()​​ 接收三个参数：

Object.defineProperty(obj, prop, desc)

对于const不可修改的特性，我们通过设置writable属性来实现

8. 数组扁平化

对于​​[1, [1,2], [1,2,3]]​​​这样多层嵌套的数组，我们如何将其扁平化为​​[1, 1, 2, 1, 2, 3]​​这样的一维数组呢：

1.ES6的flat()

const arr = [1, [1,2], [1,2,3]]
arr.flat(Infinity)  // [1, 1, 2, 1, 2, 3]
复制代码

2.序列化后正则

const arr = [1, [1,2], [1,2,3]]
const str = `[${JSON.stringify(arr).replace(/(\[|\])/g, '')}]`
JSON.parse(str)   // [1, 1, 2, 1, 2, 3]
复制代码

3.递归

对于树状结构的数据，最直接的处理方式就是递归

const arr = [1, [1,2], [1,2,3]]
function flat(arr) {
let result = []
for (const item of arr) {
    item instanceof Array ? result = result.concat(flat(item)) : result.push(item)
  }
return result
}

flat(arr) // [1, 1, 2, 1, 2, 3]
复制代码

4.reduce()递归

const arr = [1, [1,2], [1,2,3]]
function flat(arr) {
return arr.reduce((prev, cur) => {
return prev.concat(cur instanceof Array ? flat(cur) : cur)
  }, [])
}

flat(arr)  // [1, 1, 2, 1, 2, 3]
复制代码

5.迭代+展开运算符

let arr = [1, [1,2], [1,2,3]]
while (arr.some(Array.isArray)) {
arr = [].concat(...arr);
}

console.log(arr)  // [1, 1, 2, 1, 2, 3]
复制代码

9. 说说HTTP/3.0

尽管HTTP/2解决了很多1.1的问题，但HTTP/2仍然存在一些缺陷，这些缺陷并不是来自于HTTP/2协议本身，而是来源于底层的TCP协议，我们知道TCP链接是可靠的连接，如果出现了丢包，那么整个连接都要等待重传，HTTP/1.1可以同时使用6个TCP连接，一个阻塞另外五个还能工作，但HTTP/2只有一个TCP连接，阻塞的问题便被放大了。

由于TCP协议已经被广泛使用，我们很难直接修改TCP协议，基于此，HTTP/3选择了一个折衷的方法——UDP协议，HTTP/2在UDP的基础上实现多路复用、0-RTT、TLS加密、流量控制、丢包重传等功能。

10 .理解和使用ES6中的Symbol

#### 这是一种新的基础数据类型（primitive type）

​​Symbol​​​是由ES6规范引入的一项新特性，它的功能类似于一种标识唯一性的ID。通常情况下，我们可以通过调用​​Symbol()​​函数来创建一个Symbol实例：

let s1 = Symbol()

或者，你也可以在调用​​Symbol()​​函数时传入一个可选的字符串参数，相当于给你创建的Symbol实例一个描述信息：

let s2 = Symbol('another symbol')

如果用当下比较流行的TypeScript的方式来描述这个​​Symbol()​​函数的话，可以表示成：

/**
 * @param  {any} description 描述信息。可以是任何可以被转型成字符串的值，如：字符串、数字、对象、数组等
 */
function Symbol(description?: any): symbol

由于​​Symbol​​​是一种基础数据类型，所以当我们使用​​typeof​​​去检查它的类型的时候，它会返回一个属于自己的类型​​symbol​​​，而不是什么​​string​​​、​​object​​之类的：

typeof s1  // 'symbol'

另外，我们需要重点记住的一点是：每个Symbol实例都是唯一的。因此，当你比较两个Symbol实例的时候，将总会返回​​false​​：

let s1 = Symbol()
let s2 = Symbol('another symbol')
let s3 = Symbol('another symbol')

s1 === s2 // false
s2 === s3 // false

应用场景1：使用Symbol来作为对象属性名(key)

在这之前，我们通常定义或访问对象的属性时都是使用字符串，比如下面的代码：

let obj = {
  abc: 123,
"hello": "world"
}

obj["abc"] // 123
obj["hello"] // 'world'

而现在，​​Symbol​​可同样用于对象属性的定义和访问：

const PROP_NAME = Symbol()
const PROP_AGE = Symbol()

let obj = {
  [PROP_NAME]: "一斤代码"
}
obj[PROP_AGE] = 18

obj[PROP_NAME] // '一斤代码'
obj[PROP_AGE] // 18

随之而来的是另一个非常值得注意的问题：就是当使用了Symbol作为对象的属性key后，在对该对象进行key的枚举时，会有什么不同？在实际应用中，我们经常会需要使用​​Object.keys()​​​或者​​for...in​​来枚举对象的属性名，那在这方面，Symbol类型的key表现的会有什么不同之处呢？来看以下示例代码：

let obj = {
   [Symbol('name')]: '一斤代码',
age: 18,
title: 'Engineer'
}

Object.keys(obj)   // ['age', 'title']

for (let p in obj) {
console.log(p)   // 分别会输出：'age' 和 'title'
}

Object.getOwnPropertyNames(obj)   // ['age', 'title']

由上代码可知，Symbol类型的key是不能通过​​Object.keys()​​​或者​​for...in​​来枚举的，它未被包含在对象自身的属性名集合(property names)之中。所以，利用该特性，我们可以把一些不需要对外操作和访问的属性使用Symbol来定义。

也正因为这样一个特性，当使用​​JSON.stringify()​​将对象转换成JSON字符串的时候，Symbol属性也会被排除在输出内容之外：

JSON.stringify(obj)  // {"age":18,"title":"Engineer"}

我们可以利用这一特点来更好的设计我们的数据对象，让“对内操作”和“对外选择性输出”变得更加优雅。

然而，这样的话，我们就没办法获取以Symbol方式定义的对象属性了么？非也。还是会有一些专门针对Symbol的API，比如：

// 使用Object的API
Object.getOwnPropertySymbols(obj) // [Symbol(name)]

// 使用新增的反射API
Reflect.ownKeys(obj) // [Symbol(name), 'age', 'title']

应用场景2：使用Symbol来替代常量

先来看一下下面的代码，是不是在你的代码里经常会出现？

const TYPE_AUDIO = 'AUDIO'
const TYPE_VIDEO = 'VIDEO'
const TYPE_IMAGE = 'IMAGE'

function handleFileResource(resource) {
switch(resource.type) {
case TYPE_AUDIO:
      playAudio(resource)
break
case TYPE_VIDEO:
      playVideo(resource)
break
case TYPE_IMAGE:
      previewImage(resource)
break
default:
throw new Error('Unknown type of resource')
  }
}

如上面的代码中那样，我们经常定义一组常量来代表一种业务逻辑下的几个不同类型，我们通常希望这几个常量之间是唯一的关系，为了保证这一点，我们需要为常量赋一个唯一的值（比如这里的'AUDIO'、'VIDEO'、 'IMAGE'），常量少的时候还算好，但是常量一多，你可能还得花点脑子好好为他们取个好点的名字。

现在有了​​Symbol​​，我们大可不必这么麻烦了：

const TYPE_AUDIO = Symbol()
const TYPE_VIDEO = Symbol()
const TYPE_IMAGE = Symbol()

这样定义，直接就保证了三个常量的值是唯一的了！是不是挺方便的呢。

应用场景3：使用Symbol定义类的私有属性/方法

我们知道在JavaScript中，是没有如Java等面向对象语言的访问控制关键字​​private​​的，类上所有定义的属性或方法都是可公开访问的。因此这对我们进行API的设计时造成了一些困扰。

而有了​​Symbol​​​以及​​模块化机制​​，类的私有属性和方法才变成可能。例如：

• 在文件 a.js中

const PASSWORD = Symbol()

class Login {
constructor(username, password) {
this.username = username
this[PASSWORD] = password
  }

  checkPassword(pwd) {
return this[PASSWORD] === pwd
  }
}

export default Login

• 在文件 b.js 中

import Login from './a'

const login = new Login('admin', '123456')

login.checkPassword('123456')  // true

login.PASSWORD  // oh!no!
login[PASSWORD] // oh!no!
login["PASSWORD"] // oh!no!

由于Symbol常量​​PASSWORD​​​被定义在a.js所在的模块中，外面的模块获取不到这个Symbol，也不可能再创建一个一模一样的Symbol出来（因为Symbol是唯一的），因此这个​​PASSWORD​​的Symbol只能被限制在a.js内部使用，所以使用它来定义的类属性是没有办法被模块外访问到的，达到了一个私有化的效果。

注册和获取全局Symbol

通常情况下，我们在一个浏览器窗口中（window），使用​​Symbol()​​​函数来定义和Symbol实例就足够了。但是，如果你的应用涉及到多个window（最典型的就是页面中使用了​​<iframe>​​​），并需要这些window中使用的某些Symbol是同一个，那就不能使用​​Symbol()​​​函数了，因为用它在不同window中创建的Symbol实例总是唯一的，而我们需要的是在所有这些window环境下保持一个共享的Symbol。这种情况下，我们就需要使用另一个API来创建或获取Symbol，那就是​​Symbol.for()​​，它可以注册或获取一个window间全局的Symbol实例：

let gs1 = Symbol.for('global_symbol_1')  //注册一个全局Symbol
let gs2 = Symbol.for('global_symbol_1')  //获取全局Symbol

gs1 === gs2  // true

这样一个Symbol不光在单个window中是唯一的，在多个相关window间也是唯一的了。

好了，通过以上这些例子，你现在是不是开始对ES6的这个Symbol功能有点了解了呢？Symbol在JS内部也有很多应用，比如迭代器(Iterator)等，大家可以以此为出发点，发掘出更多相关知识点，深入的理解Symbol的用法和使用场景。