1 let和const what：和es5作用相同，但有自己的块级作用域，在块级作用域之外是访问不到let声明的变量的。 { let a = 10; var b = 1; }
console.log(b) // 1
console.log(a)// ReferenceError: a is not defined.
特点： 1.1 不存在变量提升 // var 的情况 console.log(foo); // 输出undefined var foo = 2;
// let 的情况 console.log(bar); // 报错ReferenceError let bar = 2;
1.2 暂时性死区：es6中let声明的变量就会形成独有的作用域，如果在之前使用和调用就会报错。总之，在let声明变量之前，该变量是不可用的，所以声明之前就是死区， 语法上称为暂时性死区。死区让typeof也不安全 var tmp = 123;
if (true) { tmp = 'abc'; // ReferenceError let tmp; }
1.3 不允许重复声明 // 报错 function func() { let a = 10; var a = 1; }
// 报错 function func() { let a = 10; let a = 1; } 因此，不能在函数内部重新声明参数。 function func(arg) { let arg; } func() // 报错
function func(arg) { { let arg; } } func() // 不报错
1.4 块级作用域必须有大括号
const:声明一个只读的常量，一旦声明就必须得立即初始化。 和let一样有块级作用域，有暂时性死区，没声明之前都是死区，不可重复声明
本质：const保存的是变量指向的那个内存地址所保存的数据不得改动。对于简单型数据（数值，字符和布尔值），值就保存在变量指向的那个内存地址。等同于常量。但对于复合型数据指对象和数组，变量指向的内存地址实际是一个指向实际数据的指针，const只能保证指针是固定的，至于指向他的数据结构就不能控制。所以const对象要小心。 const foo = {};
// 为 foo 添加一个属性，可以成功 foo.prop = 123; foo.prop // 123
// 将 foo 指向另一个对象，就会报错 foo = {}; // TypeError: "foo" is read-only
如果真的想将对象冻结，应该使用Object.freeze方法。
es6有6中声明变量的方式：let const import class var function
es6开始将全局变量和顶层对象的属性脱钩 var a = 1; // 如果在 Node 的 REPL 环境，可以写成 global.a // 或者采用通用方法，写成 this.a window.a // 1
let b = 1; window.b // undefined
2 变量的解构赋值 2.1数组： let [x = 1, y = x] = []; // x=1; y=1 let [x = 1, y = x] = [2]; // x=2; y=2 let [x = 1, y = x] = [1, 2]; // x=1; y=2 let [x = y, y = 1] = []; // ReferenceError: y is not defined 2.2对象： 对象跟数组的区别是数组是按顺序的，对象属性名称必须 let { bar, foo } = { foo: 'aaa', bar: 'bbb' }; foo // "aaa" bar // "bbb"
let { baz } = { foo: 'aaa', bar: 'bbb' }; baz // undefined
对象的解构赋值可以取到继承的属性 const obj1 = {}; const obj2 = { foo: 'bar' }; Object.setPrototypeOf(obj1, obj2);
const { foo } = obj1; foo // "bar" 2.3字符串：可以解构赋值是因为可以转为数组 const [a, b, c, d, e] = 'hello'; a // "h" b // "e" c // "l" d // "l" e // "o" 类似数组所以还有一个length属性，所以也可以对属性进行解构赋值。 let {length:len}='hello' 2.4数值和布尔：转为对象可以解构赋值 但undefined和null都不能转为对象，所以他们解构赋值会出错 注意： 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] 指定x,y的默认值 function move({x, y} = { x: 0, y: 0 }) { return [x, y]; }
move({x: 3, y: 8}); // [3, 8] move({x: 3}); // [3, undefined] move({}); // [undefined, undefined] move(); // [0, 0] 指定的是参数的默认值而不是x，y的默认值 undefined就会触发函数参数的默认值。 [1, undefined, 3].map((x = 'yes') => x); // [ 1, 'yes', 3 ]
解构赋值的作用； a:交换变量 let x = 1; let y = 2; [x, y] = [y, x]; b:从函数中返回多个值 // 返回一个数组 function example() { return [1, 2, 3]; } let [a, b, c] = example();
// 返回一个对象 function example() { return { foo: 1, bar: 2 }; } let { foo, bar } = example(); c:提取json数据
3 数组的拓展 应用： a：复制数组 const a=[1,2] const b =[...a] b:合并数组 const a=[1,2] const b=[3,4] const c=[...a,...b]
Array.from方法用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括 ES6 新增的数据结构 Set 和 Map） let arrayLike = { '0': 'a', '1': 'b', '2': 'c', length: 3 };
// ES5的写法 var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']
// ES6的写法 let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']
//用Object。values（）返回所有value let arr3 = Object。values（arrayLike）；//['a','b','c',3] Array.of方法用于将一组值，转换为数组。
数组实例的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]
上面代码表示将从 3 号位直到数组结束的成员（4 和 5），复制到从 0 号位开始的位置，结果覆盖了原来的 1 和 2。
数组实例的find方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。
[1, 4, -5, 10].find((n) => n < 0) // -5
数组实例的findIndex方法的用法与find方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。
[1, 5, 10, 15].findIndex(function(value, index, arr) { return value > 9; }) // 2
fill方法使用给定值，填充一个数组。
['a', 'b', 'c'].fill(7) // [7, 7, 7]
new Array(3).fill(7) // [7, 7, 7]
上面代码表明，fill方法用于空数组的初始化非常方便。数组中已有的元素，会被全部抹去。
fill方法还可以接受第二个和第三个参数，用于指定填充的起始位置和结束位置。
['a', 'b', 'c'].fill(7, 1, 2) // ['a', 7, 'c']
上面代码表示，fill方法从 1 号位开始，向原数组填充 7，到 2 号位之前结束。
ES6 提供三个新的方法——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"
Array.prototype.includes方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。ES2016 引入了该方法。
[1, 2, 3].includes(2) // true [1, 2, 3].includes(4) // false [1, 2, NaN].includes(NaN) // true [NaN].indexOf(NaN) // -1
数组的成员有时还是数组，Array.prototype.flat()用于将嵌套的数组“拉平”，变成一维的数组。该方法返回一个新数组，对原数据没有影响。 [1, 2, [3, [4, 5]]].flat() // [1, 2, 3, [4, 5]]
[1, 2, [3, [4, 5]]].flat(2) // [1, 2, 3, 4, 5] 如果不管有多少层嵌套，都要转成一维数组，可以用Infinity关键字作为参数。 [1, [2, [3]]].flat(Infinity) // [1, 2, 3]
