1、前言

这是我在学习ES6的过程中，碰到的很容易忽略的知识点！

知识点1：你知道for循环中的let有一个单独的作用域吗？

请看下题输出什么

let i = 5;
for (let i = 0; console.log(i), i < 3; i++) {
  let i = 'abc';
  console.log(i);
}
// 输出
// 0
// abc
// 1
// abc
// 2
// abc
// 3

上面的代码，首先最外层有一个let i = 5; for循环体里有let i = 0; 如果这两个i在同一个作用域里肯定会报错，这就说明这两个i不在同意作用域，接着，我们再看for循环体里的i和里面的i是否在同一个作用域，通过输出内容，明显它们不在同一个作用域里。

知识点2：对象的解构赋值可以取到继承的属性吗？

是的

const obj1 = {};
const obj2 = { name: 'xiaoming' };
Object.setPrototypeOf(obj1, obj2);

const { name } = obj1;
name // "xiaoming"

知识点3：将已声明的变量结构赋值需要加括号？

// 错误的写法
let x;
{x} = {x: 1};

上面代码的写法会报错，因为 JavaScript 引擎会将{x}理解成一个代码块，从而发生语法错误,需要将整个结构语句放在圆括号里。

// 正确的写法
let x;
({x} = {x: 1});

知识点4：函数的length属性是指函数的默认参数个数，如果默认参数里面有默认值，会出现什么问题？

(function (a) {}).length // 1
(function (a = 5) {}).length // 0

上面代码中，length属性的返回值，等于函数的参数个数减去指定了默认值的参数个数。

(function (a = 0, b, c) {}).length // 0
(function (a, b = 1, c) {}).length // 1

如果设置了默认值的参数不是尾参数，那么length属性也不再计入后面的参数了。

为什么要提这个知识点呢，因为函数柯里化通用函数里，需要用到函数默认参数的个数，也就是length属性，所以如果参数设置了默认值，会影响函数柯里化的结果。

知识点5：你不知道的Array.from用法

Array.from方法用于将两类对象转为真正的数组：

类似数组的对象（array-like object）
可遍历（iterable）的对象（包括 ES6 新增的数据结构 Set 和 Map）

定义提到Array.from可以将类数组对象（注：类数组对象可以理解为有length属性的对象）可以转换为数组，那么如下：

Array.from({ length: 3 });
// [ undefined, undefined, undefined ]

Array.from还可以接受第二个参数，作用类似于数组的map方法。

Array.from(arrayLike, x => x * x);
// 等同于
Array.from(arrayLike).map(x => x * x);

Array.from([1, 2, 3], (x) => x * x)

如果map函数里面用到了this关键字，还可以传入Array.from的第三个参数，用来绑定this。

知识点5：数组的includes方法和indexOf方法都可以判断是否数组中存在某一元素，它们有什么区别？

if ([1, 2, 3].indexOf(2) !== -1) {
  // ...
}

indexOf方法有两个缺点，一是不够语义化，它的含义是找到参数值的第一个出现位置，所以要去比较是否不等于-1，表达起来不够直观。二是，它内部使用严格相等运算符（===）进行判断，这会导致对NaN的误判。

[NaN].indexOf(NaN)
// -1

includes使用的是不一样的判断算法，就没有这个问题。

[NaN].includes(NaN)
// true

知识点6：数组的join()和toString()方法，如果数组中包括undefined或者null，会被处理成空字符串

[1, undefined, 2].join(); // "1,,2"
[1, undefined, 2].toString()]() // "1,,2"

[1, null, 2].join(); // "1,,2"
[1, null, 2].toString()]() // "1,,2"

知识点7：遍历对象操作跟可枚举性的恩怨情仇

可枚举性

对象的每个属性都有一个描述对象（Descriptor），用来控制该属性的行为。Object.getOwnPropertyDescriptor方法可以获取该属性的描述对象。

let obj = { foo: 123 };
Object.getOwnPropertyDescriptor(obj, 'foo')
//  {
//    value: 123,
//    writable: true,
//    enumerable: true,
//    configurable: true
//  }

描述对象的enumerable属性，称为“可枚举性”，如果该属性为false，就表示某些操作会忽略当前属性。

属性的遍历

ES6 一共有 5 种方法可以遍历对象的属性。

for...in

for...in循环遍历对象自身的和继承的可枚举属性（不含 Symbol 属性）。

Object.keys(obj)

Object.keys返回一个数组，包括对象自身的（不含继承的）所有可枚举属性（不含 Symbol 属性）的键名。

Object.getOwnPropertyNames(obj)

Object.getOwnPropertyNames返回一个数组，包含对象自身的所有属性（不含 Symbol 属性，但是包括不可枚举属性）的键名。

Object.getOwnPropertySymbols(obj)

Object.getOwnPropertySymbols返回一个数组，包含对象自身的所有 Symbol 属性的键名。

Reflect.ownKeys(obj)

Reflect.ownKeys返回一个数组，包含对象自身的所有键名，不管键名是 Symbol 或字符串，也不管是否可枚举。

以上的 5 种方法遍历对象的键名，都遵守同样的属性遍历的次序规则

首先遍历所有数值键，按照数值升序排列。
其次遍历所有字符串键，按照加入时间升序排列。
最后遍历所有 Symbol 键，按照加入时间升序排列。

Reflect.ownKeys({ [Symbol()]:0, b:0, 10:0, 2:0, a:0 })
// ['2', '10', 'b', 'a', Symbol()]

上面代码中，Reflect.ownKeys方法返回一个数组，包含了参数对象的所有属性。这个数组的属性次序是这样的，首先是数值属性2和10，其次是字符串属性b和a，最后是 Symbol 属性。

知识点7：对象和数组的扩展运算符后面可以跟表达式？

是的

const obj = {
  ...(x > 1 ? {a: 1} : {}),
  b: 2,
};

const arr = [
  ...(x > 0 ? ['a'] : []),
  'b',
];

知识点8：WeakSet 和Set 的区别？

区别有两点

第一点，WeakSet的成员只能是对象类型，而不能是其他类型的值。

const ws = new WeakSet();
ws.add({a: 1}) // 正确
ws.add([1,2]) // 正确
wa.add(1) //错误

第二点，WeakSet中的对象都是弱引用。

同上，WeakMap和Map的区别也有两点

第一点，WeakMap只接受对象作为键名（null除外），不接受其他类型的值作为键名。
第二点，WeakMap的键名所指向的对象，不计入垃圾回收机制

知识点9：对象的属性赋值，一般情况下这个值会赋值到对象上，但有一种情况会赋值到这个对象的原型上

为什么下面的代码输出1

const handler = {
  set: function(obj, prop, value, receiver) {
    console.log(1)
  }
};
const proxy = new Proxy({}, handler);
const myObj = {};
Object.setPrototypeOf(myObj, proxy);

myObj.foo = 'bar';

原因在于，如果myObj的原型部署了set方法，并且myObj上没有foo属性，此时，给myObj的foo属性赋值的话，会先看myObj对象上是否有foo属性，没有的话回去它的原型去找，此时就触发了proxy的set方法，所以打印了1。

知识点10：Promise中的resolve函数如果报错，Promise对象抛出的错误不会传递到外层代码

const someAsyncThing = function() {
  return new Promise(function(resolve, reject) {
    // 下面一行会报错，因为x没有声明
    resolve(x + 2);
  });
};

someAsyncThing().then(function() {
  console.log('everything is great');
});

setTimeout(() => { console.log(123) }, 2000);
// Uncaught (in promise) ReferenceError: x is not defined
// 123

上面代码中，someAsyncThing函数产生的 Promise 对象，内部有语法错误。浏览器运行到这一行，会打印出错误提示ReferenceError: x is not defined，但是不会退出进程、终止脚本执行，2秒之后还是会输出123。
这就是说，Promise内部的错误不会影响到 Promise外部的代码，通俗的说法就是Promise 会吃掉错误。

知识点11：如何通过generator函数控制流管理

代码如下，如何自动执行以下的generator函数（这种流程管理的代码适合同步任务，我认为可以称作js的职责责任链模式，非常方便流程管理）

function* runTask(value1) {
  try {
    var value2 = yield step1(value1);
    var value3 = yield step2(value2);
  } catch (e) {
  
  }
}

自动执行代码如下

scheduler(runTask(initialValue));

function scheduler(task) {
  var taskObj = task.next(task.value);
  // 如果Generator函数未结束，就继续调用
  if (!taskObj.done) {
    task.value = taskObj.value
    scheduler(task);
  }
}