数组的结构赋值
以前，为变量赋值，只能直接指定值：
1 let a = 1; 2 let b = 2; 3 let c = 3;
ES6可以写成下面这样：
1 let [a, b, c] = [1, 2, 3];
本质上，这种写法属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值。下面是一些使用嵌套数组进行解构的例子。
1 let [foo, [[bar], baz]] = [1, [[2], 3]]; 2 foo // 1 3 bar // 2 4 baz // 3 5 6 let [ , , third] = ["foo", "bar", "baz"]; 7 third // "baz" 8 9 let [x, , y] = [1, 2, 3]; 10 x // 1 11 y // 3 12 13 let [head, ...tail] = [1, 2, 3, 4]; 14 head // 1 15 tail // [2, 3, 4] 16 17 let [x, y, ...z] = ['a']; 18 x // "a" 19 y // undefined 20 z // []
默认值
解构赋值允许指定默认值
1 let [foo = true] = []; 2 foo // true 3 4 let [x, y = 'b'] = ['a']; // x='a', y='b' 5 let [x, y = 'b'] = ['a', undefined]; // x='a', y='b'
注意，ES6 内部使用严格相等运算符（===），判断一个位置是否有值。所以，只有当一个数组成员严格等于undefined，默认值才会生效。
对象的解构赋值
对象的解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值由它的位置决定；而对象的属性没有次序，变量必须与属性同名，才能取到正确的值。
1 let { bar, foo } = { foo: "aaa", bar: "bbb" }; 2 foo // "aaa" 3 bar // "bbb" 4 5 let { baz } = { foo: "aaa", bar: "bbb" }; 6 baz // undefined
如果变量名与属性名不一致，必须写成下面这样。
1 let { foo: baz } = { foo: 'aaa', bar: 'bbb' }; 2 baz // "aaa" 3 4 let obj = { first: 'hello', last: 'world' }; 5 let { first: f, last: l } = obj; 6 f // 'hello' 7 l // 'world'
也就是说，对象的解构赋值的内部机制，是先找到同名属性，然后再赋给对应的变量。真正被赋值的是后者，而不是前者。
1 let { foo: baz } = { foo: "aaa", bar: "bbb" }; 2 baz // "aaa" 3 foo // error: foo is not defined
上面代码中，foo是匹配的模式，baz才是变量。真正被赋值的是变量baz，而不是模式foo。
与数组一样，解构也可以用于嵌套结构的对象。
1 let obj = { 2 p: [ 3 'Hello', 4 { y: 'World' } 5 ] 6 }; 7 8 let { p: [x, { y }] } = obj; 9 x // "Hello" 10 y // "World"
注意，这时p是模式，不是变量，因此不会被赋值。如果p也要作为变量赋值，可以写成下面这样。
1 let obj = { 2 p: [ 3 'Hello', 4 { y: 'World' } 5 ] 6 }; 7 8 let { p, p: [x, { y }] } = obj; 9 x // "Hello" 10 y // "World" 11 p // ["Hello", {y: "World"}]
下面是另一个例子。
1 const node = { 2 loc: { 3 start: { 4 line: 1, 5 column: 5 6 } 7 } 8 }; 9 10 let { loc, loc: { start }, loc: { start: { line }} } = node; 11 line // 1 12 loc // Object {start: Object} 13 start // Object {line: 1, column: 5}
上面代码有三次解构赋值，分别是对loc、start、line三个属性的解构赋值。注意，最后一次对line属性的解构赋值之中，只有line是变量，loc和start都是模式，不是变量。
对象的解构也可以指定默认值。
1 var {x = 3} = {}; 2 x // 3 3 4 var {x, y = 5} = {x: 1}; 5 x // 1 6 y // 5 7 8 var {x: y = 3} = {}; 9 y // 3 10 11 var {x: y = 3} = {x: 5}; 12 y // 5 13 14 var { message: msg = 'Something went wrong' } = {}; 15 msg // "Something went wrong"
默认值生效的条件是，对象的属性值严格等于undefined。
var {x = 3} = {x: undefined}; x // 3 var {x = 3} = {x: null}; x // null
字符串的解构赋值
字符串也可以解构赋值。这是因为此时，字符串被转换成了一个类似数组的对象。
1 const [a, b, c, d, e] = 'hello'; 2 a // "h" 3 b // "e" 4 c // "l" 5 d // "l" 6 e // "o"
数值和布尔值的解构赋值
解构赋值时，如果等号右边是数值和布尔值，则会先转为对象。
1 let {toString: s} = 123; 2 s === Number.prototype.toString // true 3 4 let {toString: s} = true; 5 s === Boolean.prototype.toString // true
函数参数的解构赋值
1 function add([x, y]){ 2 return x + y; 3 } 4 5 add([1, 2]); // 3
上面代码中，函数add的参数表面上是一个数组，但在传入参数的那一刻，数组参数就被解构成变量x和y。对于函数内部的代码来说，它们能感受到的参数就是x和y。
变量解构赋值的用途
（1） 交换变量的值
1 let x = 1; 2 let y = 2; 3 4 [x, y] = [y, x];
上面代码交换变量x和y的值，这样的写法不仅简洁，而且易读，语义非常清晰。
（2）从函数返回多个值
函数只能返回一个值，如果要返回多个值，只能将它们放在数组或对象里返回。有了解构赋值，取出这些值就非常方便。
1 // 返回一个数组 2 3 function example() { 4 return [1, 2, 3]; 5 } 6 let [a, b, c] = example(); 7 8 // 返回一个对象 9 10 function example() { 11 return { 12 foo: 1, 13 bar: 2 14 }; 15 } 16 let { foo, bar } = example();
（3）函数参数的定义
解构赋值可以方便地将一组参数与变量名对应起来。
1 // 参数是一组有次序的值 2 function f([x, y, z]) { ... } 3 f([1, 2, 3]); 4 5 // 参数是一组无次序的值 6 function f({x, y, z}) { ... } 7 f({z: 3, y: 2, x: 1});
（4）提取 JSON 数据
解构赋值对提取 JSON 对象中的数据，尤其有用
1 let jsonData = { 2 id: 42, 3 status: "OK", 4 data: [867, 5309] 5 }; 6 7 let { id, status, data: number } = jsonData; 8 9 console.log(id, status, number); 10 // 42, "OK", [867, 5309]
（5）函数参数的默认值
1 jQuery.ajax = function (url, { 2 async = true, 3 beforeSend = function () {}, 4 cache = true, 5 complete = function () {}, 6 crossDomain = false, 7 global = true, 8 // ... more config 9 } = {}) { 10 // ... do stuff 11 };
指定参数的默认值，就避免了在函数体内部再写var foo = config.foo || 'default foo';这样的语句。
（6）遍历 Map 结构
任何部署了 Iterator 接口的对象，都可以用for...of循环遍历。Map 结构原生支持 Iterator 接口，配合变量的解构赋值，获取键名和键值就非常方便。
1 const map = new Map(); 2 map.set('first', 'hello'); 3 map.set('second', 'world'); 4 5 for (let [key, value] of map) { 6 console.log(key + " is " + value); 7 } 8 // first is hello 9 // second is world
如果只想获取键名，或者只想获取键值，可以写成下面这样。
1 // 获取键名 2 for (let [key] of map) { 3 // ... 4 } 5 6 // 获取键值 7 for (let [,value] of map) { 8 // ... 9 }
（7）输入模块的指定方法
加载模块时，往往需要指定输入哪些方法。解构赋值使得输入语句非常清晰
1 const { SourceMapConsumer, SourceNode } = require("source-map");