ES6

常用ES6语法

1. var let const区别

    在js中通常使用var，会发生变量提升，即脚本开始运行时，变量已经存在了，但是没有值，所以会输出undefined。
    let不会发生变量提升,这表示在声明它之前，变量是不存在的，这时如果用到它，就会抛出一个错误。
   

   {
       var a 
       let b
   }
   console.log(a)
   console.log(b)
   
   输出：
   undefined
   ReferenceError: b is not defined

2. var是函数级作用域，let是块级作用域

   for (let i = 0; i < 10; i++) {
       
   }
   console.log(i)
   输出： ReferenceError: i is not defined
   
   for (var i = 0; i < 10; i++) {
       
   }
   输出： 10

3. let不允许在相同作用域内，重复声明同一个变量

4. const声明一个只读的常量,一旦声明，常量的值就不能改变

5. const命令声明的常量也是不提升，只能在声明的位置后面使用

6. const声明的常量，也与let一样不可重复声明

7. 对于复合类型的变量，变量名不指向数据，而是指向数据所在的地址。

const命令只是保证变量名指向的地址不变，并不保证该地址的数据不变，所以将一个对象声明为常量必须非常小心。

解构赋值

• 解构赋值是对赋值运算符的扩展

• 是一种针对数组或者对象进行模式匹配，然后对其中的变量进行赋值。

• 在代码书写上简洁且易读，语义更加清晰明了；也方便了复杂对象中数据字段获取。

  1. 数组模型的解构（Array）

  基本
  let [a, b, c] = [1, 2, 3];
   // a = 1
   // b = 2
   // c = 3
  可嵌套
  let [a, [[b], c]] = [1, [[2], 3]];
   // a = 1
   // b = 2
   // c = 3
   可忽略
   let [a, , b] = [1, 2, 3];
   // a = 1
   // b = 3
   不完全解构
   let [a = 1, b] = []; 
   // a = 1, b = undefined
   let [a, ...b] = [1, 2, 3];
   剩余运算符
   //a = 1
   //b = [2, 3]
  
   字符串等
   在数组的解构中，解构的目标若为可遍历对象，皆可进行解构赋值。可遍历对象即实现 Iterator 接口的数据。
   let [a, b, c, d, e] = 'hello';
   // a = 'h'
   // b = 'e'
   // c = 'l'
   // d = 'l'
   // e = 'o'
   解构默认值
   let [a = 2] = [undefined]; 
   // a = 2
   当解构模式有匹配结果，且匹配结果是 undefined 时，会触发默认值作为返回结果。
   let [a = 3, b = a] = [];     // a = 3, b = 3
   let [a = 3, b = a] = [1];    // a = 1, b = 1
   let [a = 3, b = a] = [1, 2]; // a = 1, b = 2

  2. 对象模型的解构（Object）

  基本
  let { foo, bar } = { foo: 'aaa', bar: 'bbb' };
   // foo = 'aaa'
   // bar = 'bbb'
   
   let { baz : foo } = { baz : 'ddd' };
   // foo = 'ddd'
  
  可嵌套可忽略
  let obj = {p: ['hello', {y: 'world'}] };
  let {p: [x, { y }] } = obj;
   // x = 'hello'
   // y = 'world'
  let obj = {p: ['hello', {y: 'world'}] };
  let {p: [x, {  }] } = obj;
   // x = 'hello' 
   
  不完全解构
  let obj = {p: [{y: 'world'}] };
  let {p: [{ y }, x ] } = obj;
   // x = undefined
   // y = 'world'
  
  剩余运算符
  let {a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40};
   // a = 10
   // b = 20
   // rest = {c: 30, d: 40}
  
  解构默认值
   let {a = 10, b = 5} = {a: 3};
   // a = 3; b = 5;
   let {a: aa = 10, b: bb = 5} = {a: 3};
   // aa = 3; bb = 5;

  函数

• 箭头函数
  箭头函数提供了一种更加简洁的函数书写方式。基本语法是： 参数 => 函数体

  基本用法：

  var f = v => v;
  //等价于
  var f = function(a){
    return a;
  }
  f(1);  //1

  当箭头函数没有参数或者有多个参数，要用 () 括起来。

  当箭头函数函数体有多行语句，用 {} 包裹起来，表示代码块，当只有一行语句，并且需要返回结果时，可以省略 {} , 结果会自动返回。

  当箭头函数要返回对象的时候，为了区分于代码块，要用 () 将对象包裹起来