1.字符串的重构表达式
基本上用语
ES6 容许依照很大商业模式，从字符串和第一类中抽取值，对表达式展开表达式，这被称作重构（Destructuring）。
从前，为表达式表达式，根本无法间接选定值。
let a = 1;
let b = 2;
let c = 3;
ES6 容许写出下面这种。
let [a, b, c] = [1, 2, 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 [foo] = [];
let [bar, foo] = [1];
以内三种情形都归属于重构不获得成功，foo的值单厢等同于undefined。
另一类情形是不全然重构，即等号左边的商业模式，只相匹配一小部分的等号左边的字符串。此种情形下，重构仍然能获得成功。
let [x, y] = [1, 2, 3];
x // 1
y // 2
let [a, [b], d] = [1, [2, 3], 4];
a // 1
b // 2
d // 4
下面两个范例，都归属于不全然重构，但是能获得成功。
假如等号的左边不是字符串（或者严格地说，不是可遍历的结构，参见《Iterator》一章），那么将会报错。
// 报错
let [foo] = 1;
let [foo] = false;
let [foo] = NaN;
let [foo] = undefined;
let [foo] = null;
let [foo] = {};
下面的语句单厢报错，因为等号左边的值，要么转为第一类以后不具备 Iterator 接口（前五个表达式），要么本身就不具备 Iterator 接口（最后一个表达式）。
对于 Set 结构，也能采用数组的重构表达式。
let [x, y, z] = new Set([a, b, c]);
x // “a”
事实上，假如某种数据结构具有 Iterator 接口，都能采用字符串形式的重构表达式。
function* fibs() {
let a = 0;
let b = 1;
while (true) {
yield a;
[a, b] = [b, a + b];
}
}
let [first, second, third, fourth, fifth, sixth] = fibs();
sixth // 5
下面标识符中，fibs是一个 Generator 函数（参见《Generator 函数》一章），原生具有 Iterator 接口。重构赋
默认值
重构表达式容许选定默认值。
let [foo = true] = [];
foo // true
let [x, y = b] = [a]; // x=a, y=b
let [x, y = b] = [a, undefined]; // x=a, y=b
注意，ES6 内部采用严格相等运算符（===），判断一个边线是否有值。所以，只有当一个字符串成员严格等同于undefined，默认值才会生效。
let [x = 1] = [undefined];
x // 1
let [x = 1] = [null];
x // null
下面标识符中，假如一个字符串成员是null，默认值就不会生效，因为null不严格等同于undefined。
假如默认值是一个表达式，那么这个表达式是惰性求值的，即只有在用到的时候，才会求值。
function f() {
console.log(aaa);
}
let [x = f()] = [1];
下面标识符中，因为x能取到值，所以函数f根本不会执行。下面的标识符其实等价于下面的标识符。
let x;
if ([1][0] === undefined) {
x = f();
} else {
x = [1][0];
}
默认值能引用重构表达式的其他表达式，但该表达式必须已经声明。
let [x = 1, y = x] = []; // x=1; y=1
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: y is not defined
下面最后一个表达式之所以会报错，是因为x用y做默认值时，y还没有声明。
2.第一类的重构表达式
简介
重构不仅能用于字符串，还能用于第一类。
let { foo, bar } = { foo: aaa, bar: bbb };
foo // “aaa”
bar // “bbb”
第一类的重构与字符串有一个重要的不同。字符串的元素是按次序排列的，表达式的取值由它的边线决定；而第一类的属性没有次序，表达式必须与属性同名，才能取到正确的值。
let { bar, foo } = { foo: aaa, bar: bbb };
foo // “aaa”
bar // “bbb”
let { baz } = { foo: aaa, bar: bbb };
baz // undefined
下面标识符的第一个范例，等号左边的两个表达式的次序，与等号左边两个同名属性的次序不一致，但是对取值全然没有影响。第二个范例的表达式没有相关联的同名属性，导致取不到值，最后等同于undefined。
假如重构失败，表达式的值等同于undefined。
let {foo} = {bar: baz};
foo // undefined
下面标识符中，等号左边的第一类没有foo属性，所以表达式foo取不到值，所以等同于undefined。
第一类的重构表达式，能很方便地将现有第一类的方法，表达式到某个表达式。
// 例一
let { log, sin, cos } = Math;
// 例二
const { log } = console;
log(hello) // hello
下面标识符的例一将Math第一类的对数、正弦、余弦三个方法，表达式到相关联的表达式上，采用起来就会方便很多。例二将console.log表达式到log表达式。
假如表达式名与属性名不一致，必须写出下面这种。
let { foo: baz } = { foo: aaa, bar: bbb };
baz // “aaa”
let obj = { first: hello, last: world };
let { first: f, last: l } = 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 not defined
下面标识符中，foo是相匹配的商业模式，baz才是表达式。真正被表达式的是表达式baz，而不是商业模式foo。
与字符串一样，重构也能用于冗余结构的第一类。
let obj = {
p: [
Hello,
{ y: World }
]
};
let { p: [x, { y }] } = obj;
x // “Hello”
y // “World”
注意，这时p是商业模式，不是表达式，因此不会被表达式。假如p也要作为表达式表达式，能写出下面这种。
let obj = {
p: [
Hello,
{ y: World }
]
};
let { p, p: [x, { y }] } = obj;
x // “Hello”
y // “World”
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}
下面标识符有三次重构表达式，分别是对loc、start、line三个属性的重构表达式。注意，最后一次对line属性的重构表达式之中，只有line是表达式，loc和start都是商业模式，不是表达式。
下面是冗余表达式的范例。
let obj = {};
let arr = [];
({ foo: obj.prop, bar: arr[0] } = { foo: 123, bar: true });
obj // {prop:123}
arr // [true]
假如重构商业模式是冗余的第一类，而且子第一类所在的父属性不存在，那么将会报错。
// 报错
let {foo: {bar}} = {baz: baz};
下面标识符中，等号左边第一类的foo属性，相关联一个子第一类。该子第一类的bar属性，重构时会报错。原因很简单，因为foo这时等同于undefined，再取子属性就会报错。
注意，第一类的重构表达式能取到继承的属性。
const obj1 = {};
const obj2 = { foo: bar };
Object.setPrototypeOf(obj1, obj2);
const { foo } = obj1;
foo // “bar”
下面标识符中，第一类obj1的原型第一类是obj2。foo属性不是obj1自身的属性，而是继承自obj2的属性，重构表达式能取到这个属性。
默认值
第一类的重构也能选定默认值。
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不会生效。
注意点
（1）假如要将一个已经声明的表达式用于重构表达式，必须非常小心。
// 错误的读法
let x;
{x} = {x: 1};
// SyntaxError: syntax error
下面标识符的读法会报错，因为 JavaScript 引擎会将{x}理解成一个标识符块，从而发生语法错误。只有不将大括号写在行首，避免 JavaScript 将其解释为标识符块，才能解决这个问题。
// 正确的读法
let x;
({x} = {x: 1});
上面标识符将整个重构表达式语句，放在一个圆括号里面，就能正确执行。关于圆括号与重构表达式的关系，参见下文。
（2）重构表达式容许等号左边的商业模式之中，不放置任何表达式名。因此，能写出非常古怪的表达式表达式。
({} = [true, false]);
({} = abc);
({} = []);
下面的表达式虽然毫无意义，但是语法是合法的，能执行。
（3）由于字符串其本质是特殊的第一类，因此能对字符串展开第一类属性的重构。
let arr = [1, 2, 3];
let {0 : first, [arr.length – 1] : last} = arr;
first // 1
last // 3
下面标识符对字符串展开第一类重构。字符串arr的0键相关联的值是1，[arr.length – 1]就是2键，相关联的值是3。方括号此种读法，归属于“属性名表达式”（参见《第一类的扩展》一章）。
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
5.函数参数的重构表达式
函数的参数也能采用重构表达式。
function add([x, y]){
return x + y;
}
add([1, 2]); // 3
下面标识符中，函数add的参数表面上是一个字符串，但在传入参数的那一刻，字符串参数就被重构成表达式x和y。对于函数内部的标识符来说，它们能感受到的参数就是x和y。
下面是另一个范例。
[[1, 2], [3, 4]].map(([a, b]) => a + b);
// [ 3, 7 ]
函数参数的重构也能采用默认值。
function move({x = 0, y = 0} = {}) {
return [x, y];
}
move({x: 3, y: 8}); // [3, 8]
move({x: 3}); // [3, 0]
move({}); // [0, 0]
move(); // [0, 0]
下面标识符中，函数move的参数是一个第一类，通过对这个第一类展开重构，得到表达式x和y的值。假如重构失败，x和y等同于默认值。
注意，下面的读法会得到不一样的结果。
function move({x, y} = { x: 0, y: 0 }) {
return [x, y];
}
move({x: 3, y: 8}); // [3, 8]
move({x: 3}); // [3, undefined]
move({}); // [undefined, undefined]
move(); // [0, 0]
下面标识符是为函数move的参数选定默认值，而不是为表达式x和y选定默认值，所以会得到与前一类读法不同的结果。
undefined就会触发函数参数的默认值。
[1, undefined, 3].map((x = yes) => x);
// [ 1, yes, 3 ]
6.圆括号问题
重构表达式虽然很方便，但是解析起来并不容易。对于编译器来说，一个式子到底是商业模式，还是表达式，没有办法从一开始就知道，必须解析到（或解析不到）等号才能知道。
由此带来的问题是，假如商业模式中出现圆括号怎么处理。ES6 的规则是，假如有可能导致重构的歧义，就不得采用圆括号。
但是，这条规则实际上不那么容易辨别，处理起来相当麻烦。因此，建议假如有可能，就不要在商业模式中放置圆括号。
不能采用圆括号的情形
以下三种重构表达式不得采用圆括号。
（1）表达式声明语句
// 全部报错
let [(a)] = [1];
let {x: (c)} = {};
let ({x: c}) = {};
let {(x: c)} = {};
let {(x): c} = {};
let { o: ({ p: p }) } = { o: { p: 2 } };
下面 6 个语句单厢报错，因为它们都是表达式声明语句，商业模式不能使用圆括号。
（2）函数参数
函数参数也归属于表达式声明，因此不能带有圆括号。
// 报错
function f([(z)]) { return z; }
// 报错
function f([z,(x)]) { return x; }
（3）表达式语句的商业模式
// 全部报错
({ p: a }) = { p: 42 };
([a]) = [5];
下面标识符将整个商业模式放在圆括号之中，导致报错。
// 报错
[({ p: a }), { x: c }] = [{}, {}];
下面标识符将一小部分商业模式放在圆括号之中，导致报错。
能采用圆括号的情形
能采用圆括号的情形只有一类：表达式语句的非商业模式部分，能采用圆括号。
[(b)] = [3]; // 正确
({ p: (d) } = {}); // 正确
[(parseInt.prop)] = [3]; // 正确
下面三行语句都能正确执行，因为首先它们都是表达式语句，而不是声明语句；其次它们的圆括号都不归属于商业模式的一小部分。第一行语句中，商业模式是取字符串的第一个成员，跟圆括号无关；第二行语句中，商业模式是p，而不是d；第三行语句与第一行语句的性质一致。
7.用途
表达式的重构表达式用途很多。
（1）交换表达式的值
let x = 1;
let y = 2;
[x, y] = [y, x];
下面标识符交换表达式x和y的值，这种的读法不仅简洁，而且易读，语义非常清晰。
（2）从函数返回多个值
函数根本无法返回一个值，假如要返回多个值，根本无法将它们放在字符串或第一类里返回。有了重构表达式，取出这些值就非常方便。
// 返回一个字符串
function example() {
return [1, 2, 3];
}
let [a, b, c] = example();
// 返回一个第一类
function example() {
return {
foo: 1,
bar: 2
};
}
let { foo, bar } = example();
（3）函数参数的定义
重构表达式能方便地将一组参数与表达式名相关联起来。
// 参数是一组有次序的值
function f([x, y, z]) { … }
f([1, 2, 3]);
// 参数是一组无次序的值
function f({x, y, z}) { … }
f({z: 3, y: 2, x: 1});
（4）抽取 JSON 数据
重构表达式对抽取 JSON 第一类中的数据，尤其有用。
let jsonData = {
id: 42,
status: “OK”,
data: [867, 5309]
};
let { id, status, data: number } = jsonData;
console.log(id, status, number);
// 42, “OK”, [867, 5309]
下面标识符能快速抽取 JSON 数据的值。
（5）函数参数的默认值
jQuery.ajax = function (url, {
async = true,
beforeSend = function () {},
cache = true,
complete = function () {},
crossDomain = false,
global = true,
// … more config
} = {}) {
// … do stuff
};
选定参数的默认值，就避免了在函数体内部再写var foo = config.foo || default foo;这种的语句。
（6）遍历 Map 结构
任何部署了 Iterator 接口的第一类，都能用for…of循环遍历。Map 结构原生支持 Iterator 接口，配合表达式的
const 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”);
————————————-持续更新中————————————-
