解構不僅可以用于數組，還可以用于對象。
~~~javascript
let { foo, bar } = { foo: 'aaa', bar: 'bbb' };
foo // "aaa"
bar // "bbb"
~~~
對象的解構與數組有一個重要的不同。數組的元素是按次序排列的，變量的取值由它的位置決定；而對象的屬性沒有次序，變量必須與屬性同名，才能取到正確的值。
~~~javascript
let { bar, foo } = { foo: 'aaa', bar: 'bbb' };
foo // "aaa"
bar // "bbb"
let { baz } = { foo: 'aaa', bar: 'bbb' };
baz // undefined
~~~
上面代碼的第一個例子，等號左邊的兩個變量的次序，與等號右邊兩個同名屬性的次序不一致，但是對取值完全沒有影響。第二個例子的變量沒有對應的同名屬性，導致取不到值，最后等于`undefined`。
如果解構失敗，變量的值等于`undefined`。
~~~javascript
let {foo} = {bar: 'baz'};
foo // undefined
~~~
上面代碼中，等號右邊的對象沒有`foo`屬性，所以變量`foo`取不到值，所以等于`undefined`。
對象的解構賦值，可以很方便地將現有對象的方法，賦值到某個變量。
~~~javascript
// 例一
let { log, sin, cos } = Math;
// 例二
const { log } = console;
log('hello') // hello
~~~
上面代碼的例一將`Math`對象的對數、正弦、余弦三個方法，賦值到對應的變量上，使用起來就會方便很多。例二將`console.log`賦值到`log`變量。
如果變量名與屬性名不一致，必須寫成下面這樣。
~~~javascript
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'
~~~
這實際上說明，對象的解構賦值是下面形式的簡寫（參見《對象的擴展》一章）。
~~~javascript
let { foo: foo, bar: bar } = { foo: 'aaa', bar: 'bbb' };
~~~
也就是說，對象的解構賦值的內部機制，是先找到同名屬性，然后再賦給對應的變量。真正被賦值的是后者，而不是前者。
~~~javascript
let { foo: baz } = { foo: 'aaa', bar: 'bbb' };
baz // "aaa"
foo // error: foo is not defined
~~~
上面代碼中，`foo`是匹配的模式，`baz`才是變量。真正被賦值的是變量`baz`，而不是模式`foo`。
與數組一樣，解構也可以用于嵌套結構的對象。
~~~javascript
let obj = {
p: [
'Hello',
{ y: 'World' }
]
};
let { p: [x, { y }] } = obj;
x // "Hello"
y // "World"
~~~
注意，這時`p`是模式，不是變量，因此不會被賦值。如果`p`也要作為變量賦值，可以寫成下面這樣。
~~~javascript
let obj = {
p: [
'Hello',
{ y: 'World' }
]
};
let { p, p: [x, { y }] } = obj;
x // "Hello"
y // "World"
p // ["Hello", {y: "World"}]
~~~
下面是另一個例子。
~~~javascript
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`都是模式，不是變量。
下面是嵌套賦值的例子。
~~~javascript
let obj = {};
let arr = [];
({ foo: obj.prop, bar: arr[0] } = { foo: 123, bar: true });
obj // {prop:123}
arr // [true]
~~~
如果解構模式是嵌套的對象，而且子對象所在的父屬性不存在，那么將會報錯。
~~~javascript
// 報錯
let {foo: {bar}} = {baz: 'baz'};
~~~
上面代碼中，等號左邊對象的`foo`屬性，對應一個子對象。該子對象的`bar`屬性，解構時會報錯。原因很簡單，因為`foo`這時等于`undefined`，再取子屬性就會報錯。
注意，對象的解構賦值可以取到繼承的屬性。
~~~javascript
const obj1 = {};
const obj2 = { foo: 'bar' };
Object.setPrototypeOf(obj1, obj2);
const { foo } = obj1;
foo // "bar"
~~~
上面代碼中，對象`obj1`的原型對象是`obj2`。`foo`屬性不是`obj1`自身的屬性，而是繼承自`obj2`的屬性，解構賦值可以取到這個屬性。
