ES6知识点（一）

1. let 和 const

在ES6以前，Javascript并没有块级作用域的概念，有的是全局作用域和函数作用域，而let的出现就是为了打破局面，let是块级作用域。const是代表常量，必须在定义的时候初始化，不可改变。

 {
     var a=5;
     let b=10;
 }
 console.log(a);
 console.log(b);

也就是说，var声明的变量由于不存在块级作用域所以可以在全局环境中调用，而let声明的变量由于存在块级作用域所以不能在全局环境中调用。
再来看一个经典例子（闭包）：

var a=[];
//执行for循环
for(var i=0;i<10;i++){
      a[i]=function(){ //因为这个是定义，并没有调用方法，不会执行
           console.log(i);
      };
}
//for循环之后，此时 i = 10；再次执行a[6]();因为 i 一直被引用，所以不会回收，进入到 a[i] 的方法里面， 打印的是 i ，也就是10
a[6](); //输出10

如果使用 let

  var a=[];
  for(let i=0;i<10;i++){
        a[i]=function(){
            console.log(i);
        };
    }
    a[6]();    //打印6

a[6]函数（闭包）这个执行环境中，它会首先寻找该执行环境中是否存在 i，没有找到，因为 i 是块级作用域，就沿着作用域链继续向上到了其所在的代码块执行环境，找到了i=6,于是输出了6，即a6;的结果为6。这时，闭包被调用，所以整个代码块中的变量i和函数a6被销毁。

const 是定义常量：const a = 14; 此后变量 a 的值无法更改覆盖。

2. 字符串拼接

//传统字符串拼接
var s1 = '生物膜系统组装又拆分，变幻莫测；';
var s2 = '你的好多细胞在分裂，';
var str = '孩子们：请听我说！'+s2+'有丝，减数，哪管白天和黑夜。'+
'染色体，细胞核时隐时现，'+s1+'核糖体在mRNA上穿梭忙碌，'+'几千种酶各司其职，将活化能狠狠打折。';
console.log(str);

// 字符模板的写法
var s1 = '染色体，细胞核时隐时现，';
var s2 = '你的好多细胞在分裂，';
var str = `孩子们：请听我说！${s2}有丝，减数，哪管白天和黑夜。${s1}生物膜系统组装又拆分，变幻莫测；核糖体在mRNA上穿梭忙碌，几千种酶各司其职，将活化能狠狠打折。`;
console.log(str);

es6使用 （ ）包裹字符串，即使断开，也可以用这个符号包裹起来合并成一个字符串。

3. 解构赋值

// 以前我们给变量赋值，只能直接指定值
var a = 1;
var b = 2;
var c = 3;
console.log(a,b,c); // 1 2 3

// 现在用解构赋值的写法就变得简单了，只要模式匹配上了就行了，如下
// 注意数组是有顺序的
var [a,b,c] = [11,22,33];
console.log(a,b,c); // 11 22 33

var [b,a,c] = [11,22,33];
console.log(a,b,c); // 22 11 33

// 当然解构赋值还有嵌套比较复杂的写法，如下
let [foo,[[bar],[baz]]] = [111,[[222],[333]]];
console.log(foo,bar,baz); // 111 222 333

let [head,...foot] = [1,2,3,4];
console.log(head,foot); // 1 [2,3,4]

// 如果解构不成功，变量的值就等于undefined，如下
var [bar3,foo3] = [1000];
console.log(bar3,foo3); // 1000 undefined

// 另一种情况是不完全解构，即等号左边的模式，只匹配一部分的等号右边的数组。这种情况下，解构依然可以成功
let [x,y] = [10000,20000,30000];
console.log(x,y); // 10000 20000

// 默认值可以引用解构赋值的其他变量，但该变量必须已经声明
let [a=1,b=a] = [2,3];
console.log(a,b); // 2 3

// 对象的解构也可以指定默认值
var {x,y=5} = {x:1};
console.log(x,y); // 1 5

//对象的解构赋值解构不仅可以用于数组，还可以用于对象(json)
//对象的解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值由它的位置决定；
//而对象的属性没有次序，变量必须与属性同名，才能取到正确的值
var {a,b} = {a:'apple',b:'banana'};
console.log(a,b); // apple banana
var {b,a} = {a:'apple',b:'banana'};
console.log(a,b); // apple banana

// 如果变量名与属性名不一致，必须写成下面这样
let obj = {first:'hello',last:'world'};
// first ---> f，那么此时f就是first，而不是undefined了,有点类似别名的概念
let {first:f,last} = obj;
console.log(f,last); // hello world

//1.也就是说，对象的解构赋值的内部机制，是先找到同名属性，然后再赋给对应的变量。 真正被赋值的是后者，而不是前者
//2.v是匹配的模式，n才是变量。真正被赋值的是变量n，而不是模式v。
//注意，采用这种写法时，变量的声明和赋值是一体的
// v ---> n，那么此时n就是vue，而不是undefined了
var {v:n} = {v:'vue',r:'react'};
console.log(n); // vue
console.log(v); // Uncaught ReferenceError: v is not defined
console.log(r); // Uncaught ReferenceError: r is not defined