es6学习归纳

块级作用域解决了以前的两个问题
第一种场景，内层变量可能会覆盖外层变量。
第二种场景，用来计数的循环变量泄露为全局变量。

es6声明变量的6种方式：var,const,let,import,class,function

解构赋值：按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构，数组的是 模式赋值，对象是根据命名赋值，对象的解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值由它的位置决定；而对象的属性没有次序，变量必须与属性同名，才能取到正确的值
注意 如果要将一个已经声明的变量用于解构赋值，必须非常小心

js中对于数组的几种操作方式：
shift()删除数组的第一个元素从其中删除，并返回第一个元素的值 语法 ：arrayObject.pop()
unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度
push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度
pop() 方法用于删除并返回数组的最后一个元素。 语法 ：arrayObject.pop()

字符串扩展
es6支持字符串遍历器接口，map,数组本身支持遍历器接口
如果某个字符串不够指定长度，会在头部或尾部补全。padStart()用于头部补全，padEnd()用于尾部补全。
字符串对象共有 4 个方法，可以使用正则表达式：match()、replace()、search()和split()。

函数扩展
参数默认值可以与解构赋值的默认值，结合起来使用。
指定了默认值以后，函数的length属性，将返回没有指定默认值的参数个数。也就是说，指定了默认值后，length属性将失真。如果设置了默认值的参数不是尾参数，那么length属性也不再计入后面的参数了,函数的length属性，不包括 rest 参数
可以将参数默认值设为undefined，表明这个参数是可以省略的
rest 参数: rest参数（形式：…变量名），用于获取函数的多余参数，利用 rest 参数，可以向该函数传入任意数目的参数,rest参数搭配的变量是一个数组 例如：…item
name 属性 函数的name属性，返回该函数的函数名
箭头函数有几个使用注意点。

（1）函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。

（2）不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。

（3）不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。

（4）不可以使用yield命令，因此箭头函数不能用作 Generator 函数。

上面四点中，第一点尤其值得注意。this对象的指向是可变的，但是在箭头函数中，它是固定的。箭头函数没有自己的this，内部的this指向外部的this
部署管道机制（pipeline），即前一个函数的输出是后一个函数的输入。
尾调用（Tail Call）指某个函数的最后一步是调用另一个函数，最终只有一个调用栈，不会递归栈溢出

在JavaScript里使用typeof判断数据类型，只能区分基本类型，即：number、string、undefined、boolean、object。
对于null、array、function、object来说，使用typeof都会统一返回object字符串。
要想区分对象、数组、函数、单纯使用typeof是不行的。在JS中，可以通过Object.prototype.toString方法，判断某个对象之属于哪种内置类型。
分为null、string、boolean、number、undefined、array、function、object、date、math
在JavaScript中,想要判断某个对象值属于哪种内置类型，最靠谱的做法就是通过Object.prototype.toString方法

扩展运算符（…）：将一个数组转为用逗号分隔的参数序列 ,如果扩展运算符后面是一个空数组，则不产生任何效果,只有函数调用时，扩展运算符才可以放在圆括号中，否则会报错

js中call()、apply()、bind() 都是用来重定义 this 这个对象的
apply 方法传入两个参数：一个是作为函数上下文的对象，另外一个是作为函数参数所组成的数组 例如：func.apply(obj, [‘A’, ‘B’]);
call 方法第一个参数也是作为函数上下文的对象，但是后面传入的是一个参数列表，而不是单个数组 例如：func.call(obj, ‘C’, ‘D’);
bind 接受的参数有两部分，第一个参数是是作为函数上下文的对象，第二部分参数是个列表，可以接受多个参数 例如：var func1 = func.bind(null, ‘xixi’); func1();
apply、call 方法都会使函数立即执行，因此它们也可以用来调用函数
bind 方法不会立即执行，而是返回一个改变了上下文 this 后的函数。而原函数 func 中的 this 并没有被改变，依旧指向全局对象 window
bind 在传递参数的时候会将自己带过去的参数排在原函数参数之前
yield是ES6的新关键字，使生成器函数执行暂停，yield关键字后面的表达式的值返回给生成器的调用者。它可以被认为是一个基于生成器的版本的return关键字。
yield关键字实际返回一个IteratorResult（迭代器）对象，它有两个属性，value和done，分别代表返回值和是否完成。
yield无法单独工作，需要配合generator(生成器)的其他函数，如next，懒汉式操作(在类加载时，不创建实例，因此类加载速度快，但运行时获取对象的速度慢)，展现强大的主动控制特性。

扩展运算符 1.由于扩展运算符可以展开数组，所以不再需要apply方法，将数组转为函数的参数了。
扩展运算符的应用
（1）复制数组
const a1 = [1, 2];
// 写法一
const a2 = […a1];
// 写法二
const […a2] = a1;
（2）合并数组 不过，这两种方法都是浅拷贝，使用的时候需要注意
const arr1 = [‘a’, ‘b’];
const arr2 = [‘c’];
const arr3 = [‘d’, ‘e’];
// ES5 的合并数组
arr1.concat(arr2, arr3);
// [ ‘a’, ‘b’, ‘c’, ‘d’, ‘e’ ]
// ES6 的合并数组
[…arr1, …arr2, …arr3]
// [ ‘a’, ‘b’, ‘c’, ‘d’, ‘e’ ]
（3）与解构赋值结合
// ES5
a = list[0], rest = list.slice(1)
// ES6
[a, …rest] = list
const [first, …rest] = [1, 2, 3, 4, 5];
first // 1
rest // [2, 3, 4, 5]

（4）字符串
扩展运算符还可以将字符串转为真正的数组。[…‘hello’] // [ “h”, “e”, “l”, “l”, “o” ]
（5）实现了 Iterator 接口的对象 任何定义了遍历器（Iterator）接口的对象（参阅 Iterator 一章），都可以用扩展运算符转为真正的数组。
（6）Map 和 Set 结构，Generator 函数
扩展运算符内部调用的是数据结构的 Iterator 接口，因此只要具有 Iterator 接口的对象，都可以使用扩展运算符，比如 Map 结构。

Array.from() Array.from方法用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括 ES6 新增的数据结构 Set 和 Map）
let arrayLike = {
‘0’: ‘a’,
‘1’: ‘b’,
‘2’: ‘c’,
length: 3
};
// ES6的写法
let arr2 = Array.from(arrayLike); // [‘a’, ‘b’, ‘c’]
只要是部署了 Iterator 接口的数据结构，Array.from都能将其转为数组
如果参数是一个真正的数组，Array.from会返回一个一模一样的新数组
扩展运算符背后调用的是遍历器接口（Symbol.iterator），如果一个对象没有部署这个接口，就无法转换。**Array.from（）**方法还支持类似数组的对象。所谓类似数组的对象，本质特征只有一点，即必须有length属性。因此，任何有length属性的对象，都可以通过Array.from方法转为数组，而此时扩展运算符就无法转换。
**Array.of()**方法用于将一组值，转换为数组
Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1
这个方法的主要目的，是弥补数组构造函数Array()的不足。因为参数个数的不同，会导致Array()的行为有差异。
Array() // []
Array(3) // [, , ,]
Array(3, 11, 8) // [3, 11, 8]
Array方法没有参数、一个参数、三个参数时，返回结果都不一样。只有当参数个数不少于 2 个时，Array()才会返回由参数组成的新数组。参数个数只有一个时，实际上是指定数组的长度

数组实例的 copyWithin() 数组实例的copyWithin()方法，在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，使用这个方法，会修改当前数组
Array.prototype.copyWithin(target, start = 0, end = this.length)
它接受三个参数。

target（必需）：从该位置开始替换数据。如果为负值，表示倒数。
start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示从末尾开始计算。
end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示从末尾开始计算。
[1, 2, 3, 4, 5].copyWithin(0, 3)
// [4, 5, 3, 4, 5]

数组实例的 find() 和 findIndex()
数组实例的find方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined find方法的回调函数可以接受三个参数，依次为当前的值、当前的位置和原数组。

数组实例的findIndex方法的用法与find方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1

另外，这两个方法都可以发现NaN，弥补了数组的indexOf方法的不足。
[NaN].indexOf(NaN) // -1
[NaN].findIndex(y => Object.is(NaN, y))// 0
上面代码中，indexOf方法无法识别数组的NaN成员，但是findIndex方法可以借助Object.is方法做到。
数组实例的 fill() fill方法使用给定值，填充一个数组 。fill方法用于空数组的初始化非常方便。数组中已有的元素，会被全部抹去。
fill方法还可以接受第二个和第三个参数，用于指定填充的起始位置和结束位置。
[‘a’, ‘b’, ‘c’].fill(7, 1, 2) // [‘a’, 7, ‘c’]

**数组实例的 entries()，keys() 和 values()**用于遍历数组。它们都返回一个遍历器对象（详见《Iterator》一章），可以用for…of循环进行遍历，唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。
for (let index of [‘a’, ‘b’].keys()) {
console.log(index);
}
// 0
// 1
for (let elem of [‘a’, ‘b’].values()) {
console.log(elem);
}
// ‘a’
// ‘b’
for (let [index, elem] of [‘a’, ‘b’].entries()) {
console.log(index, elem);
}
// 0 “a”
// 1 “b”
数组实例的 includes() Array.prototype.includes方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似 [1, 2, 3].includes(2) // true [1, 2, 3].includes(4) // false
该方法的第二个参数表示搜索的起始位置，默认为0。如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度（比如第二个参数为-4，但数组长度为3），则会重置为从0开始
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true

另外，Map 和 Set 数据结构有一个has方法，需要注意与includes区分。
Map 结构的has方法，是用来查找键名的，比如Map.prototype.has(key)、WeakMap.prototype.has(key)、Reflect.has(target, propertyKey)。
Set 结构的has方法，是用来查找值的，比如Set.prototype.has(value)、WeakSet.prototype.has(value)

数组实例的 flat()，flatMap()
数组的成员有时还是数组，Array.prototype.flat()用于将嵌套的数组“拉平”，变成一维的数组。该方法返回一个新数组，对原数据没有影响 [1, 2, [3, 4]].flat()// [1, 2, 3, 4]
1.flat()默认只会“拉平”一层，如果想要“拉平”多层的嵌套数组，可以将flat()方法的参数写成一个整数，表示想2.要拉平的层数，默认为1 [1, 2, [3, [4, 5]]].flat(2)// [1, 2, 3, 4, 5]
3.如果不管有多少层嵌套，都要转成一维数组，可以用Infinity关键字作为参数。[1, [2, [3]]].flat(Infinity)// [1, 2, 3]
4.如果原数组有空位，flat()方法会跳过空位。[1, 2, , 4, 5].flat()// [1, 2, 4, 5]

flatMap() 方法对原数组的每个成员执行一个函数（相当于执行Array.prototype.map()），然后对返回值组成的数组执行flat()方法。该方法返回一个新数组，不改变原数组。
// 相当于 [[2, 4], [3, 6], [4, 8]].flat()
[2, 3, 4].flatMap((x) => [x, x * 2])
// [2, 4, 3, 6, 4, 8]
1.flatMap()只能展开一层数组。 // 相当于 [[[2]], [[4]], [[6]], [[8]]].flat()
[1, 2, 3, 4].flatMap(x => [[x * 2]])
// [[2], [4], [6], [8]]
2.flatMap()方法的参数是一个遍历函数，该函数可以接受三个参数，分别是当前数组成员、当前数组成员的位置（从零开始）、原数组。
arr.flatMap(function callback(currentValue[, index[, array]]) {
// …
}[, thisArg])
3.flatMap()方法还可以有第二个参数，用来绑定遍历函数里面的this

数组的空位 数组的某一个位置没有任何值。比如，Array构造函数返回的数组都是空位。 Array(3) // [, , ,]
注意：空位不是undefined，一个位置的值等于undefined，依然是有值的。空位是没有任何值
ES6 则是明确将空位转为undefined
Array.from方法会将数组的空位，转为undefined，也就是说，这个方法不会忽略空位Array.from([‘a’,‘b’])
// [ “a”, undefined, “b” ]
扩展运算符（…）也会将空位转为undefined […[‘a’,‘b’]]// [ “a”, undefined, “b” ]
copyWithin()会连空位一起拷贝。[,‘a’,‘b’,].copyWithin(2,0) // [,“a”,“a”]
fill()会将空位视为正常的数组位置new Array(3).fill(‘a’) // [“a”,“a”,“a”]
for…of循环也会遍历空位。
let arr = [, ,];
for (let i of arr) {
console.log(1);
}
// 1
// 1
entries()、keys()、values()、find()和findIndex()会将空位处理成undefined

Array.prototype.sort() 的排序稳定性 排序稳定性（stable sorting）是排序算法的重要属性，指的是排序关键字相同的项目，排序前后的顺序不变。
常见的排序算法之中，插入排序、合并排序、冒泡排序等都是稳定的，堆排序、快速排序等是不稳定的。不稳定排序的主要缺点是，多重排序时可能会产生问题。假设有一个姓和名的列表，要求按照“姓氏为主要关键字，名字为次要关键字”进行排序。开发者可能会先按名字排序，再按姓氏进行排序。如果排序算法是稳定的，这样就可以达到“先姓氏，后名字”的排序效果。如果是不稳定的，就不行

可枚举性
对象的每个属性都有一个描述对象（Descriptor），用来控制该属性的行为。Object.getOwnPropertyDescriptor方法可以获取该属性的描述对象
let obj = { foo: 123 };
Object.getOwnPropertyDescriptor(obj, ‘foo’)
// {
// value: 123,
// writable: true,
// enumerable: true,
// configurable: true
// }
描述对象的enumerable属性，称为“可枚举性”，如果该属性为false，就表示某些操作会忽略当前属性。
目前，有四个操作会忽略enumerable为false的属性。
for…in循环：只遍历对象自身的和继承的可枚举的属性。
Object.keys()：返回对象自身的所有可枚举的属性的键名。
JSON.stringify()：只串行化对象自身的可枚举的属性。
Object.assign()： 忽略enumerable为false的属性，只拷贝对象自身的可枚举的属性

属性的遍历
ES6 一共有 5 种方法可以遍历对象的属性。
（1）for…in
for…in循环遍历对象自身的和继承的可枚举属性（不含 Symbol 属性）。
（2）Object.keys(obj)
Object.keys返回一个数组，包括对象自身的（不含继承的）所有可枚举属性（不含 Symbol 属性）的键名。
（3）Object.getOwnPropertyNames(obj)
Object.getOwnPropertyNames返回一个数组，包含对象自身的所有属性（不含 Symbol 属性，但是包括不可枚举属性）的键名。
（4）Object.getOwnPropertySymbols(obj)
Object.getOwnPropertySymbols返回一个数组，包含对象自身的所有 Symbol 属性的键名。
（5）Reflect.ownKeys(obj)
Reflect.ownKeys返回一个数组，包含对象自身的所有键名，不管键名是 Symbol 或字符串，也不管是否可枚举。
以上的 5 种方法遍历对象的键名，都遵守同样的属性遍历的次序规则。
首先遍历所有数值键，按照数值升序排列。
其次遍历所有字符串键，按照加入时间升序排列。
最后遍历所有 Symbol 键，按照加入时间升序排列。

super 关键字
this关键字总是指向函数所在的当前对象，ES6 又新增了另一个类似的关键字super，指向当前对象的原型对象
注意，super关键字表示原型对象时，只能用在对象的方法之中，用在其他地方都会报错。

对象的解构赋值用于从一个对象取值，相当于将目标对象自身的所有可遍历的（enumerable）、但尚未被读取的属性，分配到指定的对象上面。所有的键和它们的值，都会拷贝到新对象上面。
let { x, y, …z } = { x: 1, y: 2, a: 3, b: 4 }; x // 1 y // 2 z // { a: 3, b: 4 }

对象的扩展运算符（…）用于取出参数对象的所有可遍历属性，拷贝到当前对象之中

let aClone = { …a };
// 等同于
let aClone = Object.assign({}, a);
上面的例子只是拷贝了对象实例的属性，如果想完整克隆一个对象，还拷贝对象原型的属性，可以采用下面的写法。

// 写法一
const clone1 = {
proto: Object.getPrototypeOf(obj),
…obj
};
// 写法二
const clone2 = Object.assign(
Object.create(Object.getPrototypeOf(obj)),
obj
);

// 写法三
const clone3 = Object.create(
Object.getPrototypeOf(obj),
Object.getOwnPropertyDescriptors(obj)
) 写法一的__proto__属性在非浏览器的环境不一定部署，因此推荐使用写法二和写法三

扩展运算符的参数对象之中，如果有取值函数get，这个函数是会执行的
链判断运算符 （optional chaining operator）?.
const firstName = message?.body?.user?.firstName || ‘default’;
链判断运算符有三种用法。
obj?.prop // 对象属性
obj?.[expr] // 同上
func?.(…args) // 函数或对象方法的调用

Object.is就是部署这个算法的新方法。它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致Object.is(‘foo’, ‘foo’) 不同之处只有两个：一是+0不等于-0，二是NaN等于自身
// true
Object.is({}, {})
// false

Object.assign方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）
Object.assign方法的第一个参数是目标对象，后面的参数都是源对象
注意，如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。
Object.assign方法实行的是浅拷贝，而不是深拷贝。也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用
对于这种嵌套的对象，一旦遇到同名属性，Object.assign的处理方法是替换，而不是添加
Object.assign方法有很多用处
（1）为对象添加属性
class Point {
constructor(x, y) {
Object.assign(this, {x, y});
}
}
（2）为对象添加方法
Object.assign(SomeClass.prototype, {
someMethod(arg1, arg2) {
···
},
anotherMethod() {
···
}
});

（3）克隆对象
function clone(origin) {
return Object.assign({}, origin);
}
（4）合并多个对象
const merge =
(target, …sources) => Object.assign(target, …sources);
如果希望合并后返回一个新对象，可以改写上面函数，对一个空对象合并。
const merge =
(…sources) => Object.assign({}, …sources);
（5）为属性指定默认值
const DEFAULTS = {
logLevel: 0,
outputFormat: ‘html’
};

function processContent(options) {
options = Object.assign({}, DEFAULTS, options);
console.log(options);
// …
}
Object.getOwnPropertyDescriptors() 返回指定对象所有自身属性（非继承属性）的描述对象
该方法的引入目的，主要是为了解决Object.assign()无法正确拷贝get属性和set属性的问题。
Object.getOwnPropertyDescriptors()方法可以实现一个对象继承另一个对象。以前，继承另一个对象，常常写成下面这样。
const obj = {
proto: prot,
foo: 123,
};
const obj = Object.create(
prot,
Object.getOwnPropertyDescriptors({
foo: 123,
})
);
__proto__属性，Object.setPrototypeOf()，Object.getPrototypeOf()
__proto__属性（前后各两个下划线），用来读取或设置当前对象的prototype对象只有浏览器部署，因此不建议使用而是用以下代替
Object.setPrototypeOf()（写操作）、Object.getPrototypeOf()（读操作）、Object.create()（生成操作）代替

Object.keys方法，返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键名
Object.values方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值
如果Object.values方法的参数是一个字符串会返回各个字符组成的一个数组。Object.values(‘foo’)// [‘f’, ‘o’, ‘o’]
如果参数不是对象，Object.values会先将其转为对象。由于数值和布尔值的包装对象，都不会为实例添加非继承的属性。所以，Object.values会返回空数组
**Object.entries()**方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值对数组
const obj = { foo: ‘bar’, baz: 42 };
Object.entries(obj)
// [ [“foo”, “bar”], [“baz”, 42] ]
Object.entries方法的另一个用处是，将对象转为真正的Map结构
const obj = { foo: ‘bar’, baz: 42 };
const map = new Map(Object.entries(obj));
map // Map { foo: “bar”, baz: 42 }
**Object.fromEntries()**方法是Object.entries()的逆操作，用于将一个键值对数组转为对象
Object.fromEntries([
[‘foo’, ‘bar’],
[‘baz’, 42]
])
// { foo: “bar”, baz: 42 }
该方法的主要目的，是将键值对的数据结构还原为对象，因此特别适合将 Map 结构转为对象
该方法的一个用处是配合URLSearchParams对象，将查询字符串转为对象
Object.fromEntries(new URLSearchParams(‘foo=bar&baz=qux’))
// { foo: “bar”, baz: “qux” }

ES6 引入了一种新的原始数据类型Symbol，表示独一无二的值。它是 JavaScript 语言的第七种数据类型，前六种是：undefined、null、布尔值（Boolean）、字符串（String）、数值（Number）、对象（Object）
注意，Symbol函数前不能使用new命令，否则会报错。这是因为生成的 Symbol 是一个原始类型的值，不是对象。也就是说，由于 Symbol 值不是对象，所以不能添加属性。基本上，它是一种类似于字符串的数据类型
注意，Symbol函数的参数只是表示对当前 Symbol 值的描述，因此相同参数的Symbol函数的返回值是不相等的
Symbol 值不能与其他类型的值进行运算，会报错。
但是，Symbol 值可以显式转为字符串。
let sym = Symbol(‘My symbol’);
String(sym) // ‘Symbol(My symbol)’
sym.toString() // 'Symbol(My symbol)
另外，Symbol 值也可以转为布尔值，但是不能转为数值。
Symbol.prototype.description:因读取这个描述需要将 Symbol 显式转为字符串，故提供了一个实例属性description，直接返回 Symbol 的描述const sym = Symbol(‘foo’); sym.description // “foo”
由于每一个 Symbol 值都是不相等的，这意味着 Symbol 值可以作为标识符，用于对象的属性名，就能保证不会出现同名的属性。
对象的Symbol.replace属性，指向一个方法，当该对象被String.prototype.replace方法调用时，会返回该方法的返回值