所谓 解构（Destructuring） ，就是把数组或对象打散为一堆变量。
\n解构是 构造（Constructuring） 的逆过程，想象一下我们熟悉的构造函数，其实就是把一堆变量组合成一个对象或数组。
\n而 解构赋值 ，就是把解构的结果赋值给其它的变量，这个过程通常是多对多的，看上去就像是把一个数组或对象直接赋值给另一个数组或对象一样。（然而这并不表示对象和数组可以直接赋值，只是看着像而已）
\nES6 支持对数组进行解构赋值，它会根据索引顺序进行模式匹配，写法如下。
\nvar [a, b, c] = [1, 2, 3];\nvar a = 1, b = 2, c = 3; // 上面的代码等价于这行代码数组的解构赋值根据索引顺序一一对应，如果左边变量的索引在右边的数组中存在，则将右边该索引位置的值赋给左边的变量，如果右边数组中没有对应的索引，则该索引位置的解构失败，左边的变量赋值为undefined（或使用默认值，后面会讲到）。
\n// 右边比左边少，空缺位解构失败\nlet [foo] = []; // foo: undefined\nlet [bar, foo] = [1]; // foo: undefined\n\n// 右边比左边多，多余部分舍去\nlet [x, y] = [1, 2, 3]; // x:1, y:2\nlet [a, [b], d] = [1, [2, 3], 4]; // a:1, b:2, d:4数组的解构赋值要求等号右边必须是数组（ES6引入了Iterator接口的概念，因此这里严格说来是指等号右边必须是可遍历的结构），否则报错。
\n// 原始变量的包装对象不具备Iterator接口\nlet [foo] = 1;\nlet [foo] = false;\nlet [foo] = NaN;\nlet [foo] = undefined;\nlet [foo] = null;\n\n// 空对象不具备Iterator接口\nlet [foo] = {};\n\n// Set是ES6引入的集合类，具备Iterator接口，可以用于解构赋值\nlet [x, y, z] = new Set([\"a\", \"b\", \"c\"]); // x: \"a\"\n\n// Generator是ES6引入的函数类型，具备Iterator接口，可以用于解构赋值\n// yield在Generator中相当于return，后续文章会详细说明。\nfunction* fibs() {\n var a = 0, b = 1;\n while (true) {\n yield a;\n [a, b] = [b, a + b]; // 函数内部的解构赋值。\n }\n}\nlet [first, second, third, fourth, fifth, sixth] = fibs(); // sixth: 5在之前的代码中，解构赋值通常都和 let 一起出现，但解构赋值和变量声明其实是两个独立的操作，我们只是将解构的结果直接用于新变量的初始化了而已。无论是 var 、 let 、 const 都可以使用，如果变量已经存在就不需要用到它们。
数组的解构赋值支持嵌套，只要等号两边对应位置的结构相同即可。
\nlet [foo, [[bar], baz]] = [1, [[2], 3]]; // foo:1, bar:2, baz:3\n\n// 左边有空缺不要紧，空缺位会自动跳过\nlet [ , , third] = [\"foo\", \"bar\", \"baz\"]; // third:\"baz\"\nlet [x, , y] = [1, 2, 3]; // x:1, y:3\n\n// \"...x\"是ES6新增的语法糖“剩余参数”，后续文章会详细说明。\nlet [head, ...tail] = [1, 2, 3, 4]; // head:1, tail:[2, 3, 4]\nlet [x, y, ...z] = ['a']; // x:'a', y:undefined, z:[]解构赋值可以设置默认值。
\nvar [foo = true] = []; // foo: true\n\nvar [x, y = 'b'] = ['a'] // x:'a', y:'b'\nvar [x, y = 'b'] = ['a', undefined] // x:'a', y:'b'\n\n// 仅当等号右边的元素是undefined时，默认值才起效\nvar [x = 1] = [undefined]; // x:1\nvar [x = 1] = [null]; // x:null\n\nfunction f() { console.log('aaa'); }\nlet [x = f()] = [1]; // 右边不等于undefined，因此f()不会调用。x：1默认值可以引用解构赋值的其他变量，但该变量必须已经声明。
\nlet [x = 1, y = x] = []; // x:1, y:1\nlet [x = 1, y = x] = [2]; // x:2, y:2\nlet [x = 1, y = x] = [2, 3]; // x:2, y:3\nlet [x = y, y = 1] = []; // ReferenceError，x引用y的值时，y还没声明解构赋值也可以用于对象，区别在于对象的解构根据属性名进行映射，与顺序无关。
\nvar { bar, foo } = { foo: \"aaa\", bar: \"bbb\" }; // foo:\"aaa\", bar:\"bbb\"\nvar { baz } = { foo: \"aaa\", bar: \"bbb\" }; // baz:undefined对象解构赋值的内部机制，是先找到同名属性，然后用等号右边的属性值给左边对应的属性值赋值。真正被赋值的是冒号右边的属性值，而不是左边的属性名。
\nvar { foo: baz } = { foo: \"aaa\", bar: \"bbb\" }; // baz:\"aaa\", foo:not defined\n\nlet obj = { first: 'hello', last: 'world' };\nlet { first: f, last: l } = obj; // f:'hello', l:'world'对象的解构赋值其实是下面形式的简写。
\nvar { foo: foo, bar: bar } = { foo: \"aaa\", bar: \"bbb\" }; // 完整形式\nvar { foo , bar } = { foo: \"aaa\", bar: \"bbb\" }; // 简写形式对象的解构赋值同样支持嵌套，并且可以和数组混合嵌套。
\nvar obj = {\n p: [\n \"Hello\",\n { y: \"World\" }\n ]\n};\n\nvar { p: [x, { y }] } = obj; // x:\"Hello\", y:\"World\", p是属性名，不参与赋值对象的解构赋值同样支持默认值。默认值仅当右边找不到同名属性，或同名属性值为undefined时起效
\nvar {x, y = 5} = {x: 1}; // x:1, y:5\n\nvar {x = 3} = {x: null}; // x:null\nvar {x = 3} = {x: undefined}; // x:3如果左边的属性在右边没有同名属性，又没有指定默认值，则解构失败，值为undefined
\nvar {foo} = {bar: 'baz'} // foo:undefined如果解构模式是嵌套的对象，子对象所属的父属性不存在，则即便右边同名属性的值不是undefined，也依旧会报错。
\nvar {foo: {bar}} = {baz: 'baz'} // Error\n\nvar _tmp = {baz: 'baz'};\n_tmp.foo.bar // 报错，foo属性值为undefined，再取子属性自然报错。如果要将一个已经声明的变量用于解构赋值，必须用括号包裹，不能让花括号处于行首。例如下面的代码，JS引擎会把 {x} 理解为一个代码段，进而导致语法错误。
var x;\n {x} = {x: 1}; // 语法错误\n({x} = {x: 1}); // 正确的写法解构赋值允许等号左边为空。下面的代码虽然毫无意义，但在语法上却是合法的。
\n({} = [true, false]);\n({} = 'abc');\n({} = []);利用对象的解构赋值，可以很方便地将现有对象的方法，赋值到某个变量。
\nlet { log, sin, cos } = Math; // Math类中包含了这几个方法，该操作将这几个方法提取出来字符串作为类数组对象，同时具备了数组和对象的特性，因此可以用两种方式进行解构赋值。
\n// 字符串可以看做数组进行结构\nconst [a, b, c, d, e] = 'hello'; // a:\"h\", b:\"e\", c:\"l\", d:\"l\", e:\"o\",\n\n// 字符串作为类数组对象，拥有length属性。\nlet {length : len} = 'hello'; // len:5数值和布尔值也能进行解构，两者会先转为对象，剩下的就是匹配对象中的方法
\nlet {toString: s} = 123;\ns === Number.prototype.toString // true\n\nlet {toString: s} = true;\ns === Boolean.prototype.toString // true\n\n// undefined和null不能转为对象，没有属性\nlet { prop: x } = undefined; // TypeError\nlet { prop: y } = null; // TypeError函数的参数也可以使用解构赋值。下面的代码中， add() 的参数不是数组，而是 [x,y] = [1,2] 的解构，在函数内部，x和y可以直接访问，不需要索引。
function add([x, y]){\n return x + y;\n}\n\nadd([1, 2]) // 3函数参数的解构也可以使用默认值。
\nfunction move({x = 0, y = 0}) {\n return [x, y];\n}\n\nmove({x: 3, y: 8}); // [3, 8]\nmove({x: 3}); // [3, 0]，y使用默认值\nmove({}); // [0, 0]，空对象，x、y均使用默认值\nmove(); // [0, 0]，无参调用，x、y均使用默认值注意，下面的写法不是解构赋值，而是给函数的参数设定默认值，只有在无参调用时默认值才起效。
\nfunction move({x, y} = { x: 0, y: 0 }) {\n return [x, y];\n}\n\nmove({x: 3, y: 8}); // [ 3, 8]\nmove({x: 3}); // [ 3, undefined]，x正常赋值，默认值无效，y属性不存在，因此是undefined\nmove({}); // [undefined, undefined]，空对象也是实参，默认值无效，x、y属性都不存在，都是undefined\nmove(); // [ 0, 0]，无参调用，默认值起效对编译器而言，一个式子到底是模式，还是表达式，只有解析到（或解析不到）等号才能知道，因此会导致一些歧义。ES6 规定，但凡有可能产生歧义，就不能使用圆括号。以下3种情况下不能用圆括号：
\n// 下面3中写法都会报错\nvar [(a)] = [1];\nvar { x: (c) } = {};\nvar { o: ({ p: p }) } = { o: { p: 2 } };// 函数参数也属于变量声明，因此不能带有圆括号\nfunction f([(z)]) { return z; }// 将整个模式放在圆括号之中，会报错\n({ p: a }) = { p: 42 };\n([a]) = [5];\n\n// 将嵌套模式的一层放在圆括号之中，会报错。\n[({ p: a }), { x: c }] = [{}, {}];只有一种情况可以使用圆括号：赋值语句的非模式部分。
\n[(b)] = [3]; // 正确，数组的解构赋值根据索引来，与括号无关\n({ p: (d) } = {}); // 正确，p是模式，但d不是模式。[x, y] = [y, x];// 返回一个数组\nfunction example() { return [1, 2, 3]; }\nvar [a, b, c] = example();\n\n// 返回一个对象\nfunction example() { return { foo: 1, bar: 2 }; }\nvar { foo, bar } = example();// 参数是一组有次序的值\nfunction f([x, y, z]) { ... }\nf([1, 2, 3])\n\n// 参数是一组无次序的值\nfunction f({x, y, z}) { ... }\nf({z: 3, y: 2, x: 1})// bar, baz 等参数如果不指定，就用默认值代替，本质是对象的解构赋值\n// 避免了在函数体内再写 var bar = config.bar || true 等检测代码\nfunction (foo, {\n bar = true,\n baz = function () {},\n ......\n}) {\n // do something\n}var jsonData = {\n id: 42,\n status: \"OK\",\n data: [867, 5309]\n}\nlet { id, status, data: number } = jsonData;\nconsole.log(id, status, number) // 42, OK, [867, 5309]// Map 类型是 ES6 引入的集合类型，以键值对方式存储数据。后续文章会详细说明\nvar map = new Map();\nmap.set('first', 'hello');\nmap.set('second', 'world');\n\n// for...of 是 ES6 引入的循环方式，类似 for...in，后续文章会详细说明\nfor (let [key, value] of map) {\n console.log(key + \" is \" + value);\n}\n// first is hello\n// second is world\n\n// 也可以单独获取键，或者值\nfor (let [key] of map) { ... }\nfor (let [, value] of map) { ... } // 注意逗号不能省，这是数组的解构赋值// 加载模块时，往往需要指定输入哪些方法。解构赋值使得输入语句非常清晰。\nconst { SourceMapConsumer, SourceNode } = require(\"source-map\");