JS

另外对于 null 来说，很多人会认为他是个对象类型，其实这是错误的。虽然 typeof null 会输出 object，但是这只是 JS 存在的一个悠久 Bug。在 JS 的最初版本中使用的是 32 位系统，为了性能考虑使用低位存储变量的类型信息，000 开头代表是对象，然而 null 表示为全零，所以将它错误的判断为 object 。虽然现在的内部类型判断代码已经改变了，但是对于这个 Bug 却是一直流传下来。

首先，函数传参是传递对象指针的副本<br>到函数内部修改参数的属性这步，我相信大家都知道，当前 p1 的值也被修改了<br>但是当我们重新为 person 分配了一个对象时就出现了分歧，请看下图

所以最后 person 拥有了一个新的地址（指针），也就和 p1 没有任何关系了，导致了最终两个变量的值是不相同的。

typeof 1 // 'number'<br>typeof '1' // 'string'<br>typeof undefined // 'undefined'<br>typeof true // 'boolean'<br>typeof Symbol() // 'symbol'

typeof null // 'object'

typeof [] // 'object'<br>typeof {} // 'object'<br>

typeof console.log // 'function'

var str = 'hello world'<br>str instanceof String // false<br><br>var str1 = new String('hello world')<br>str1 instanceof String // true

Symbol.hasInstance 其实就是一个能让我们自定义 instanceof 行为的东西，<br>以上代码等同于 typeof 'hello world' === 'string'，所以结果自然是 true 了。<br>这其实也侧面反映了一个问题， instanceof 也不是百分之百可信的。

1、如果已经是原始类型了，那就不需要转换了<br>2、如果需要转字符串类型就调用 x.toString()，转换为基础类型的话就返回转换的值。<br>&nbsp; &nbsp; &nbsp;不是字符串类型的话就先调用 valueOf，结果不是基础类型的话再调用 toString<br>3、调用 x.valueOf()，如果转换为基础类型，就返回转换的值<br>4、如果都没有返回原始类型，就会报错

加法运算符不同于其他几个运算符，<br>它有以下几个特点：

示例1

示例2

对于除了加法的运算符来说，只要其中一方是数字，那么另一方就会被转为数字

示例

解析

在这个例子中，因为包裹箭头函数的第一个普通函数是 a，所以此时的 this 是 window

可以从上述代码中发现，不管我们给函数 bind 几次，fn 中的 this 永远由第一次 bind 决定，所以结果永远是 window

图中的流程只针对于单个规则

两边都是相同数据类型时，==是直接比较两边数据，结果为false，因为[]属于引用类型，在两个[]分别指向不同的堆内存

过程：[]==![] ----&gt; []==false -----&gt; 0==0 ---&gt;//true

闭包的定义其实很简单：函数 A 内部有一个函数 B，函数 B 可以访问到函数 A 中的变量，那么函数 B 就是闭包。

在 JS 中，闭包存在的意义就是让我们可以间接访问函数内部的变量。

题目

解决办法

Object.assign 只会拷贝所有的属性值到新的对象中，如果属性值是对象的话，拷贝的是地址，所以并不是深拷贝

该方法也是有局限性的

MessageChannel

手写深拷贝

原型链就是多个对象通过 __proto__ 的方式连接了起来。为什么 obj 可以访问到 valueOf 函数，就是因为 obj 通过原型链找到了

例子1

例子2

使用 var 声明的变量会被提升到作用域的顶部

console.log(a) // ƒ a() {}<br>function a() {}<br>var a = 1<br>

打印结果会是 ƒ a() {}，即使变量声明在函数之后，<br>这也说明了函数会被提升，并且优先于变量提升

为了解决函数间互相调用的情况

假如不存在提升这个情况，那么就实现不了上述的代码，因为不可能存在 test1 在 test2 前面然后 test2 又在 test1 前面。

1、在子类的构造函数中通过 Parent.call(this) 继承父类的属性

2、然后改变子类的原型为 new Parent() 来继承父类的函数

优点

缺点

将父类的原型赋值给了子类，并且将构造函数设置为子类，<br>这样既解决了无用的父类属性问题，还能正确的找到子类的构造函数

1、解决命名冲突<br>2、提供复用性<br>3、提高代码可维护性

在早期，使用立即执行函数实现模块化是常见的手段，通过函数作用域解决了命名冲突、污染全局作用域的问题

鉴于目前这两种实现方式已经很少见到，所以不再对具体特性细聊，只需要了解这两者是如何使用的。

CommonJS 最早是 Node 在使用，目前也仍然广泛使用，比如在 Webpack 中你就能见到它，当然目前在 Node 中的模块管理已经和 CommonJS 有一些区别了

ES Module 是原生实现的模块化方案

ES Module与 CommonJS 有以下几个区别

// 引入模块 API<br>import XXX from './a.js'<br>import { XXX } from './a.js'<br>// 导出模块 API<br>export function a() {}<br>export default function() {}

我们通过自定义 set 和 get 函数的方式，在原本的逻辑中插入了我们的函数逻辑，实现了在对对象任何属性进行读写时发出通知。

第一轮遍历 parseInt('1', 0) -&gt; 1<br>第二轮遍历 parseInt('2', 1) -&gt; NaN<br>第三轮遍历 parseInt('3',

let array = [1, 2, 4, 6]<br>let newArray = array.filter(item =&gt; item !== 6)<br>console.log(newArray) // [1, 2, 4]

const arr = [1, 2, 3]<br>const sum = arr.reduce((acc, current) =&gt; acc + current, 0)<br>console.log(sum)

对于 reduce 来说，它接受两个参数，分别是回调函数和初始值，接下来我们来分解上述代码中 reduce 的过程<br><br>首先初始值为 0，该值会在执行第一次回调函数时作为第一个参数传入<br>回调函数接受四个参数，分别为累计值、当前元素、当前索引、原数组，后三者想必大家都可以明白作用，这里着重分析第一个参数<br>在一次执行回调函数时，当前值和初始值相加得出结果 1，该结果会在第二次执行回调函数时当做第一个参数传入<br>所以在第二次执行回调函数时，相加的值就分别是 1 和 2，以此类推，循环结束后得到结果 6

1、嵌套函数存在耦合性，一旦有所改动，就会牵一发而动全身<br>2、嵌套函数一多，就很难处理错误

比如不能使用 try catch 捕获错误，<br>不能直接 return。<br><br>

因为 await 将异步代码改造成了同步代码，如果多个异步代码没有依赖性却使用了 await 会导致性能上的降低。

第一，它和 setTimeout 一样，不能保证在预期的时间执行任务

第二，它存在执行累积的问题，请看以下伪代码

不同的任务源会被分配到不同的 Task 队列中，任务源可以分为 微任务（microtask） 和 宏任务（macrotask）。<br>在 ES6 规范中，microtask 称为 jobs，macrotask 称为 task。<br>下面来看以下代码的执行顺序：

首先先来解释下上述代码的 async 和 await 的执行顺序。当我们调用 async1 函数时，会马上输出 async2 end，并且函数返回一个 Promise，接下来在遇到 await的时候会就让出线程开始执行 async1 外的代码，所以我们完全可以把 await 看成是让出线程的标志。<br><br>然后当同步代码全部执行完毕以后，就会去执行所有的异步代码，那么又会回到 await 的位置执行返回的 Promise 的 resolve 函数，这又会把 resolve 丢到微任务队列中，接下来去执行 then 中的回调，当两个 then 中的回调全部执行完毕以后，又会回到 await 的位置处理返回值，这时候你可以看成是 Promise.resolve(返回值).then()，然后 await 后的代码全部被包裹进了 then 的回调中，所以 console.log('async1 end') 会优先执行于 setTimeout。

把 async 的这两个函数改造成你一定能理解的代码

1、首先 context 为可选参数，如果不传的话默认上下文为 window<br>2、接下来给 context 创建一个 fn 属性，并将值设置为需要调用的函数<br>3、因为 call 可以传入多个参数作为调用函数的参数，所以需要将参数剥离出来<br>4、然后调用函数并将对象上的函数删除

1、前几步和之前的实现差不多，就不赘述了<br>2、bind 返回了一个函数，对于函数来说有两种方式调用，一种是直接调用，一种是通过 new 的方式，我们先来说直接调用的方式<br>3、对于直接调用来说，这里选择了 apply 的方式实现，但是对于参数需要注意以下情况：因为 bind 可以实现类似这样的代码 f.bind(obj, 1)(2)，所以我们需要将两边的参数拼接起来，于是就有了这样的实现 args.concat(...arguments)<br>4、最后来说通过 new 的方式，在之前的章节中我们学习过如何判断 this，对于 new 的情况来说，不会被任何方式改变 this，所以对于这种情况我们需要忽略传入的 this

1、创建一个空对象<br>2、获取构造函数<br>3、设置空对象的原型<br>4、绑定 this 并执行构造函数<br>5、确保返回值为对象

只要你在士兵前面使用 new 关键字，那么可以少做四件事情：<br><br>不用创建临时对象，因为 new 会帮你做（你使用「this」就可以访问到临时对象）；<br>不用绑定原型，因为 new 会帮你做（new 为了知道原型在哪，所以指定原型的名字为 prototype）；<br>不用 return 临时对象，因为 new 会帮你做；<br>不要给原型想名字了，因为 new 指定名字为 prototype。