*,html { font-size: 16px }
一、数组的解构赋值
基本用法
ES6允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构。
下面的代码表示，可以从数组中提取值，按照位置的对应关系对变量赋值。这种写法属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值。
var [a,b,c]=[1,2,3] a // 1 b // 2 c // 3
let [foo,[[bar],baz]]=[1,[[2],3]]; foo //1 bar //2 baz //3
let [,,third]=[‘foo‘,‘bar‘,‘baz‘]; third // ‘baz‘
let [x, ,y]=[1,2,3]; x // 1 y // 3
let [head,...tail]=[1,2,3,4]; head // 1 tail // [2,3,4]
let [x,y,...z]=[‘a‘]; x // ‘a‘ y // undefined z // []
如果解构不成功，变量的值就等于undefined。
另一种情况是不完全解构，即等号左边的模式只匹配等号右边数组的一部分。这种情况下，解构依然可以成功。
let [a,[b],d]=[1,[2,3],4]; a //1 b //2 d //4
如果等号的右边不是数组，或者严格地说，不是可遍历的结构，那么将会报错。下面的表达式都将报错。
let [foo]=1; let [foo]=false; let [foo]=NaN;
对于Set结构，也可以使用数组的解构赋值。
let [x,y,z]=new Set(["a","b","c"]); x // "a"
事实上，只要某种数据结构具有Iterator接口，都可以采用数组的形式解构赋值。
function* fibs(){
var a=0;
var b=1;
while(true){
yield a;
[a,b]=[b,a+b];
}
}
var [first,second,third,fourth,fifth,sixth]=fibs();
sixth //5
默认值
解构赋值允许指定默认值。注意ES6内部使用严格相等运算符（“===”）判断一个位置是否有值。所以，如果一个数组成员不严格等于undefined,默认值是不会生效的。
var [x,y=‘b‘]=[‘a‘] // x=‘a‘ y=‘b‘ var [x=1]=[undefined] // x=1 var [x=1]=[null] // x=null null不严格等于undefined，默认值不生效
如果默认值是一个表达式，那么这个表达式是惰性求值的，即只有在用到的时候才会求值。
function f(){
console.log(‘aaa‘);
}
let [x=f()]=[1];
上面的代码中，因为x能取到值，所以函数f根本不会执行。
默认值可以引用解构赋值的其他变量，但该变量必须已经声明。
let [x=1,y=2]=[] // x=1 y=2 let [x=1,y=x]=[2] // x=2 y=2 let [x=1,y=x]=[1,2] // x=1 y=2 let [x=y,y=1]=[] // ReferenceError x用到默认值y时，y还没有声明
二、对象的解构赋值
对象的解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值由它的位置决定；而对象的属性没有次序，变量必须与属性同名，才能取到正确的值。
var {bar,foo}={foo:‘aaa‘,bar:‘bbb‘};
foo // ‘aaa‘
bar // ‘bbb‘
var {baz}={foo:‘aaa‘,bar:‘bbb‘};
baz // undefined
等号左边的baz，bar,foo是变量名，等号右边的foo,bar是属性名
如果变量名与属性名不一致，必须写成下面这样
var {foo:baz}={foo:‘aaa‘,bar:‘bbb‘};
baz // ‘aaa‘
foo // error: foo is not defined
let obj={first:‘hello‘,last:‘world‘};
let {first:f,last:l}=obj;
f // ‘hello‘
l // ‘world‘
对象的解构赋值的内部机制，是先找到同名属性，然后再赋给对应的变量。真正被赋值的是后者，而不是前者。比如上面例子中，真真赋值的是baz而不是模式foo。
注意：采用这种写法时，变量的声明和赋值是一体的。对于let和const而言，变量不能重新声明，所以一旦赋值的变量以前声明过，就会报错。
let foo;
let {foo}={foo:1}; // SyntaxError:Duplicate declaration ‘foo‘
let baz;
let {bar:baz}={bar:1}; // SyntaxError:Duplicate declaration ‘baz‘
上面代码中解构赋值的变量都会重新声明，所以报错了。不过因为var命令允许重新声明，所以这个错误只会在使用let和const命令时出现。如果没有第二个let命令，上面的代码就不会报错。
let foo;
({foo}={foo:1}); // 成功 注意大括号
let baz;
({bar:baz}={bar:1}); // 成功 注意大括号
上面的代码是将一个已经声明的变量用于赋值，必须非常小心。
var x;
{x}={x:1}; // SynaxError: syntax error;
上面的代码写法会报错，因为JS引擎会将{x}理解成一个代码块，从而发生语法错误。只有不将大括号写在行首，避免JS将其解释为代码块，才能解决这个问题。
和数组一样，解构也可以用于嵌套结构的对象。
var obj={
p:[
"Hello",
{y:‘world‘}
]
};
var {p:[x,{y}]}=obj;
x // ‘Hello‘
y // ‘world‘
p // error: p is undefined
这时p是模式，不是变量，因此不会被赋值。
let obj={};
let arr=[];
({foo:obj.prop,bar:arr[0]}={foo:123,bar:true});
obj // {prop:123}
arr // [true]
对象的解构也可以指定默认值。默认值生效的条件是，对象的属性值严格等于undefined。
var {x,y=5}={x:1} // x=1 y=5
var {message:msg="somthing went wrong"}={};
msg // somthing went wrong
如果解构失败，变量的值就等于undefined。
如果解构模式是嵌套的对象，而且子对象所在的父属性不存在，那么就会报错。
var {foo:{bar}}={bar:‘baz‘} // 报错
等号左边对象的foo属性对应一个子对象。该子对象的bar属性解构时会报错。因为foo这时等于undefined，再取子属性就会报错
var temp={baz:‘baz‘};
temp.foo.bar // 报错
解构赋值允许等号左边的模式中不放置任何变量名。因此，可以写出非常古怪的赋值表达式。
({}=[true,false]);
({}=‘abc‘);
({}=[]);