promise
一个容器，里面保存着某个未来才会结束的事件的结果
Promise对象有以下两个特点:
（1）对象的状态不受外界影响:有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）
（2）一旦状态改变，就不会再变
优点：
异步操作以同步操作的流程表达出来，.then 避免了层层嵌套的回调函数
缺点：
1无法取消Promise
常用方法：
finally()
例子，服务器使用 Promise 处理请求，然后使用finally方法关掉服务器。
all()
（1）只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。
（2）只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。
race()
只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给p的回调函数。
var a = [];
for (var i = 0; i < 10; i++) {
a[i] = function () {
console.log(i);
};
}
a[6](); // 10 a[6]函数立即执行，传入6，for循环中还是从0到10循环，全局变量最新值为10， console.log(i);自然输出10
暂时性死区
var tmp = 123;
if (true) {
tmp = 'abc'; // ReferenceError
let tmp;
}
ES6 在附录 B里面规定，浏览器的实现可以不遵守上面的规定，有自己的行为方式。
允许在块级作用域内声明函数。 函数声明类似于var，即会提升到全局作用域或函数作用域的头部。 同时，函数声明还会提升到所在的块级作用域的头部。 注意，上面三条规则只对 ES6 的浏览器实现有效，其他环境的实现不用遵守，还是将块级作用域的函数声明当作let处理。
const声明一个只读的常量。一旦声明 就必须立即初始化，常量的值就不能改变 除此之外，和let使用规则相同
对象的扩展运算符
let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
x // 1
y // 2
z // { a: 3, b: 4 }
1要求等号右边是一个对象
2扩展运算符必须是最后一个参数
3不能复制继承自原型对象的属性
let o1 = { a: 1 };
let o2 = { b: 2 };
o2.__proto__ = o1;
let { ...o3 } = o2;
o3 // { b: 2 }
o3.a // undefined
注意，如果将引用类型赋值，拷贝的是这个值的引用：同步改变
let obj = { a: { b: 1 } };
let { ...x } = obj;
obj.a.b = 2;
x.a.b // 2
3变量的解构赋值
数组的解构赋值 对象的解构赋值 字符串的解构赋值 数值和布尔值的解构赋值 函数参数的解构赋值
function move({x = 0, y = 0} = {}) {
return [x, y];
}
move({x: 3, y: 8}); // [3, 8]
move({x: 3}); // [3, 0]
move({}); // [0, 0]
move(); // [0, 0]
17 Iterator 和 for...of 循环
Iterator 的作用有三个：一是为各种数据结构，提供一个统一的、简便的访问接口；二是使得数据结构的成员能够按某种次序排列；三供for...of消费。 Iterator 的遍历过程是这样的。
（1）创建一个指针对象，指向当前数据结构的起始位置。也就是说，遍历器对象本质上，就是一个指针对象。
（2）第一次调用指针对象的next方法，可以将指针指向数据结构的第一个成员。
（3）第二次调用指针对象的next方法，指针就指向数据结构的第二个成员。
（4）不断调用指针对象的next方法，直到它指向数据结构的结束位置。
模拟next方法返回值
var it = makeIterator(['a', 'b']);
it.next() // { value: "a", done: false }
it.next() // { value: "b", done: false }
it.next() // { value: undefined, done: true }
function makeIterator(array) {
var nextIndex = 0;
return {
next: function() {
return nextIndex < array.length ?
{value: array[nextIndex++], done: false} :
{value: undefined, done: true};
}
};
}
let arr = [3, 5, 7];
arr.foo = 'hello';
for (let i in arr) {
console.log(i); // "0", "1", "2", "foo" 下标
}
for (let i of arr) {
console.log(i); // "3", "5", "7" 健值 for...of循环调用interator接口，数组的遍历器接口只返回具有数字索引的属性
}
for of 循环对象：需要借助Object.keys()
Object.keys() 方法会返回由给定对象的自身可枚举属性组成的数组
5字符串的新增方法
返回一个斜杠都被转义（即斜杠前面再加一个斜杠）的字符串，往往用于模板字符串的处理方法。
includes()：返回布尔值，表示是否找到了参数字符串。
startsWith()：返回布尔值，表示参数字符串是否在原字符串的头部。
endsWith()：返回布尔值，表示参数字符串是否在原字符串的尾部。
**trimStart()消除字符串头部的空格，trimEnd()消除尾部的空格。它们返回的都是新字符串，不会修改原始字符串。**
6正则的扩展
1、RegExp 构造函数
如果RegExp构造函数第一个参数是一个正则对象，那么可以使用第二个参数指定修饰符。
而且，返回的正则表达式会忽略原有的正则表达式的修饰符，只使用新指定的修饰符。
var regex = new RegExp('xyz', 'i');
// 等价于
var regex = /xyz/i;
7数值的扩展
BigInt 数据类型
JavaScript 所有数字都保存成 64 位浮点数，这给数值的表示带来了两大限制。
一是数值的精度只能到 53 个二进制位（相当于 16 个十进制位），大于这个范围的整数，JavaScript 是无法精确表示的，这使得 JavaScript 不适合进行科学和金融方面的精确计算
二是大于或等于2的1024次方的数值，JavaScript 无法表示，会返回Infinity。
const aa = 21721416522233333331111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113333333333;
const ba = 153463493333333333333333333333333333333331111111111111111111111111111111111111111111111111111111111111333333333333334444444444444445555555555555666666666666666666666666666666666666666777777777777777777777777777788888888888309;
aa * ba
Infinity
const a = 217214165222333333311111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111133333333
33n;
const b = 1534634933333333333333333333333333333333311111111111111111111111111111111111111111111111111111111111113333333333333344444444444444455555555555556666666666666666666666666666666666666667777777777777777777777777777888888888
88309n;
// BigInt 可以保持精度
a * b // 33334444555566667777n
3333444459650311668103414459259259259259210989444765407407412345679012345679012345679012345679012345683839327128397554998610950629653762067740755499908008643210217326281430326983703706117194428396296291111111112093200924308515102994249112346967654320987654320988148148148074076543209876172841975308641605185185185148148148148148148148148148148395061728358024691358024691382716049377723703703897n
BigInt 类型的数据必须添加后缀n
新的数据类型 BigInt（大整数），来解决这个问题。BigInt 只用来表示整数，没有位数的限制，任何位数的整数都可以精确表示。
8函数的扩展
map, filter, reduce
map 遍历原数组，将每个元素拿出来做一些变换然后放入到新的数组中,不改变原数组 另外 map 的回调函数接受三个参数，分别是当前元素，索引，原数组
let c=[1,3,4,5,6]
undefined
c.map(function (current,index) {
return current*2
})
(5) [2, 6, 8, 10, 12]
['1','2','3'].map(parseInt)
(3) [1, NaN, NaN]
c
(5) [1, 3, 4, 5, 6]
filter
let array = [1, 2, 4, 6]
let newArray = array.filter(item => item !== 6)
console.log(newArray) // [1, 2, 4]
reduce
const arr = [1, 2, 3]
const sum = arr.reduce((acc, current,index,array) =>
acc + current
, 0)
console.log(sum)
VM539:5 6
let arr1 = [1, 2, 3]
let sum1 = arr.reduce((acc, current,index,array) => //回调函数接受四个参数，分别为累计值、当前元素、当前索引、原数组
acc + current
, 1)//在一次执行回调函数时，当前值和初始值相加得出结果 1，该结果会在第二次执行回调函数时当做第一个参数传入
console.log(sum1)
VM572:5 7
reduce 来实现 map 函数
const arr = [1, 2, 3]
const mapArray = arr.map(value => value * 2)
const reduceArray = arr.reduce((acc, current) => {
acc.push(current * 2)
return acc
}, [])
console.log(mapArray, reduceArray) // [2, 4, 6]
