数组的解构赋值
//以前，为变量赋值，只能直接指定值。
var a = 1;
var b = 2;
var c = 3;
//ES6允许写成下面这样，=号左右和右边都必须是数组，如果不是会报错
var [a,b,c] = [1,2,3];
let [foo,[[bar],baz]] = [1,[[2],3]];
foo // 1
bar // 2
baz // 3
let [head,...tail] = [1,3,4];
console.log(head) // 1
console.log(tail) // [2,4]
//解构赋值允许指定默认值。
var [foo = true] = [];
console.log(foo) // true
var [x,y = 'b'] = ['a']; // x='a',y='b'
var [x,y = 'b'] = ['a',undefined]; // x='a',y='b'
//如果默认值是一个表达式，那么这个表达式是惰性求值的，即只有在用到的时候，才会求值。
function f() {
console.log('aaa');
}
let [x = f()] = [];
console.log(x);
//默认值可以引用解构赋值的其他变量，但该变量必须已经声明。
let [x = y,y = 1] = []; //ReferenceError x用到默认值y时，y还没有声明
对象的解构赋值
var { foo,bar } = { foo: "aaa",bar: "bbb" };
foo // "aaa"
bar // "bbb"
//对象的解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值由它的位置决定；而对象的属性没有次序，变量必须与属性同名，才能取到正确的值。
var { bar,foo } = { foo: "aaa",bar: "bbb" };
console.log(foo) // "aaa"
console.log(bar) // "bbb"
var { baz } = { foo: "aaa",bar: "bbb" };
console.log(baz) // undefined
//如果变量名与属性名不一致，必须写成下面这样。
var { foo: baz } = { foo: 'aaa',bar: 'bbb' };
console.log(baz) // "aaa"
let obj = { first: 'hello',last: 'world' };
let { first: f,last: l } = obj;
console.log(f) // 'hello'
console.log(l) // 'world'
//和数组一样，解构也可以用于嵌套结构的对象,这时p是模式，不是变量，因此不会被赋值
var obj = {
p: [
'Hello',{ y: 'World' }
]
};
var { p: [x,{ y }] } = obj;
x // "Hello"
y // "World"
//由于数组本质是特殊的对象，因此可以对数组进行对象属性的解构。
var arr = [1,3];
var {0 : first,[arr.length - 1] : last} = arr;
first // 1
last // 3
字符串解构赋值
const [a,c,d,e] = 'hello';
a // "h"
b // "e"
c // "l"
d // "l"
e // "o"
//类似数组的对象都有一个length属性，因此还可以对这个属性解构赋值。
let {length : len} = 'hello';
console.log(len) // 5
数值和布尔值的解构赋值
//解构赋值时，如果等号右边是数值和布尔值，则会先转为对象
let {toString: s} = 123;
s === Number.prototype.toString // true
let {toString: s} = true;
s === Boolean.prototype.toString // true
//由于undefined和null无法转为对象，所以对它们进行解构赋值，都会报错。
let { prop: x } = undefined; // TypeError
let { prop: y } = null; // TypeError
函数参数的解构赋值
function add([x,y]){
return x + y;
}
add([1,2]); // 3
function add([x = 1,y = 3] = []){
return x + y;
}
console.log(add()); // 3
用途
（1）交换变量的值
[x,y] = [y,x];
（2）从函数返回多个值
//函数只能返回一个值，如果要返回多个值，只能将它们放在数组或对象里返回。有了解构赋值，取出这些值就非常方便。
// 返回一个数组
function example() {
return [1,3];
}
var [a,c] = example();
// 返回一个对象
function example() {
return {
foo: 1,bar: 2
};
}
var { foo,bar } = example();
（3）函数参数的定义
解构赋值可以方便地将一组参数与变量名对应起来。
// 参数是一组有次序的值
function f([x,y,z]) { ... }
f([1,3]);
// 参数是一组无次序的值
function f({x,z}) { ... }
f({z: 3,y: 2,x: 1});
（4）提取JSON数据
解构赋值对提取JSON对象中的数据，尤其有用。
var jsonData = {
id: 42,status: "OK",data: [867,5309]
};
let { id,status,data: number } = jsonData;
console.log(id,number);
// 42,"OK",[867,5309]
（5）函数参数的默认值
//指定参数的默认值，就避免了在函数体内部再写var foo = config.foo || 'default foo';这样的语句。
jQuery.ajax = function (url,{
async = true,beforeSend = function () {},cache = true,complete = function () {},crossDomain = false,global = true,// ... more config
}) {
// ... do stuff
};
（6）遍历Map结构
//任何部署了Iterator接口的对象，都可以用for...of循环遍历。Map结构原生支持Iterator接口，配合变量的解构赋值，获取键名和键值就非常方便。
var map = new Map();
map.set('first','hello');
map.set('second','world');
for (let [key,value] of map) {
console.log(key + " is " + value);
}
// first is hello
// second is world
（7）输入模块的指定方法
加载模块时，往往需要指定输入那些方法。解构赋值使得输入语句非常清晰。
const { SourceMapConsumer,SourceNode } = require("source-map");
