数组的解构赋值
ES6规定以一定模式从数组、对象中提取值，然后给变量赋值叫做解构。
本质上就是一种匹配模式，等号两边模式相同，左边的变量就能对应的值。
假如解构不成功会赋值为undefined。
不需要匹配的位置可以置空
let [ a, b, c] = [1, 2, 3];
// a = 1
// b = 2
// c = 3let [, , d] = [1, 2, 3];
// d = 31. 不完全解构
指的是左侧只能匹配右侧一部分模式，这种情况叫做不完全解构。
let [x, y] = [1, 2, 3];
// x = 1; y = 22. 等号右侧不是数组
如果等于右侧不是数组会报错
let [foo] = 1; // 报错
let [foo] = true; // 报错
在执行时会先转化，其实只要数据结构具有Iterator接口，都能解构。
3. 嵌套解构
4. 默认值
解构时可以设置一个默认值，假如解构不成功时可以使用默认值，否则会报错。
只有解构时值为undefined，才会使用默认值。
let [ x = 1] = [];
// x = 1
这里结构变量x时，不存在但是给定默认值为1。
let [x, y = 1] = ['a'];
// x = 'a' y = 1let [x = 1] = [undefined];
// x = 1let [x = 1] = [null];
// x = 1
默认值也可以是表达式、其他变量
如果是表达式，只有使用时才会进行计算求值，否则不会主动计算。
function foo() {return 2;
}
let [x = foo()] = [1]; // 1
let [x = foo()] = [undefined]; // 2
第一个解构时不会执行foo函数，因为解构能成功，第二个解构的值为undefined，所以会执行foo函数。
对于其他变量，必须保证变量是已经存在的。
let [x = 1, y = x] = []; // x = 1; y = 1
let [x = 1, y = x] = [2]; // x = 2; y = 2
let [x = 1, y = x] = [2, 3]; // x = 2; y = 3
let [x = y, y = 1] = []; // 报错
最后一个会报错是因为，y还没有声明呢，就直接使用了。
对象的解构赋值
对象的解构不必像数组那样按顺序排列，只要变量与属性名一致就能获取到值，对于取不到值的会被赋值为undefined。
let { foo, bar } = { foo: 'a', bar: 'b'};
// foo = 'a'; bar = 'b'let { baz } = { foo: 'a', bar: 'b'};
// baz = undefined 不存在
对于属性名不一致可以使用冒号连接，冒号左边表示匹配的模式，这个模式要与解构的对象的属性名一致，冒号有侧就是自定义的变量名。
对象的解构本质就是通过冒号，左侧进行查找，右侧被真正赋值，只不过平时左侧、右侧名称一致，简写了而已。
let { foo: baz } = { foo: 'a', bar: 'b'};
// baz = 'a'
1. 嵌套解构
let obj = {p: ['hello', { y: 'world'}]
}
let { p: [x, {y}]} = obj;
// x = 'hello'
// y = 'world'
这里的p是匹配模式，并不是变量
2. 默认值
只有对象的属性值为undefined时，默认值才能生效。
let { x = 3 } = {};
// x = 3
对象的解构赋值可以很方便地将现有对象的方法赋值给某个变量。
let { log, sin, cos } = Math;
数组是特殊的对象，可以对数组进行对象属性结构，以数组的index。
let arr = [1, 2, 3];
let { 0: first, [arr.length - 1 ]:last } = arr;
// first = 1; last = 3
字符串的解构赋值
字符串也能解构，也解构成一个类似数组的对象。
不需要匹配的位置可以置空
let [a, b] = 'world';
// a = 'w'; b = 'o'let [a, , b] = 'world';
// a = 'w'; b = 'r'
类似数组的对象都有一个length属性，所以可以对length属性进行解构
let { length: len } = 'hello';
// len = 5
数值和布尔类型解构
解构赋值时，等号右侧只要不是对象或者数组，就会先转为对象
let { toString: s } = 123;
s === Number.prototype.toString // true
函数参数的解构
函数的参数也能进行解构，也能使用默认值。
function add ({x, y}) {return x + y;
}
add(1, 2); // 3function boo({x = 1, y = 2}) {return x + y;
}
add()
括号问题
正常解构是声明变量并且赋值，假如说变量已经声明成功，直接赋值，这时需要有所注意。
解构赋值虽然很方便，但是解析起来不容易。对于编译器来说，一个式子到底是模式还是表达式，没有办法从一开始就知道，必须解析到(或者解析不到)等号才知道，所以ES6规定，为了不导致歧义，不要使用圆括号。
let x;
{x} = {x:1};
// 报错
因为js会把{x}当做一个代码块，而不是变量，从而发生语法错误。
1. 不能使用圆括号的情况
- 变量声明语句
会导致全部报错
let [ (a) ] = [1];
let { x: (c) } = {};
let ({ x: c }) = {};
let { (x: c) } = {};
let { (x): c } = {};let { o: ({ p:p }) } = { o: { p: 2 } };
- 函数参数
函数的参数属于变量声明，不能使用圆括号
function f([(z)]) {return z;
}
- 赋值语句的模式
({ p:a }) = { p: 42 };
([a]) = [5];
[({ p: a }), {x: c }] = [{}, {}];
不管是一部分模式还是全部模式都放在括号里面，都会报错。
2. 可以使用圆括号
赋值语句的非模式部分可以使用圆括号
[(b)] = [3];
({ p: (d) } = {});
[(parseInt.prop)] = [3];
用途
交换变量的值
let x = 1;
let y = 2;
[x, y] = [y, x];
// x = 2; y = 1
从函数返回多个值
函数只能返回一个值，如果真要返回多个只能放在数组和对象中，但是使用解构赋值就很方便。
function example() {return [1, 2, 3];
}
let [a, b, c] = example();
函数参数的定义
解构赋值可以方便地将一组参数与变量名对应起来。
// 参数是一组有次序的值
function f([x, y, z]) {}
f([1, 2, 3]);
// 参数是一组无次序的值
function f([x, y, z]) {}
f([z: 1, y: 2, x: 3]);
提取JSON数据
函数参数的默认值
在之前函数要是有默认值时，需要加判断，很不方便。
之前的
function foo(x) {var y;if(x != undefined) {y = '默认值';}y = x;
}
foo();
现在直接使用解构赋值，添加默认值就可以
function foo(x = '默认值') {}
foo();
变量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 helllo
// second is world
获取键名
for(let [key] of map) {// ...
}
获取键值
for (let [, value] of map) {// ...
}
输入模块的指定方法
加载模块时，汪汪需要指定输入的方法，则使用解构赋值使输入语句清晰
// 现在
const { SourceMapConsumer, SourceNode } = require('source-map');// 之前
const sourceMap = require('source-map');
const SourceMapConsumer = sourceMap.SourceMapConsumer();
const SourceNode = sourceMap.SourceNode();
