變數的解構賦值——ES6學習筆記
陣列的解構賦值
基本用法
ES6 允許按照一定模式，從陣列和物件中提取值，對變數進行賦值，這被稱為解構。
以前，為變數賦值，只能直接指定值，ES6 允許寫成這樣：let [a, b, c] = [1, 2, 3]; 程式碼表示，可以從陣列中提取值，按照對應位置，對變數賦值。本質上，這種寫法屬於“模式匹配”，只要等號兩邊的模式相同，左邊的變數就會被賦予對應的值。如果解構不成功，變數的值就等於undefined。
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 // []
// 另一種情況是不完全解構，即等號左邊的模式，只匹配一部分的等號右邊的陣列。這種情況下，解構依然可以成功。 let [x, y] = [1, 2, 3]; x // 1 y // 2 let [a, [b], d] = [1, [2, 3], 4]; a // 1 b // 2 d // 4 // 報錯 如果等號的右邊不是陣列（或者嚴格地說，不是可遍歷的結構），那麼將會報錯 let [foo] = 1; let [foo] = false; let [foo] = NaN; let [foo] = undefined; let [foo] = null; let [foo] = {}; // 上面的語句都會報錯，因為等號右邊的值，要麼轉為物件以後不具備 Iterator 介面（前五個表示式），要麼本身就不具備 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
如果預設值是一個表示式，那麼這個表示式是惰性求值的，即只有在用到的時候，才會求值。
let [x = f()] = [1];
上面程式碼中，因為x能取到值，所以函式f根本不會執行。
預設值可以引用解構賦值的其他變數，但該變數必須已經宣告。
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還沒有宣告。
物件的解構賦值
基本使用
解構不僅可以用於陣列，還可以用於物件。物件的解構與陣列有一個重要的不同。陣列的元素是按次序排列的，變數的取值由它的位置決定；而物件的屬性沒有次序，變數必須與屬性同名，才能取到正確的值。如果解構失敗，變數的值等於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'
與陣列一樣，解構也可以用於巢狀結構的物件。
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都是模式，不是變數。
物件的解構賦值可以取到繼承的屬性。
// 物件obj1的原型物件是obj2。foo屬性不是obj1自身的屬性，而是繼承自obj2的屬性，解構賦值可以取到這個屬性。
const obj1 = {};
const obj2 = { foo: 'bar' };
Object.setPrototypeOf(obj1, obj2);
const { foo } = obj1;
foo // "bar"
預設值
預設值生效的條件是，物件的屬性值嚴格等於undefined。
注意點
（1）如果要將一個已經宣告的變數用於解構賦值，必須非常小心。
let x;
{x} = {x: 1};
// SyntaxError: syntax error 因為 JavaScript 引擎會將{x}理解成一個程式碼塊，從而發生語法錯誤。只有不將大括號寫在行首，避免 JavaScript 將其解釋為程式碼塊，才能解決這個問題。
// 正確的寫法 將整個解構賦值語句，放在一個圓括號裡面，就可以正確執行
let x;
({x} = {x: 1});
（2）解構賦值允許等號左邊的模式之中，不放置任何變數名。因此，可以寫出非常古怪的賦值表示式。
（3）由於陣列本質是特殊的物件，因此可以對陣列進行物件屬性的解構。
let arr = [1, 2, 3];
let {0 : first, [arr.length - 1] : last} = arr; // 方括號這種寫法，屬於“屬性名錶達式”
first // 1
last // 3
字串的解構賦值
字串也可以解構賦值。這是因為此時，字串被轉換成了一個類似陣列的物件。 const [a, b, c, d, e] = 'hello';
類似陣列的物件都有一個length屬性，因此還可以對這個屬性解構賦值。
let {length : len} = 'hello';
len // 5
數值和布林值的解構賦值
解構賦值時，如果等號右邊是數值和布林值，則會先轉為物件。
let {toString: s} = 123;
s === Number.prototype.toString // true
let {toString: s} = true;
s === Boolean.prototype.toString // true
// 上面程式碼中，數值和布林值的包裝物件都有toString屬性，因此變數s都能取到值。
解構賦值的規則是，只要等號右邊的值不是物件或陣列，就先將其轉為物件。由於undefined和null無法轉為物件，所以對它們進行解構賦值，都會報錯。
函式引數的解構賦值
[[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]
--------------------------------------------
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]
---------------------------------------------
[1, undefined, 3].map((x = 'yes') => x);
// [ 1, 'yes', 3 ]
上面程式碼是為函式move的引數指定預設值，而不是為變數x和y指定預設值，所以會得到與前一種寫法不同的結果。 undefined就會觸發函式引數的預設值。
可以使用圓括號的情況
可以使用圓括號的情況只有一種：賦值語句的非模式部分，可以使用圓括號。
[(b)] = [3]; // 正確
({ p: (d) } = {}); // 正確
[(parseInt.prop)] = [3]; // 正確
上面三行語句都可以正確執行，因為首先它們都是賦值語句，而不是宣告語句；其次它們的圓括號都不屬於模式的一部分。第一行語句中，模式是取陣列的第一個成員，跟圓括號無關；第二行語句中，模式是p，而不是d；第三行語句與第一行語句的性質一致。
用途
-
交換變數的值：
[x, y] = [y, x]; -
從函式返回多個值：
return [1, 2, 3] -
函式引數的定義： 方便將一組引數與變數名對應起來
-
提取JSON資料：
-
let jsonData = { id: 42, status: "OK", data: [867, 5309] }; let { id, status, data: number } = jsonData; console.log(id, status, number); -
函式引數的預設值： 指定引數的預設值，就避免了在函式體內部再寫
var foo = config.foo || 'default foo';這樣的語句。 -
輸入模組的指定方法：
const { SourceMapConsumer, SourceNode } = require("source-map"); -
遍歷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 如果只想獲取鍵名，或者只想獲取鍵值，可以寫成下面這樣。 // 獲取鍵名 for (let [key] of map) { // ... } // 獲取鍵值 for (let [,value] of map) { // ... }