ES6中变量的解构赋值

ES6中变量的解构赋值
1 数组的解构赋值
2 对象的解构赋值
3 字符串的解构赋值
4 数值和布尔值的解构赋值（先转为对象）
5 函数参数的解构赋值

不能使用圆括号
1 变量声明语句
2 函数参数
3 赋值语句的模式

可以使用圆括号
只有一种情况就是赋值语句是非模式

用途
（1）交换变量的值
（2）从函数返回多个值
（3）函数参数的定义
（4）提取 JSON 数据
（5）函数参数的默认值
（6）遍历 Map 结构

// 获取键名
for (let [key] of map) {
  // ...
}

// 获取键值
for (let [,value] of map) {
  // ...
}

（7）输入模块的指定方法

const { SourceMapConsumer, SourceNode } = require("source-map");

数组的解构赋值

//数组的解构赋值
             let [a,b,c] = [1,2,3]; //左右两边结构必须保持一致
             console.log(a,b,c); //1 2 3
             let [a,[b,c],d] = [1,[2,3],4];
             console.log(a,b,c,d); //1 2 3 4
        
        //如果左右两边结构不一致，解构不成功就会报undefined
             let [a,b,c] = [1,2];
             console.log(a,b,c) //1 2 undefined
        //如果等号右边不是数组，那么就会报错
             let [a] = 1;
             let [a] = false;
             let [a] = NaN;
             let [a] = {};
             let [a] = null;
             let [a] = undefined;
             上面这几种都是等号右边不是数组，都会报错（Uncaught TypeError: 上面等号右边的值 is not iterable）
        //允许有默认值
             let [a = 1] = [];
             console.log(a);  //1
             let [a=1,b] = ['ok','yes'];
             console.log(a,b); //ok yes

对象的解构赋值

 //对象的解构赋值
            let {a,b} = {a:'haha',b:'hhh'};
            console.log(a); //haha
            console.log(b); //hhh
            let obj = {
                a:'你好',
                b:{
                    c:'好啊',
                    d:'很好'
                }
            };
            let {a,b,b:{c,d}} = obj;
            console.log(a); //你好
            console.log(b); //Object{c: "好啊", d: "很好"}
            console.log(c); //好啊
            console.log(d); //很好
        
        //允许指定默认值
            let {a=1} = {};
            console.log(a); //1
            let {a,b=1} = {a:2};
            console.log(a); //2
            console.log(b); //1

字符串解构赋值

//字符串解构赋值
            let [a,b,c,d,e] = 'hello';
            console.log(a); //h
            console.log(b); //e
            console.log(c); //l
            console.log(d); //l
            console.log(e); //o
        //此时字符串被转换成了一个类似数组的对象

函数参数解构赋值

//函数参数解构赋值
            function got({a=0,b=0} = {}){
                return [a,b];
            }
            console.log(got({a: 1,b: 2})); //[1, 2]
            console.log(got({a: 1})); //[1, 0]
            console.log(got()); //[0, 0]
            //上面代码中，函数got的参数是一个对象，通过对这个对象进行解构，得到变量a和b的值。如果解构失败，a和b等于默认值。
    
            function got({a,b} = {a: 0,b: 0}){
                return [a,b];
            }
            console.log(got({a: 1,b: 2})); //[1, 2]
            console.log(got({a: 1})); //[1, undefined]
            console.log(got()); //[0, 0]
            //上面代码是为函数got的参数指定默认值，而不是为变量a和b指定默认值，所以会得到与前一种写法不同的结果。