关于前端:校招前端必会面试题

函数防抖是指在事件被触发 n 秒后再执行回调，如果在这 n 秒内事件又被触发，则从新计时。这能够应用在一些点击申请的事件上，防止因为用户的屡次点击向后端发送屡次申请。
函数节流是指规定一个单位工夫，在这个单位工夫内，只能有一次触发事件的回调函数执行，如果在同一个单位工夫内某事件被触发屡次，只有一次能失效。节流能够应用在 scroll 函数的事件监听上，通过事件节流来升高事件调用的频率。

防抖函数的利用场景：

按钮提交场景：防⽌屡次提交按钮，只执⾏最初提交的⼀次
服务端验证场景：表单验证须要服务端配合，只执⾏⼀段间断的输⼊事件的最初⼀次，还有搜寻联想词性能相似⽣存环境请⽤ lodash.debounce

节流函数的适⽤场景：

拖拽场景：固定工夫内只执⾏⼀次，防⽌超⾼频次触发地位变动
缩放场景：监控浏览器 resize
动画场景：防止短时间内屡次触发动画引起性能问题

1. setTimeout

setTimeout 的运行机制：执行该语句时，是立刻把以后定时器代码推入事件队列，当定时器在事件列表中满足设置的工夫值时将传入的函数退出工作队列，之后的执行就交给工作队列负责。然而如果此时工作队列不为空，则需期待，所以执行定时器内代码的工夫可能会大于设置的工夫

setTimeout(() => {console.log(1);
}, 0)
console.log(2);

输入 2，1；

setTimeout的第二个参数示意在执行代码前期待的毫秒数。下面代码中，设置为 0，外表意思为执行代码前期待的毫秒数为 0，即立刻执行。但实际上的运行后果咱们也看到了，并不是外表上看起来的样子，千万不要被坑骗了。

实际上，下面的代码并不是立刻执行的，这是因为 setTimeout 有一个最小执行工夫，HTML5 标准规定了 setTimeout() 的第二个参数的最小值（最短距离）不得低于 4 毫秒 。当指定的工夫低于该工夫时，浏览器会用最小容许的工夫作为setTimeout 的工夫距离，也就是说即便咱们把 setTimeout 的延迟时间设置为 0，实际上可能为 4 毫秒后才事件推入工作队列。

定时器代码在被推送到工作队列前，会先被推入到事件列表中，当定时器在事件列表中满足设置的工夫值时会被推到工作队列，然而如果此时工作队列不为空，则需期待，所以执行定时器内代码的工夫可能会大于设置的工夫

setTimeout(() => {console.log(111);
}, 100);

下面代码示意 100ms 后执行 console.log(111)，但实际上履行的工夫必定是大于 100ms 后的，100ms 只是示意 100ms 后将工作退出到 ” 工作队列 ” 中，必须等到以后代码（执行栈）执行完，主线程才会去执行它指定的回调函数。要是以后代码耗时很长，有可能要等很久，所以并没有方法保障，回调函数肯定会在setTimeout() 指定的工夫执行。

2. setTimeout 和 setInterval 区别

setTimeout: 指定延期后调用函数，每次 setTimeout 计时到后就会去执行，而后执行一段时间后才持续setTimeout, 两头就多了误差，（误差多少与代码的执行工夫无关）。
setInterval：以指定周期调用函数，而 setInterval 则是每次都准确的隔一段时间推入一个事件（然而，事件的执行工夫不肯定就不精确，还有可能是这个事件还没执行结束，下一个事件就来了）.

btn.onclick = function(){setTimeout(function(){console.log(1);
    },250);
}

击该按钮后，首先将 onclick 事件处理程序退出队列。该程序执行后才设置定时器，再有 250ms 后，指定的代码才被增加到队列中期待执行。如果下面代码中的 onclick 事件处理程序执行了 300ms，那么定时器的代码至多要在定时器设置之后的300ms 后才会被执行。队列中所有的代码都要等到 javascript 过程闲暇之后能力执行，而不论它们是如何增加到队列中的。

如图所示，只管在 255ms 处增加了定时器代码，但这时候还不能执行，因为 onclick 事件处理程序仍在运行。定时器代码最早能执行的机会是在 300ms 处，即 onclick 事件处理程序完结之后。

3. setInterval 存在的一些问题：

JavaScript 中应用 setInterval 开启轮询。定时器代码可能在代码再次被增加到队列之前还没有实现执行，后果导致定时器代码间断运行好几次，而之间没有任何进展。而 javascript 引擎对这个问题的解决是：当应用 setInterval() 时，仅当没有该定时器的任何其余代码实例时，才将定时器代码增加到队列中。这确保了定时器代码退出到队列中的最小工夫距离为指定距离。

然而，这样会导致两个问题：

某些距离被跳过；
多个定时器的代码执行之间的距离可能比预期的小

假如，某个 onclick 事件处理程序应用 setInterval() 设置了 200ms 距离的定时器。如果事件处理程序花了 300ms 多一点工夫实现，同时定时器代码也花了差不多的工夫，就会同时呈现跳过某距离的状况

例子中的第一个定时器是在 205ms 处增加到队列中的，然而直到过了 300ms 处能力执行。当执行这个定时器代码时，在 405ms 处又给队列增加了另一个正本。在下一个距离，即 605ms 处，第一个定时器代码仍在运行，同时在队列中曾经有了一个定时器代码的实例。后果是，在这个工夫点上的定时器代码不会被增加到队列中

应用 setTimeout 结构轮询能保障每次轮询的距离。

setTimeout(function () {console.log('我被调用了');
 setTimeout(arguments.callee, 100);
}, 100);

callee 是 arguments 对象的一个属性。它能够用于援用该函数的函数体内以后正在执行的函数。在严格模式下，第 5 版 ECMAScript (ES5) 禁止应用arguments.callee()。当一个函数必须调用本身的时候, 防止应用 arguments.callee(), 通过要么给函数表达式一个名字, 要么应用一个函数申明.

setTimeout(function fn(){console.log('我被调用了');
    setTimeout(fn, 100);
},100);

这个模式链式调用了 setTimeout()，每次函数执行的时候都会创立一个新的定时器。第二个setTimeout() 调用以后执行的函数，并为其设置另外一个定时器。这样做的益处是，在前一个定时器代码执行完之前，不会向队列插入新的定时器代码，确保不会有任何缺失的距离。而且，它能够保障在下一次定时器代码执行之前，至多要期待指定的距离，防止了间断的运行。

4. requestAnimationFrame

4.1 60fps与设施刷新率

目前大多数设施的屏幕刷新率为60 次 / 秒，如果在页面中有一个动画或者突变成果，或者用户正在滚动页面，那么浏览器渲染动画或页面的每一帧的速率也须要跟设施屏幕的刷新率保持一致。

卡顿：其中每个帧的估算工夫仅比 16 毫秒 多一点（ 1 秒 / 60 = 16.6 毫秒 ）。但实际上，浏览器有整顿工作要做，因而您的所有工作是须要在10 毫秒 内实现。如果无奈合乎此估算，帧率将降落，并且内容会在屏幕上抖动。此景象通常称为卡顿，会对用户体验产生负面影响。

跳帧: 如果动画切换在 16ms, 32ms, 48ms 时别离切换，跳帧就是如果到了 32ms，其余工作还未执行实现，没有去执行动画切帧，等到开始进行动画的切帧，曾经到了该执行 48ms 的切帧。就好比你玩游戏的时候卡了，过了一会，你再看画面，它不会停留你卡的中央，或者这时你的角色曾经挂掉了。必须在下一帧开始之前就曾经绘制结束;

Chrome devtool 查看实时 FPS, 关上 More tools => Rendering, 勾选 FPS meter

4.2 requestAnimationFrame实现动画

requestAnimationFrame是浏览器用于定时循环操作的一个接口，相似于 setTimeout，主要用途是按帧对网页进行重绘。

在 requestAnimationFrame 之前，次要借助 setTimeout/ setInterval 来编写 JS 动画，而动画的关键在于动画帧之间的工夫距离设置，这个工夫距离的设置有考究，一方面要足够小，这样动画帧之间才有连贯性，动画成果才显得平滑晦涩；另一方面要足够大，确保浏览器有足够的工夫及时实现渲染。

显示器有固定的刷新频率（60Hz 或 75Hz），也就是说，每秒最多只能重绘 60 次或 75 次，requestAnimationFrame的根本思维就是与这个刷新频率放弃同步，利用这个刷新频率进行页面重绘。此外，应用这个 API，一旦页面不处于浏览器的以后标签，就会主动进行刷新。这就节俭了 CPU、GPU 和电力。

requestAnimationFrame 是在主线程上实现。这意味着，如果主线程十分忙碌，requestAnimationFrame的动画成果会大打折扣。

requestAnimationFrame 应用一个回调函数作为参数。这个回调函数会在浏览器重绘之前调用。

requestID = window.requestAnimationFrame(callback); 

window.requestAnimFrame = (function(){
    return  window.requestAnimationFrame       || 
            window.webkitRequestAnimationFrame || 
            window.mozRequestAnimationFrame    || 
            window.oRequestAnimationFrame      || 
            window.msRequestAnimationFrame     || 
            function(callback){window.setTimeout(callback, 1000 / 60);
        };
})();

下面的代码依照 1 秒钟 60 次（大概每 16.7 毫秒一次），来模仿requestAnimationFrame。

5. requestIdleCallback()

MDN 上的解释：requestIdleCallback()办法将在浏览器的闲暇时段内调用的函数排队。这使开发者可能在主事件循环上执行后盾和低优先级工作，而不会影响提早要害事件，如动画和输出响应。函数个别会按先进先调用的程序执行，然而，如果回调函数指定了执行超时工夫 timeout，则有可能为了在超时前执行函数而打乱执行程序。

requestAnimationFrame会在每次屏幕刷新的时候被调用，而 requestIdleCallback 则会在每次屏幕刷新时，判断以后帧是否还有多余的工夫，如果有，则会调用 requestAnimationFrame 的回调函数，

图片中是两个间断的执行帧，大抵能够了解为两个帧的持续时间大略为 16.67，图中黄色局部就是闲暇工夫。所以，requestIdleCallback 中的回调函数仅会在每次屏幕刷新并且有闲暇工夫时才会被调用.

利用这个个性，咱们能够在动画执行的期间，利用每帧的闲暇工夫来进行数据发送的操作，或者一些优先级比拟低的操作，此时不会使影响到动画的性能，或者和 requestAnimationFrame 搭配，能够实现一些页面性能方面的的优化，

react 的 fiber 架构也是基于 requestIdleCallback 实现的, 并且在不反对的浏览器中提供了 polyfill

总结

从 单线程模型和工作队列 登程了解 setTimeout(fn, 0)，并不是立刻执行。
JS 动画, 用requestAnimationFrame 会比 setInterval 成果更好
requestIdleCallback()罕用来切割长工作，利用闲暇工夫执行，防止主线程长时间阻塞

在 Vue3.0 中通过 Proxy 来替换本来的 Object.defineProperty 来实现数据响应式。

Proxy 是 ES6 中新增的性能，它能够用来自定义对象中的操作。

let p = new Proxy(target, handler)

target 代表须要增加代理的对象，handler 用来自定义对象中的操作，比方能够用来自定义 set 或者 get 函数。

上面来通过 Proxy 来实现一个数据响应式：

let onWatch = (obj, setBind, getLogger) => {
  let handler = {get(target, property, receiver) {getLogger(target, property)
      return Reflect.get(target, property, receiver)
    },
    set(target, property, value, receiver) {setBind(value, property)
      return Reflect.set(target, property, value)
    }
  }
  return new Proxy(obj, handler)
}
let obj = {a: 1}
let p = onWatch(
  obj,
  (v, property) => {console.log(` 监听到属性 ${property}扭转为 ${v}`)
  },
  (target, property) => {console.log(`'${property}' = ${target[property]}`)
  }
)
p.a = 2 // 监听到属性 a 扭转
p.a // 'a' = 2

在上述代码中，通过自定义 set 和 get 函数的形式，在本来的逻辑中插入了咱们的函数逻辑，实现了在对对象任何属性进行读写时发出通知。

当然这是简略版的响应式实现，如果须要实现一个 Vue 中的响应式，须要在 get 中收集依赖，在 set 派发更新，之所以 Vue3.0 要应用 Proxy 替换本来的 API 起因在于 Proxy 无需一层层递归为每个属性增加代理，一次即可实现以上操作，性能上更好，并且本来的实现有一些数据更新不能监听到，然而 Proxy 能够完满监听到任何形式的数据扭转，惟一缺点就是浏览器的兼容性不好。

产生乱码的起因：

网页源代码是 gbk 的编码，而内容中的中文字是 utf-8 编码的，这样浏览器关上即会呈现 html 乱码，反之也会呈现乱码；
html网页编码是 gbk，而程序从数据库中调出出现是utf-8 编码的内容也会造成编码乱码；
浏览器不能自动检测网页编码，造成网页乱码。

解决办法：

应用软件编辑 HTML 网页内容；
如果网页设置编码是gbk，而数据库贮存数据编码格局是UTF-8，此时须要程序查询数据库数据显示数据后退程序转码；
如果浏览器浏览时候呈现网页乱码，在浏览器中找到转换编码的菜单进行转换。

共同点：

扭转行内元素的出现形式，将 display 置为 inline-block
使元素脱离一般文档流，不再占据文档物理空间
笼罩非定位文档元素

不同点：

abuselute 与 fixed 的根元素不同，abuselute 的根元素能够设置，fixed 根元素是浏览器。
在有滚动条的页面中，absolute 会跟着父元素进行挪动，fixed 固定在页面的具体位置。

箭头函数是 ES6 中的提出来的，它没有 prototype，也没有本人的 this 指向，更不能够应用 arguments 参数，所以不能 New 一个箭头函数。

new 操作符的实现步骤如下：

创立一个对象
将构造函数的作用域赋给新对象（也就是将对象的__proto__属性指向构造函数的 prototype 属性）
指向构造函数中的代码，构造函数中的 this 指向该对象（也就是为这个对象增加属性和办法）
返回新的对象

所以，下面的第二、三步，箭头函数都是没有方法执行的。

参考前端进阶面试题具体解答

应用 clear 属性革除浮动，其语法如下：

clear:none|left|right|both

如果单看字面意思，clear:left 是“革除左浮动”，clear:right 是“革除右浮动”，实际上，这种解释是有问题的，因为浮动始终还在，并没有革除。

官网对 clear 属性解释：“元素盒子的边不能和后面的浮动元素相邻”，对元素设置 clear 属性是为了防止浮动元素对该元素的影响，而不是革除掉浮动。

还须要留神 clear 属性指的是元素盒子的边不能和后面的浮动元素相邻，留神这里“后面的”3 个字，也就是 clear 属性对“前面的”浮动元素是充耳不闻的。思考到 float 属性要么是 left，要么是 right，不可能同时存在，同时因为 clear 属性对“前面的”浮动元素充耳不闻，因而，当 clear:left 无效的时候，clear:right 必然有效，也就是此时 clear:left 等同于设置 clear:both；同样地，clear:right 如果无效也是等同于设置 clear:both。由此可见，clear:left 和 clear:right 这两个申明就没有任何应用的价值，至多在 CSS 世界中是如此，间接应用 clear:both 吧。

个别应用伪元素的形式革除浮动：

.clear::after{content:'';  display: block;   clear:both;}

clear 属性只有块级元素才无效的，而::after 等伪元素默认都是内联程度，这就是借助伪元素革除浮动影响时须要设置 display 属性值的起因。

虚构 DOM 的工作原理是 通过 JS 对象模仿 DOM 的节点。在 Facebook 构建 React 初期时，思考到要晋升代码形象能力、防止人为的 DOM 操作、升高代码整体危险等因素，所以引入了虚构 DOM
虚构 DOM 在实现上通常是 Plain Object，以 React 为例，在 render 函数中写的 JSX 会在 Babel 插件的作用下，编译为 React.createElement 执行 JSX 中的属性参数
React.createElement 执行后会返回一个 Plain Object，它会形容本人的 tag 类型、props 属性以及 children 状况等。这些 Plain Object 通过树形构造组成一棵虚构 DOM 树。当状态产生变更时，将变更前后的虚构 DOM 树进行差别比拟，这个过程称为 diff，生成的后果称为 patch。计算之后，会渲染 Patch 实现对实在 DOM 的操作。
虚构 DOM 的长处次要有三点：改善大规模 DOM 操作的性能 、 躲避 XSS 危险 、 能以较低的老本实现跨平台开发。
虚构 DOM 的毛病在社区中次要有两点
- 内存占用较高，因为须要模仿整个网页的实在 DOM
- 高性能利用场景存在难以优化的状况，相似像 Google Earth 一类的高性能前端利用在技术选型上往往不会抉择 React

除了渲染页面，虚构 DOM 还有哪些利用场景？

这个问题考验面试者的想象力。通常而言，咱们只是将虚构 DOM 与渲染绑定在一起，但实际上虚构 DOM 的利用更为广大。比方，只有你记录了实在 DOM 变更，它甚至能够利用于埋点统计与数据记录等。

SSR 原理

借助虚构 dom, 服务器中没有 dom 概念的，react 奇妙的借助虚构 dom，而后能够在服务器中 nodejs 能够运行起来 react 代码。

Null 和 Undefined 类型，null 转换为 “null”，undefined 转换为 “undefined”，
Boolean 类型，true 转换为 “true”，false 转换为 “false”。
Number 类型的值间接转换，不过那些极小和极大的数字会应用指数模式。
Symbol 类型的值间接转换，然而只容许显式强制类型转换，应用隐式强制类型转换会产生谬误。
对一般对象来说，除非自行定义 toString() 办法，否则会调用 toString()（Object.prototype.toString()）来返回外部属性 [[Class]] 的值，如 ”[object Object]”。如果对象有本人的 toString() 办法，字符串化时就会调用该办法并应用其返回值。

1. XSS

涉及面试题：什么是 XSS 攻打？如何防备 XSS 攻打？什么是 CSP？

XSS 简略点来说，就是攻击者想尽一切办法将能够执行的代码注入到网页中。
XSS 能够分为多种类型，然而总体上我认为分为两类：长久型和非长久型。
长久型也就是攻打的代码被服务端写入进数据库中，这种攻打危害性很大，因为如果网站访问量很大的话，就会导致大量失常拜访页面的用户都受到攻打。

举个例子，对于评论性能来说，就得防备长久型 XSS 攻打，因为我能够在评论中输出以下内容

这种状况如果前后端没有做好进攻的话，这段评论就会被存储到数据库中，这样每个关上该页面的用户都会被攻打到。
非长久型相比于前者危害就小的多了，个别通过批改 URL 参数的形式退出攻打代码，诱导用户拜访链接从而进行攻打。

举个例子，如果页面须要从 URL 中获取某些参数作为内容的话，不通过过滤就会导致攻打代码被执行

<!-- http://www.domain.com?name=<script>alert(1)</script> -->
<div>{{name}}</div>

然而对于这种攻击方式来说，如果用户应用 Chrome 这类浏览器的话，浏览器就能主动帮忙用户进攻攻打。然而咱们不能因而就不进攻此类攻打了，因为我不能确保用户都应用了该类浏览器。

对于 XSS 攻打来说，通常有两种形式能够用来进攻。

转义字符

首先，对于用户的输出应该是永远不信赖的。最广泛的做法就是本义输入输出的内容，对于引号、尖括号、斜杠进行本义

function escape(str) {str = str.replace(/&/g, '&')
  str = str.replace(/</g, '<')
  str = str.replace(/>/g, '>')
  str = str.replace(/"/g,'&quto;')
  str = str.replace(/'/g,'&#39;')
  str = str.replace(/`/g, '&#96;')
  str = str.replace(/\//g, '&#x2F;')
  return str
}

通过本义能够将攻打代码 <script>alert(1)</script> 变成

// -> <script>alert(1)<&#x2F;script>
escape('<script>alert(1)</script>')

然而对于显示富文本来说，显然不能通过下面的方法来本义所有字符，因为这样会把须要的格局也过滤掉。对于这种状况，通常采纳白名单过滤的方法，当然也能够通过黑名单过滤，然而思考到须要过滤的标签和标签属性切实太多，更加举荐应用白名单的形式

const xss = require('xss')
let html = xss('<h1 id="title">XSS Demo</h1><script>alert("xss");</script>')
// -> <h1>XSS Demo</h1><script>alert("xss");</script>
console.log(html)

以上示例应用了 js-xss 来实现，能够看到在输入中保留了 h1 标签且过滤了 script标签

CSP

CSP 实质上就是建设白名单，开发者明确通知浏览器哪些内部资源能够加载和执行。咱们只须要配置规定，如何拦挡是由浏览器本人实现的。咱们能够通过这种形式来尽量减少 XSS 攻打。

通常能够通过两种形式来开启 CSP：

设置 HTTP Header 中的 Content-Security-Policy
设置 meta 标签的形式 <meta http-equiv="Content-Security-Policy">

这里以设置 HTTP Header 来举例

只容许加载本站资源

Content-Security-Policy: default-src‘self’

只容许加载 HTTPS 协定图片

Content-Security-Policy: img-src https://*

容许加载任何起源框架

Content-Security-Policy: child-src 'none'

当然能够设置的属性远不止这些，你能够通过查阅文档 (opens new window)的形式来学习，这里就不过多赘述其余的属性了。

对于这种形式来说，只有开发者配置了正确的规定，那么即便网站存在破绽，攻击者也不能执行它的攻打代码，并且 CSP 的兼容性也不错。

2 CSRF

跨站申请伪造（英语：Cross-site request forgery），也被称为 one-click attack或者 session riding，通常缩写为 CSRF 或者 XSRF，是一种挟制用户在以后已登录的 Web 应用程序上执行非本意的操作的攻打办法

CSRF 就是利用用户的登录态发动歹意申请

如何攻打

假如网站中有一个通过 Get 申请提交用户评论的接口，那么攻击者就能够在钓鱼网站中退出一个图片，图片的地址就是评论接口

<img src="http://www.domain.com/xxx?comment='attack'"/>

res.setHeader('Set-Cookie', `username=poetry2;sameSite = strict;path=/;httpOnly;expires=${getCookirExpires()}`)

在 B 网站，危险网站向 A 网站发动申请

<!DOCTYPE html>
<html>
  <body>
  <!-- 利用 img 主动发送申请 -->
    <img src="http://localhost:8000/api/user/login" />
  </body>
</html>

会带上 A 网站的 cookie

// 在 A 网站下发 cookie 的时候，加上 sameSite=strict，这样 B 网站在发送 A 网站申请，不会主动带上 A 网站的 cookie，保障了平安


// NAME=VALUE    赋予 Cookie 的名称及对应值
// expires=DATE  Cookie 的有效期
// path=PATH     赋予 Cookie 的名称及对应值
// domain= 域名   作为 Cookie 实用对象的域名（若不指定则默认为创立 Cookie 的服务器的域名）(个别不指定)
// Secure        仅在 HTTPS 平安通信时才会发送 Cookie
// HttpOnly      加以限度，使 Cookie 不能被 JavaScript 脚本拜访
// SameSite      Lax|Strict|None  它容许您申明该 Cookie 是否仅限于第一方或者同一站点上下文

res.setHeader('Set-Cookie', `username=poetry;sameSite=strict;path=/;httpOnly;expires=${getCookirExpires()}`)

如何进攻

Get 申请不对数据进行批改
不让第三方网站拜访到用户 Cookie
阻止第三方网站申请接口
申请时附带验证信息，比方验证码或者 token
SameSite Cookies: 只能以后域名的网站收回的 http 申请，携带这个Cookie。当然，因为这是新的 cookie 属性，在兼容性上必定会有问题

CSRF 攻打，仅仅是利用了 http 携带 cookie 的个性进行攻打的，然而攻打站点还是无奈失去被攻打站点的 cookie。这个和 XSS 不同，XSS 是间接通过拿到 Cookie 等信息进行攻打的

在 CSRF 攻打中，就 Cookie 相干的个性：

http 申请，会主动携带 Cookie。
携带的 cookie，还是 http 申请所在域名的 cookie。

3 明码平安

加盐

对于明码存储来说，必然是不能明文存储在数据库中的，否则一旦数据库泄露，会对用户造成很大的损失。并且不倡议只对明码单纯通过加密算法加密，因为存在彩虹表的关系

通常须要对明码加盐，而后进行几次不同加密算法的加密

// 加盐也就是给原明码增加字符串，减少原明码长度
sha256(sha1(md5(salt + password + salt)))

然而加盐并不能阻止他人盗取账号，只能确保即便数据库泄露，也不会裸露用户的实在明码。一旦攻击者失去了用户的账号，能够通过暴力破解的形式破解明码。对于这种状况，通常应用验证码减少延时或者限度尝试次数的形式。并且一旦用户输出了谬误的明码，也不能间接提醒用户输错明码，而应该提醒账号或明码谬误

前端加密

尽管前端加密对于平安防护来说意义不大，然而在遇到中间人攻打的状况下，能够防止明文明码被第三方获取

4. 总结

XSS：跨站脚本攻打，是一种网站应用程序的安全漏洞攻打，是代码注入的一种。常见形式是将恶意代码注入非法代码里暗藏起来，再诱发恶意代码，从而进行各种各样的非法活动

防备：记住一点“所有用户输出都是不可信的”，所以得做输出过滤和本义

CSRF：跨站申请伪造，也称 XSRF，是一种挟制用户在以后已登录的 Web 应用程序上执行非本意的操作的攻打办法。与 XSS 相比，XSS利用的是用户对指定网站的信赖，CSRF利用的是网站对用户网页浏览器的信赖。

防备：用户操作验证（验证码），额定验证机制（token应用）等

1. 浏览器如何渲染网页

概述：浏览器渲染一共有五步

解决 HTML 并构建 DOM 树。
解决 CSS构建 CSSOM 树。
将 DOM 与 CSSOM 合并成一个渲染树。
依据渲染树来布局，计算每个节点的地位。
调用 GPU 绘制，合成图层，显示在屏幕上

第四步和第五步是最耗时的局部，这两步合起来，就是咱们通常所说的渲染

具体如下图过程如下图所示

渲染

网页生成的时候，至多会渲染一次
在用户拜访的过程中，还会一直从新渲染

从新渲染须要反复之前的第四步 (从新生成布局)+ 第五步(从新绘制) 或者只有第五个步(从新绘制)

在构建 CSSOM 树时，会阻塞渲染，直至 CSSOM树构建实现。并且构建 CSSOM 树是一个非常耗费性能的过程，所以应该尽量保障层级扁平，缩小适度层叠，越是具体的 CSS 选择器，执行速度越慢
当 HTML 解析到 script 标签时，会暂停构建 DOM，实现后才会从暂停的中央从新开始。也就是说，如果你想首屏渲染的越快，就越不应该在首屏就加载 JS 文件。并且 CSS 也会影响 JS 的执行，只有当解析完样式表才会执行 JS，所以也能够认为这种状况下，CSS 也会暂停构建 DOM

2. 浏览器渲染五个阶段

2.1 第一步：解析 HTML 标签，构建 DOM 树

在这个阶段，引擎开始解析 html，解析进去的后果会成为一棵dom 树 dom的目标至多有 2 个

作为下个阶段渲染树状图的输出
成为网页和脚本的交互界面。(最罕用的就是 getElementById 等等)

当解析器达到 script 标签的时候，产生上面四件事件

html解析器进行解析,
如果是内部脚本，就从内部网络获取脚本代码
将控制权交给 js 引擎，执行 js 代码
复原 html 解析器的控制权

由此能够失去第一个论断 1

因为 <script> 标签是阻塞解析的，将脚本放在网页尾部会减速代码渲染。
defer和 async 属性也能有助于加载内部脚本。
defer使得脚本会在 dom 残缺构建之后执行；
async标签使得脚本只有在齐全 available 才执行，并且是以非阻塞的形式进行的

2.2 第二步：解析 CSS 标签，构建 CSSOM 树

咱们曾经看到 html 解析器碰到脚本后会做的事件，接下来咱们看下 html 解析器碰到样式表会产生的状况
js会阻塞解析，因为它会批改文档 (document)。css 不会批改文档的构造，如果这样的话，仿佛看起来 css 款式不会阻塞浏览器 html 解析。然而事实上 css样式表是阻塞的。阻塞是指当 cssom 树建设好之后才会进行下一步的解析渲染

通过以下伎俩能够加重 cssom 带来的影响

将 script 脚本放在页面底部
尽可能快的加载 css 样式表
将样式表依照 media type 和media query辨别，这样有助于咱们将 css 资源标记成非阻塞渲染的资源。
非阻塞的资源还是会被浏览器下载，只是优先级较低

2.3 第三步：把 DOM 和 CSSOM 组合成渲染树（render tree）

2.4 第四步：在渲染树的根底上进行布局，计算每个节点的几何构造

布局 (layout)：定位坐标和大小，是否换行，各种position, overflow, z-index 属性

2.5 调用 GPU 绘制，合成图层，显示在屏幕上

将渲染树的各个节点绘制到屏幕上，这一步被称为绘制painting

3. 渲染优化相干

3.1 Load 和 DOMContentLoaded 区别

Load 事件触发代表页面中的 DOM，CSS，JS，图片曾经全副加载结束。
DOMContentLoaded 事件触发代表初始的 HTML 被齐全加载和解析，不须要期待 CSS，JS，图片加载

3.2 图层

一般来说，能够把一般文档流看成一个图层。特定的属性能够生成一个新的图层。不同的图层渲染互不影响，所以对于某些频繁须要渲染的倡议独自生成一个新图层，进步性能。但也不能生成过多的图层，会引起副作用。

通过以下几个罕用属性能够生成新图层

3D 变换：translate3d、translateZ
will-change
video、iframe 标签
通过动画实现的 opacity 动画转换
position: fixed

3.3 重绘（Repaint）和回流（Reflow）

重绘和回流是渲染步骤中的一大节，然而这两个步骤对于性能影响很大

重绘是当节点须要更改外观而不会影响布局的，比方扭转 color 就叫称为重绘
回流是布局或者几何属性须要扭转就称为回流。

回流必定会产生重绘，重绘不肯定会引发回流。回流所需的老本比重绘高的多，扭转深层次的节点很可能导致父节点的一系列回流

以下几个动作可能会导致性能问题

扭转 window 大小
扭转字体
增加或删除款式
文字扭转
定位或者浮动
盒模型

很多人不晓得的是，重绘和回流其实和 Event loop 无关

当 Event loop 执行完Microtasks 后，会判断 document 是否须要更新。因为浏览器是 60Hz 的刷新率，每 16ms 才会更新一次。
而后判断是否有 resize 或者 scroll，有的话会去触发事件，所以 resize 和 scroll 事件也是至多 16ms才会触发一次，并且自带节流性能。
判断是否触发了 media query
更新动画并且发送事件
判断是否有全屏操作事件
执行 requestAnimationFrame 回调
执行 IntersectionObserver 回调，该办法用于判断元素是否可见，能够用于懒加载上，然而兼容性不好
更新界面
以上就是一帧中可能会做的事件。如果在一帧中有闲暇工夫，就会去执行 requestIdleCallback 回调

常见的引起重绘的属性

color
border-style
visibility
background
text-decoration
background-image
background-position
background-repeat
outline-color
outline
outline-style
border-radius
outline-width
box-shadow
background-size

3.4 常见引起回流属性和办法

任何会扭转元素几何信息 (元素的地位和尺寸大小) 的操作，都会触发重排，上面列一些栗子

增加或者删除可见的 DOM 元素；
元素尺寸扭转——边距、填充、边框、宽度和高度
内容变动，比方用户在 input 框中输出文字
浏览器窗口尺寸扭转——resize事件产生时
计算 offsetWidth 和 offsetHeight 属性
设置 style 属性的值

回流影响的范畴

因为浏览器渲染界面是基于散失布局模型的，所以触发重排时会对四周 DOM 重新排列，影响的范畴有两种

全局范畴：从根节点 html 开始对整个渲染树进行从新布局。
部分范畴：对渲染树的某局部或某一个渲染对象进行从新布局

全局范畴回流

<body>
  <div class="hello">
    <h4>hello</h4>
    <p><strong>Name:</strong>BDing</p>
    <h5>male</h5>
    <ol>
      <li>coding</li>
      <li>loving</li>
    </ol>
  </div>
</body>

当 p 节点上产生 reflow 时，hello和 body 也会从新渲染，甚至 h5 和ol都会收到影响

部分范畴回流

用部分布局来解释这种景象：把一个 dom 的宽高之类的几何信息定死，而后在 dom 外部触发重排，就只会从新渲染该 dom 外部的元素，而不会影响到外界

3.5 缩小重绘和回流

应用 translate 代替 top

<div class="test"></div>
<style>
    .test {
        position: absolute;
        top: 10px;
        width: 100px;
        height: 100px;
        background: red;
    }
</style>
<script>
    setTimeout(() => {
        // 引起回流
        document.querySelector('.test').style.top = '100px'
    }, 1000)
</script>

应用 visibility 替换 display: none，因为前者只会引起重绘，后者会引发回流（扭转了布局）
把 DOM 离线后批改，比方：先把 DOM 给 display:none (有一次 Reflow)，而后你批改 100 次，而后再把它显示进去
不要把 DOM 结点的属性值放在一个循环里当成循环里的变量

for(let i = 0; i < 1000; i++) {
    // 获取 offsetTop 会导致回流，因为须要去获取正确的值
    console.log(document.querySelector('.test').style.offsetTop)
}

不要应用 table 布局，可能很小的一个小改变会造成整个 table 的从新布局
动画实现的速度的抉择，动画速度越快，回流次数越多，也能够抉择应用 requestAnimationFrame
CSS选择符从右往左匹配查找，防止 DOM深度过深
将频繁运行的动画变为图层，图层可能阻止该节点回流影响别的元素。比方对于 video标签，浏览器会主动将该节点变为图层。

在浮动元素前面增加 clear:both的空 div 元素

<div class="container">
    <div class="left"></div>
    <div class="right"></div>
    <div style="clear:both"></div>
</div>

给父元素增加 overflow:hidden 或者 auto 款式，触发BFC

<div class="container">
    <div class="left"></div>
    <div class="right"></div>
</div>

.container{
    width: 300px;
    background-color: #aaa;
    overflow:hidden;
    zoom:1;   /*IE6*/
}

应用伪元素，也是在元素开端增加一个点并带有 clear: both 属性的元素实现的。

<div class="container clearfix">
    <div class="left"></div>
    <div class="right"></div>
</div>

.clearfix{zoom: 1; /*IE6*/}
.clearfix:after{
    content: ".";
    height: 0;
    clear: both;
    display: block;
    visibility: hidden;
}

举荐应用第三种办法，不会在页面新增 div，文档构造更加清晰

利用 vw 来实现：

.square {
  width: 10%;
  height: 10vw;
  background: tomato;
}

利用元素的 margin/padding 百分比是绝对父元素 width 的性质来实现：

.square {
  width: 20%;
  height: 0;
  padding-top: 20%;
  background: orange;
}

利用子元素的 margin-top 的值来实现：

.square {
  width: 30%;
  overflow: hidden;
  background: yellow;
}
.square::after {
  content: '';
  display: block;
  margin-top: 100%;
}

1. 浅拷贝的原理和实现

本人创立一个新的对象，来承受你要从新复制或援用的对象值。如果对象属性是根本的数据类型，复制的就是根本类型的值给新对象；但如果属性是援用数据类型，复制的就是内存中的地址，如果其中一个对象扭转了这个内存中的地址，必定会影响到另一个对象

办法一：object.assign

object.assign是 ES6 中 object 的一个办法，该办法能够用于 JS 对象的合并等多个用处，其中一个用处就是能够进行浅拷贝。该办法的第一个参数是拷贝的指标对象，前面的参数是拷贝的起源对象（也能够是多个起源）。

object.assign 的语法为：Object.assign(target, ...sources)

object.assign 的示例代码如下：

let target = {};
let source = {a: { b: 1} };
Object.assign(target, source);
console.log(target); // {a: { b: 1} };

然而应用 object.assign 办法有几点须要留神

它不会拷贝对象的继承属性；
它不会拷贝对象的不可枚举的属性；
能够拷贝 Symbol 类型的属性。

let obj1 = {a:{ b:1}, sym:Symbol(1)}; 
Object.defineProperty(obj1, 'innumerable' ,{
    value:'不可枚举属性',
    enumerable:false
});
let obj2 = {};
Object.assign(obj2,obj1)
obj1.a.b = 2;
console.log('obj1',obj1);
console.log('obj2',obj2);

从下面的样例代码中能够看到，利用 object.assign 也能够拷贝 Symbol 类型的对象，然而如果到了对象的第二层属性 obj1.a.b 这里的时候，前者值的扭转也会影响后者的第二层属性的值，阐明其中 仍旧存在着拜访独特堆内存的问题 ，也就是说 这种办法还不能进一步复制，而只是实现了浅拷贝的性能

办法二：扩大运算符形式

咱们也能够利用 JS 的扩大运算符，在结构对象的同时实现浅拷贝的性能。
扩大运算符的语法为：let cloneObj = {...obj};

/* 对象的拷贝 */
let obj = {a:1,b:{c:1}}
let obj2 = {...obj}
obj.a = 2
console.log(obj)  //{a:2,b:{c:1}} console.log(obj2); //{a:1,b:{c:1}}
obj.b.c = 2
console.log(obj)  //{a:2,b:{c:2}} console.log(obj2); //{a:1,b:{c:2}}
/* 数组的拷贝 */
let arr = [1, 2, 3];
let newArr = [...arr]; // 跟 arr.slice()是一样的成果

扩大运算符和 object.assign 有同样的缺点，也就是 实现的浅拷贝的性能差不多 ，然而如果属性都是 根本类型的值，应用扩大运算符进行浅拷贝会更加不便

办法三：concat 拷贝数组

数组的 concat 办法其实也是浅拷贝，所以连贯一个含有援用类型的数组时，须要留神批改原数组中的元素的属性，因为它会影响拷贝之后连贯的数组。不过 concat 只能用于数组的浅拷贝，应用场景比拟局限。代码如下所示。

let arr = [1, 2, 3];
let newArr = arr.concat();
newArr[1] = 100;
console.log(arr);  // [1, 2, 3]
console.log(newArr); // [1, 100, 3]

办法四：slice 拷贝数组

slice 办法也比拟有局限性，因为 它仅仅针对数组类型。slice 办法会返回一个新的数组对象，这一对象由该办法的前两个参数来决定原数组截取的开始和完结工夫，是不会影响和扭转原始数组的。

slice 的语法为：arr.slice(begin, end);

let arr = [1, 2, {val: 4}];
let newArr = arr.slice();
newArr[2].val = 1000;
console.log(arr);  //[1, 2, { val: 1000} ]

从下面的代码中能够看出，这就是 浅拷贝的限度所在了——它只能拷贝一层对象 。如果 存在对象的嵌套，那么浅拷贝将无能为力。因而深拷贝就是为了解决这个问题而生的，它能解决多层对象嵌套问题，彻底实现拷贝

手工实现一个浅拷贝

依据以上对浅拷贝的了解，如果让你本人实现一个浅拷贝，大抵的思路分为两点：

对根底类型做一个最根本的一个拷贝；
对援用类型开拓一个新的存储，并且拷贝一层对象属性。

const shallowClone = (target) => {if (typeof target === 'object' && target !== null) {const cloneTarget = Array.isArray(target) ? []: {};
    for (let prop in target) {if (target.hasOwnProperty(prop)) {cloneTarget[prop] = target[prop];
      }
    }
    return cloneTarget;
  } else {return target;}
}

利用类型判断，针对援用类型的对象进行 for 循环遍历对象属性赋值给指标对象的属性，根本就能够手工实现一个浅拷贝的代码了

2. 深拷贝的原理和实现

浅拷贝只是创立了一个新的对象，复制了原有对象的根本类型的值，而援用数据类型只拷贝了一层属性，再深层的还是无奈进行拷贝。深拷贝则不同，对于简单援用数据类型，其在堆内存中齐全开拓了一块内存地址，并将原有的对象齐全复制过去寄存。

这两个对象是互相独立、不受影响的，彻底实现了内存上的拆散。总的来说，深拷贝的原理能够总结如下：

将一个对象从内存中残缺地拷贝进去一份给指标对象，并从堆内存中开拓一个全新的空间寄存新对象，且新对象的批改并不会扭转原对象，二者实现真正的拆散。

办法一：乞丐版（JSON.stringify）

JSON.stringify() 是目前开发过程中最简略的深拷贝办法，其实就是把一个对象序列化成为 JSON 的字符串，并将对象外面的内容转换成字符串，最初再用 JSON.parse() 的办法将 JSON 字符串生成一个新的对象

let a = {
    age: 1,
    jobs: {first: 'FE'}
}
let b = JSON.parse(JSON.stringify(a))
a.jobs.first = 'native'
console.log(b.jobs.first) // FE

然而该办法也是有局限性的：

会疏忽 undefined
会疏忽 symbol
不能序列化函数
无奈拷贝不可枚举的属性
无奈拷贝对象的原型链
拷贝 RegExp 援用类型会变成空对象
拷贝 Date 援用类型会变成字符串
对象中含有 NaN、Infinity 以及 -Infinity，JSON 序列化的后果会变成 null
不能解决循环援用的对象，即对象成环 (obj[key] = obj)。

function Obj() {this.func = function () {alert(1) }; 
  this.obj = {a:1};
  this.arr = [1,2,3];
  this.und = undefined; 
  this.reg = /123/; 
  this.date = new Date(0); 
  this.NaN = NaN;
  this.infinity = Infinity;
  this.sym = Symbol(1);
} 
let obj1 = new Obj();
Object.defineProperty(obj1,'innumerable',{ 
  enumerable:false,
  value:'innumerable'
});
console.log('obj1',obj1);
let str = JSON.stringify(obj1);
let obj2 = JSON.parse(str);
console.log('obj2',obj2);

应用 JSON.stringify 办法实现深拷贝对象，尽管到目前为止还有很多无奈实现的性能，然而这种办法足以满足日常的开发需要，并且是最简略和快捷的。而对于其余的也要实现深拷贝的，比拟麻烦的属性对应的数据类型，JSON.stringify 临时还是无奈满足的，那么就须要上面的几种办法了

办法二：根底版（手写递归实现）

上面是一个实现 deepClone 函数封装的例子，通过 for in 遍历传入参数的属性值，如果值是援用类型则再次递归调用该函数，如果是根底数据类型就间接复制

let obj1 = {
  a:{b:1}
}
function deepClone(obj) {let cloneObj = {}
  for(let key in obj) {                 // 遍历
    if(typeof obj[key] ==='object') {cloneObj[key] = deepClone(obj[key])  // 是对象就再次调用该函数递归
    } else {cloneObj[key] = obj[key]  // 根本类型的话间接复制值
    }
  }
  return cloneObj
}
let obj2 = deepClone(obj1);
obj1.a.b = 2;
console.log(obj2);   //  {a:{b:1}}

尽管利用递归能实现一个深拷贝，然而同下面的 JSON.stringify 一样，还是有一些问题没有齐全解决，例如：

这个深拷贝函数并不能复制不可枚举的属性以及 Symbol 类型；
这种办法 只是针对一般的援用类型的值做递归复制，而对于 Array、Date、RegExp、Error、Function 这样的援用类型并不能正确地拷贝；
对象的属性外面成环，即 循环援用没有解决。

这种根底版本的写法也比较简单，能够应答大部分的利用状况。然而你在面试的过程中，如果只能写出这样的一个有缺点的深拷贝办法，有可能不会通过。

所以为了“援救”这些缺点，上面我带你一起看看改良的版本，以便于你能够在面试种呈现出更好的深拷贝办法，博得面试官的青眼。

办法三：改进版（改良后递归实现）

针对下面几个待解决问题，我先通过四点相干的实践通知你别离应该怎么做。

针对可能遍历对象的不可枚举属性以及 Symbol 类型，咱们能够应用 Reflect.ownKeys 办法；
当参数为 Date、RegExp 类型，则间接生成一个新的实例返回；
利用 Object 的 getOwnPropertyDescriptors 办法能够取得对象的所有属性，以及对应的个性，顺便联合 Object.create 办法创立一个新对象，并继承传入原对象的原型链；
利用 WeakMap 类型作为 Hash 表，因为 WeakMap 是弱援用类型，能够无效避免内存透露（你能够关注一下 Map 和 weakMap 的要害区别，这里要用 weakMap），作为检测循环援用很有帮忙，如果存在循环，则援用间接返回 WeakMap 存储的值

如果你在思考到循环援用的问题之后，还能用 WeakMap 来很好地解决，并且向面试官解释这样做的目标，那么你所展现的代码，以及你对问题思考的全面性，在面试官眼中应该算是合格的了

实现深拷贝

const isComplexDataType = obj => (typeof obj === 'object' || typeof obj === 'function') && (obj !== null)

const deepClone = function (obj, hash = new WeakMap()) {if (obj.constructor === Date) {return new Date(obj)       // 日期对象间接返回一个新的日期对象
  }

  if (obj.constructor === RegExp){return new RegExp(obj)     // 正则对象间接返回一个新的正则对象
  }

  // 如果循环援用了就用 weakMap 来解决
  if (hash.has(obj)) {return hash.get(obj)
  }
  let allDesc = Object.getOwnPropertyDescriptors(obj)

  // 遍历传入参数所有键的个性
  let cloneObj = Object.create(Object.getPrototypeOf(obj), allDesc)

  // 把 cloneObj 原型复制到 obj 上
  hash.set(obj, cloneObj)

  for (let key of Reflect.ownKeys(obj)) {cloneObj[key] = (isComplexDataType(obj[key]) && typeof obj[key] !== 'function') ? deepClone(obj[key], hash) : obj[key]
  }
  return cloneObj
}

// 上面是验证代码
let obj = {
  num: 0,
  str: '',
  boolean: true,
  unf: undefined,
  nul: null,
  obj: {name: '我是一个对象', id: 1},
  arr: [0, 1, 2],
  func: function () { console.log('我是一个函数') },
  date: new Date(0),
  reg: new RegExp('/ 我是一个正则 /ig'),
  [Symbol('1')]: 1,
};
Object.defineProperty(obj, 'innumerable', {enumerable: false, value: '不可枚举属性'}
);
obj = Object.create(obj, Object.getOwnPropertyDescriptors(obj))
obj.loop = obj    // 设置 loop 成循环援用的属性
let cloneObj = deepClone(obj)
cloneObj.arr.push(4)
console.log('obj', obj)
console.log('cloneObj', cloneObj)

咱们看一下后果，cloneObj 在 obj 的根底上进行了一次深拷贝，cloneObj 里的 arr 数组进行了批改，并未影响到 obj.arr 的变动，如下图所示

float + margin，float + calc

/* 计划 1 */ 
.left {
  width: 120px;
  float: left;
}
.right {margin-left: 120px;}
/* 计划 2 */ 
.left {
  width: 120px;
  float: left;
}
.right {width: calc(100% - 120px);
  float: left;
}

在 JavaScript 中，根本类型是没有属性和办法的，然而为了便于操作根本类型的值，在调用根本类型的属性或办法时 JavaScript 会在后盾隐式地将根本类型的值转换为对象，如：

const a = "abc";
a.length; // 3
a.toUpperCase(); // "ABC"

在拜访 'abc'.length 时，JavaScript 将 'abc' 在后盾转换成 String('abc')，而后再拜访其length 属性。

JavaScript 也能够应用 Object 函数显式地将根本类型转换为包装类型：

var a = 'abc'
Object(a) // String {"abc"}

也能够应用 valueOf 办法将包装类型倒转成根本类型：

var a = 'abc'
var b = Object(a)
var c = b.valueOf() // 'abc'

看看如下代码会打印出什么：

var a = new Boolean(false);
if (!a) {console.log( "Oops"); // never runs
}

答案是什么都不会打印，因为尽管包裹的根本类型是 false，然而false 被包裹成包装类型后就成了对象，所以其非值为false，所以循环体中的内容不会运行。

|| 和 && 首先会对第一个操作数执行条件判断，如果其不是布尔值就先强制转换为布尔类型，而后再执行条件判断。

对于 || 来说，如果条件判断后果为 true 就返回第一个操作数的值，如果为 false 就返回第二个操作数的值。
&& 则相同，如果条件判断后果为 true 就返回第二个操作数的值，如果为 false 就返回第一个操作数的值。

|| 和 && 返回它们其中一个操作数的值，而非条件判断的后果

（1）创立新节点

createDocumentFragment()    // 创立一个 DOM 片段
createElement()   // 创立一个具体的元素
createTextNode()   // 创立一个文本节点

（2）增加、移除、替换、插入

appendChild(node)
removeChild(node)
replaceChild(new,old)
insertBefore(new,old)

（3）查找

getElementById();
getElementsByName();
getElementsByTagName();
getElementsByClassName();
querySelector();
querySelectorAll();

（4）属性操作

getAttribute(key);
setAttribute(key, value);
hasAttribute(key);
removeAttribute(key);

Undefined 类型的值转换为 NaN。
Null 类型的值转换为 0。
Boolean 类型的值，true 转换为 1，false 转换为 0。
String 类型的值转换如同应用 Number() 函数进行转换，如果蕴含非数字值则转换为 NaN，空字符串为 0。
Symbol 类型的值不能转换为数字，会报错。
对象（包含数组）会首先被转换为相应的根本类型值，如果返回的是非数字的根本类型值，则再遵循以上规定将其强制转换为数字。

为了将值转换为相应的根本类型值，形象操作 ToPrimitive 会首先（通过外部操作 DefaultValue）查看该值是否有 valueOf()办法。如果有并且返回根本类型值，就应用该值进行强制类型转换。如果没有就应用 toString() 的返回值（如果存在）来进行强制类型转换。

如果 valueOf() 和 toString() 均不返回根本类型值，会产生 TypeError 谬误。

在开发过程中遇到相似这样的问题：

let n1 = 0.1, n2 = 0.2
console.log(n1 + n2)  // 0.30000000000000004

这里失去的不是想要的后果，要想等于 0.3，就要把它进行转化：

(n1 + n2).toFixed(2) // 留神，toFixed 为四舍五入

toFixed(num) 办法可把 Number 四舍五入为指定小数位数的数字。那为什么会呈现这样的后果呢？

计算机是通过二进制的形式存储数据的，所以计算机计算 0.1+0.2 的时候，实际上是计算的两个数的二进制的和。0.1 的二进制是0.0001100110011001100...（1100 循环），0.2 的二进制是：0.00110011001100...（1100 循环），这两个数的二进制都是有限循环的数。那 JavaScript 是如何解决有限循环的二进制小数呢？

个别咱们认为数字包含整数和小数，然而在 JavaScript 中只有一种数字类型：Number，它的实现遵循 IEEE 754 规范，应用 64 位固定长度来示意，也就是规范的 double 双精度浮点数。在二进制迷信表示法中，双精度浮点数的小数局部最多只能保留 52 位，再加上后面的 1，其实就是保留 53 位有效数字，残余的须要舍去，听从“0 舍 1 入”的准则。

依据这个准则，0.1 和 0.2 的二进制数相加，再转化为十进制数就是：0.30000000000000004。

上面看一下 双精度数是如何保留 的：

第一局部（蓝色）：用来存储符号位（sign），用来辨别正负数，0 示意负数，占用 1 位
第二局部（绿色）：用来存储指数（exponent），占用 11 位
第三局部（红色）：用来存储小数（fraction），占用 52 位

对于 0.1，它的二进制为：

0.00011001100110011001100110011001100110011001100110011001 10011...

转为迷信计数法（迷信计数法的后果就是浮点数）：

1.1001100110011001100110011001100110011001100110011001*2^-4

能够看出 0.1 的符号位为 0，指数位为 -4，小数位为：

1001100110011001100110011001100110011001100110011001

那么问题又来了，指数位是正数，该如何保留 呢？

IEEE 标准规定了一个偏移量，对于指数局部，每次都加这个偏移量进行保留，这样即便指数是正数，那么加上这个偏移量也就是负数了。因为 JavaScript 的数字是双精度数，这里就以双精度数为例，它的指数局部为 11 位，能示意的范畴就是 0~2047，IEEE 固定 双精度数的偏移量为 1023。

当指数位不全是 0 也不全是 1 时(规格化的数值)，IEEE 规定，阶码计算公式为 e-Bias。此时 e 最小值是 1，则 1 -1023= -1022，e 最大值是 2046，则 2046-1023=1023，能够看到，这种状况下取值范畴是-1022~1013。
当指数位全副是 0 的时候(非规格化的数值)，IEEE 规定，阶码的计算公式为 1 -Bias，即 1 -1023= -1022。
当指数位全副是 1 的时候(非凡值)，IEEE 规定这个浮点数可用来示意 3 个非凡值，别离是正无穷，负无穷，NaN。具体的，小数位不为 0 的时候示意 NaN；小数位为 0 时，当符号位 s = 0 时示意正无穷，s= 1 时候示意负无穷。

对于下面的 0.1 的指数位为 -4，-4+1023 = 1019 转化为二进制就是：1111111011.

所以，0.1 示意为：

0 1111111011 1001100110011001100110011001100110011001100110011001

说了这么多，是时候该最开始的问题了，如何实现 0.1+0.2=0.3 呢？

对于这个问题，一个间接的解决办法就是设置一个误差范畴，通常称为“机器精度”。对 JavaScript 来说，这个值通常为 2 -52，在 ES6 中，提供了 Number.EPSILON 属性，而它的值就是 2 -52，只有判断 0.1+0.2-0.3 是否小于Number.EPSILON，如果小于，就能够判断为 0.1+0.2 ===0.3

function numberepsilon(arg1,arg2){return Math.abs(arg1 - arg2) < Number.EPSILON;        
}        

console.log(numberepsilon(0.1 + 0.2, 0.3)); // true

对节流与防抖的了解

定时器与 requestAnimationFrame、requestIdleCallback

Proxy 能够实现什么性能？

浏览器乱码的起因是什么？如何解决？

absolute 与 fixed 共同点与不同点

如果 new 一个箭头函数的会怎么样

应用 clear 属性革除浮动的原理？

Virtual DOM 的工作原理是什么

其余值到字符串的转换规则？

XSS 和 CSRF

渲染机制

革除浮动

实现一个宽高自适应的正方形

深浅拷贝

右边定宽，左边自适应计划

什么是 JavaScript 中的包装类型？

|| 和 && 操作符的返回值？

DOM 节点操作

其余值到数字值的转换规则？

为什么 0.1+0.2 ! == 0.3，如何让其相等

站内搜索