大家想了解更多，可以去看阮一峰的ECMAScript6(ES6)標準入門課程

對象

簡介

解構不僅可以用于數組，還可以用于對象。

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});

?上面代碼將整個解構賦值語句，放在一個圓括號里面，就可以正確執行。關于圓括號與解構賦值的關系，參見下文。

在 JavaScript 中，{} 被解釋為一個塊級作用域而不是對象字面量。因此，當你使用 {x} = {x: 1} 時，JavaScript 引擎會將 {} 視為一個塊級作用域，然后嘗試將 {x} 解構賦值給 {x: 1}，這會導致語法錯誤。

為了避免這個問題，你可以將整個解構賦值語句包裹在括號中，即 ({x} = {x: 1})。這樣做告訴 JavaScript 解析器，{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。方括號這種寫法，屬于“屬性名表達式”?

字符串

字符串也可以解構賦值。這是因為此時，字符串被轉換成了一個類似數組的對象

const [a, b, c, d, e] = 'hello';
a // "h"
b // "e"
c // "l"
d // "l"
e // "o"

類似數組的對象都有一個length屬性，因此還可以對這個屬性解構賦值。

let {length : len} = 'hello';
len // 5