2019-01-28

1.数组的解构赋值

2.对象的解构赋值

解构不仅可以用于数组，还可以用于对象

let{ foo,bar }={ foo:"aaa", bar:"bbb"};
foo //aaa
bar //bbb
//等号左边和右边的两个同名属性的次数不一样，但是对取值完全没影响

let{ baz } = {foo:"aaa", bar:"bbb"}
baz //undefined
//变量没有对应的同名属性，导致取不到值

如果变量名与属性名不一致，必须得这样写：

let{ foo:baz } = { foo:'aaa', bar:'bbb' };
baz // 'aaa'

let obj = {first:'hello', last:'world'};
let { first:f , last:1 }=obj;
f //hello
l //world

//实际上说明，对象的解构赋值是下面形式的简写
let { foo:foo,bar:bar } = { foo:'aaa',bar:'bbb' };
//就是说，对象的解构赋值的内部机制，是先找到同名属性，然后再赋给对应的变量

真正被赋值的是后者，而不是前者

let { foo:baz } = { foo:"aaa", bar:"bbb" };
baz //aaa
foo // error:foo is defined

//foo是匹配的模式，baz才是变量
//真正被赋值的事变量baz，而不是模式foo

与数组一样，解构也可以用于嵌套结构的对象：

let obj = {
    p:[
        'Hello',
        {y:'World'}
    ]
};

let { p:[x,{ y }]  } = obj;
x // Hello
y // World

//此时p是模式，不是变量，因此不会被赋值。
//如果要p也作为变量赋值，可以这样写：
let { p,p:[x,{ y }]  } = obj;
p //["Hello",{y:"World"}]

const node = {
      loc:{
            start:{
                line:1,
                column:5
            }
      }
};

let{loc,loc:{ start }, loc:{ start:{ line }} } = node;
line //1
loc //Object{start:Object}
start //Object{line:1,column:5}
//最后一次对line属性的解构赋值之中，只有line是变量，loc和start都是模式，不是变量

嵌套赋值的例子：

let obj = {};
let arr = [];

({ foo:obj.prop,bar:arr[0] } = { foo:123,bar:true });
obj // {prop:123}
arr // [true]

对象的解构也可以指定默认值

var { x=3 } = {};
x//3

var { x,y=5 } = { x:1 };
x//1
y//5

var { x:y=3 } = {};
y //3

var { x:y=3 } = {x:5};
y //5

var { message:msg = 'Something went wrong' } = {};
msg //'Something went wrong' 

//但是默认值生效的条件是，对象的属性值严格等于undefined

var { x=3 } = { x:undefined };
x //3

var { x=3 } = { x:null };
x //null
//x等于null，因为null与undefined不严格相等，所以是个有效的赋值，导致默认值3不会生效

◆ 如果解构失败的话，变量的值就等于undefined

let {foo}={bar:'baz'};
foo //undefined

◆ 如果解构模式是嵌套的对象，而且子对象所在的父属性不存在，那么将会报错
let { foo:{bar} }={baz:'baz'}; //报错

◆ 如果将一个已经声明的变量用于解构赋值就得小心了

//错误的写法
let x;
{x} = {x:1};
//报错的原因是因为Javascript引擎会将{x}理解成一个代码块，从而发生语法错误

//正确的写法
({x}={x:1});

解构赋值允许等号左边的模式之中，不放置任何变量名，虽然表达式毫无意义，但是语法是合法的，可以执行：

({ } = [true,false]);
({ } = 'abc');
({ } = [ ]);

3.字符串的解构赋值

字符串也可以解构赋值，因为字符串被转换成了一个类似数组的对象：

const [ a,b,c,d,e ] = 'hello';
a // 'h'
b // 'e'
c // 'l'
d // 'l'
e // 'o'

//类似数组的对象都有一个length属性，因为可以对这个属性解构赋值
 let { length :len } = 'hello';
len //5

4.数值和布尔值的解构赋值

解构赋值时，如果等号右边是数值和布尔值，则会先转为对象。

let { toString:s } = 123;
s === Number.prototype.toString //true

let { toString:s } = true;
s === Boolean.prototype.toString //true
//上面代码中，数值和布尔值的包装对象都有toString属性，因此变量s都能取到值。

解构赋值的规则是，只要等号右边的值不是对象或数组，就先将其转为对象。
由于undefined和null无法转为对象，所以对它们进行解构赋值都会报错：

let { prop:x }=undefined;  //TypeError
let { prop:y } = null;  //TypeError