JavaScript ECMAScript 6 筆記 -2 《變數的解構賦值》

ES6 允許按照一定模式，從陣列和物件中提取值，對變數進行賦值，這被稱為解構
ES5
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 [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 = true] = [];
foo // true

let [x, y = 'b'] = ['a']; // x='a', y='b'
let [x, y = 'b'] = ['a', undefined]; // x='a', y='b'

let [x = 1] = [undefined];
x // 1

let [x = 1] = [null];
x // null

ES6 內部使用嚴格相等運算子（===），判斷一個位置是否有值。所以，如果一個陣列成員不嚴格等於undefined，預設值是不會生效的

let [x = 1] = [undefined];
x // 1

let [x = 1] = [null];
x // null

如果預設值是一個表示式，那麼這個表示式是惰性求值的，即只有在用到的時候，才會求值。

function f() {
  console.log('aaa');
}

let [x = f()] = [1];

等價
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
最後一個表示式之所以會報錯，是因為x用到預設值y時，y還沒有宣告。

物件的解構賦值

解構不僅可以用於陣列，還可以用於物件
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。

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'

var {x = 3} = {x: undefined};
x // 3

var {x = 3} = {x: null};
x // null

未完。。。。