在这先来个截点，最近过年放假各种事情忙东忙西的，学习也中断了，断断续续的，已经有点遗忘之前看过的知识要点了，再这重新复习一下：
之前学习的章节：
1、let和const命令
2、变量的解构赋值
3、函数的扩展

一、let和const

1、let

1. 一个大括号就是一个块级作用域，let声明的变量只在自己的作用域有效；
   2）es6严格模式下，变量未声明不能引用，不然会报错
   3）let不能重复声明
   4）let不存在变量提升

2、const

1）const声明之后必须赋值，否则编译不通过
2）const声明的值不允许修改

Javascript中，通常说的作用域是函数作用域，使用var声明的变量，无论是在代码的哪个地方声明的，都会提升到当前作用域的最顶部，这种行为叫做变量提升。

在ES5中，使用var去声明变量，var命令会发生“变量提升”现象，即变量可以在声明之前使用，值为undefined。一般逻辑中，变量应该在声明语句之中才可以使用

在ES6中，使用let和const声明变量，并且必须提前声明变量才可以使用

在ES5中只有全局作用域和函数作用域，没有块级作用域。而let则实际上为Javascript新增了块级作用及。用let声明的变量，只在let命令所在的代码块内有效。

Note：
const的作用域与let命令相同：只在声明所在的块级作用域内有效
const声明的变量不得改变值，这意味着，const一旦声明变量就会立即初始化，不能留到以后赋值
const命令声明的常量也是不提升，同样存在暂时性死区，只能在声明的位置后面使用
当前使用块级绑定的最佳实践是：默认使用const，只在确实需要改变变量时使用let

暂时性死区

只在块级作用域内存在let命令，它所声明的变量就绑定这个区域，不再受外部的影响
ES6明确规定，如果区块中存在let和const命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错。在使用let命令声明变量之前，该变量都是不可用的。这在语法上就成为“暂时性死区”

二、解构赋值

1、解构赋值：

{
  let a, b, rest;
  [a, b, rest] = [1, 2];
  console.log(a, b, rest);   //1 2 undefined
}

{
  let a, b, rest;
  [a, b, ...rest] = [1, 2, 3, 4, 5, 6, 7];
  console.log(a, b, rest);   //1 2 [3, 4, 5, 6, 7]
}

2、对象的解构赋值

let a,b;
({a,b} = {a:1,b:2});
console.log(a,b)//1 2

————————————————————————————————

数组的扩展

1、扩展运算符

扩展运算符是三个点（...）
它好比rest参数的逆运算，将一个数组转为用逗号分隔的参数序列

console.log(...[1,2,3])
//1 2 3
console.log(1, ...[2, 3, 4], 5)
//1 2 3 4 5

该运算符主要用于函数调用
扩展运算符与正常的函数参数可以结合使用，在扩展运算符后面也协议防止表达式：

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

如果扩展运算符后面是一个空数组，则不产生任何效果：

[...[],1]//[1]

注意，扩展运算符如果放在括号中，Javascript引擎就会认为这是函数调用。如果这时不是函数调用就会报错。

(...[1,2])
//Uncaught SyntaxError: Invalid destructuring assignment target
console.log((...[1,2]))
//Uncaught SyntaxError: Invalid destructuring assignment target
console.log(...[1,2]) //1 2

替代函数的apply方法

由于扩展运算符可以展开数组，所以不再需要apply方法，将数组转为函数的参数了。
下面是扩展运算符取代apply方法的一个时机的例子，应用Math.max方法，简化求出一个数组最大元素的写法：

//ES5
Math.max.apply(null,[14,3,77])

//ES6
Math.max(...[14,3,77])

//等同于
Math.max(14,3,77);

另外可以直接通过push函数，将一个数组添加到另一个数组的尾部

//ES5
var arr1=[0,1,2];
var arr2=[3,4,5];
Array.prototype.push.apply(arr1,arr2);

//ES6
let arr1=[0,1,2];
let arr2=[3,4,5];
arr1.push(...arr2);

在ES5的写法中，push方法的参数不能是数组，所以只好通过apply方法变通使用push方法。有了扩展运算符可以直接将数组传入push方法

扩展运算符的应用

1）复制数组

数组是复合的数据类型，直接复制的话，只是复制了指向底层数据结构的指针，而不是克隆一个全新的数组。
扩展运算符提供了复制数组的简便写法

const a1=[1,2];
//写法一
const a2=[...a1];
//写法二
const [...a2]=a1;

//这两种写法，a2都是a1的克隆，修改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 [...butLast, last] = [1, 2, 3, 4, 5];
// 报错

const [first, ...middle, last] = [1, 2, 3, 4, 5];
// 报错

4）字符串

扩展运算符还可以将字符串转为真正的数组

[...'hello']  // ["h", "e", "l", "l", "o"]

这样写的好处就是能够正确识别四个字节的Unicode字符

5）实现了Iterator接口的对象

任何定义了遍历器接口的对象都可以用扩展运算符转为真正的数组

let nodeList = document.querySelectorAll('div');
let array = [...nodeList];

上面代码中，querySelectorAll方法返回的是一个NodeList对象。它不是数组，而是一个类似数组的对象。这时，扩展运算符可以将其转为真正的数组，原因就在于NodeList对象实现了 Iterator 。

6）Map和Set结构，Generator函数

扩展运算符内部调用的是数据结构的Iterator接口，因此只要具有Iterator接口的对象，都可以使用扩展运算符，比如Map结构

let map = new Map([
  [1, 'one'],
  [2, 'two'],
  [3, 'three'],
]);

let arr = [...map.keys()]; // [1, 2, 3]