1.ES6介绍

1
ECMAScript 6.0（以下简称ES6）是JavaScript语言的下一代标准，已经在2015年6月正式发布了。它的目标，是使得JavaScript语言可以用来编写复杂的大型应用程序，成为企业级开发语言。

2.关于变量

var:

1.只有全局作用域变量和函数作用域变量
2.“变量提升”

let:

1、没有变量的提升，必须先声明后使用

2、let声明的变量，不能与前面的let，var，conset声明的变量重名

3、定义块级作用域变量

const ： 定义只读变量

1、const声明变量的同时必须赋值，const声明的变量必须初始化，一旦初始化完毕就不允许修改
2、const声明变量也是一个块级作用域变量
3、const声明的变量没有“变量的提升”，必须先声明后使用
4、const声明的变量不能与前面的let， var ， const声明的变量重名

3.解构赋值

对象的解构赋值：
1
2
3
4
5
6
//对象解构：对象解构不需要位置和数组解构位置一致，只要保证解构的变量名和属性一致即可。
 let {a,c}={c:4,a:2};
 console.log(a,c);
 //如果解构失败，变量赋值为undefined.
 let {acd}={f:2};
 console.log(acd);
  • 对象解构还有一个常用的功能，就是取js的一些方法，类似python的反射功能。
1
2
3
4
5
6
// 我们在使用对象解构的时候，可以获取对应的对象的方法类似有点想python的反射
    let {log}=console;
    log(222);
     //对象解构 上面的例子都是简写形式。实际上是如下：//也就是说：a是匹配的关键字 而真正的白能量是c.
    let {a:c}={a:2,c:4};
    console.log(c)
  • 对象解构嵌套解构对象，这种情况下对应嵌套的解构匹配属性不能省略。
1
2
3
//在解构的时候，我们也可以用在解构中嵌套解构对象，也就是说可以在对象解构中嵌套数组解构 这种情况嵌套对象的属性不能省略匹配的同名属性。
 let {ac:ac,ff:[c,a]}={ac:22,ff:[1,2]};
 console.log(ac,c,a);
数组的解构赋值：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//解构赋值：通过数组对应，对变量进行对应赋值。
 let [a,c,v,b]=[1,2,3,4];
 console.log(a,c,v,b);
 //这种赋值叫做 模式匹配。只要等号两边结构一样就可以进行赋值。
 let [k,[[n],d]]=[1,[[2],3]];
 console.log(k,n,d);
 //如果解构不成功，对应变量值为undefined;
 let [l,m]=[1];
 console.log(m);
 //不完全解构，如果等号左边没有全部匹配右边也是可以结构成功的。
 let [vv,vb,vc]=[1,2,3,4];
 console.log(vv,vb,vc);
 //变量结构需要等号右边需要itrator结构，也就是说具备可以被迭代。否则解构不成功。
 try {
     // let [cc]=2;//右边并不是数组 TypeError: 2 is not iterable
     let [dd]={};//不具备iteraor 所以解构也不成功。TypeError: {} is not iterable
 }catch (e) {
     console.log(e)
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 解构允许有默认值。
    let [a1,a2=2]=[1];
    console.log(a1,a2);
    // 需要注意的是在es6内部使用的是严格相等来判断一个位置是否有值。只有当数组中的成员严格等于undefined 默认值才能生效。
    // 如果默认值里是null，因为null不严格等于undefined 所有默认值也不会生效。
    let  [a=2]=[null];
    console.log(a);//a=null
    // 如果默认值是表达式，这个表达式是惰性求值。只有用到的时候才会求值。
    fn=()=>{
      return 2;
    };
    let [a=fn()]=[1];
console.log(a);
//只有a对应的右边的位置的值为undefined的时候，才会执行fn，否则不会执行相当于：
let x;
x=[1][0]===undefined?fn():[1][0];//只有在对应的右边的元素为undefined的时候才会计算表达式。和函数的默认为表达式也是惰性求值。
1
2
3
4
5
6
7
8
9
// 默认值也可以是其他结构解构的变量，但是对应的变量需要提前声明，否则会报错。
    try {
        let [ov,oc=ov]=[1];
        console.log(ov,oc);
        let [k1=k2,k2]=[undefined,2];
        console.log(k1,k2);//ReferenceError: Cannot access 'k2' before initialization
    }catch (e) {
        console.log(e)
    }