变量结构赋值——对象的结构赋值

对象的解构赋值

简介

解构不仅可以用于数组，还可以用于对象。

let { foo, bar } = { 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取不到值，所以等于undefined

对象的解构赋值，可以很方便地将现有对象的方法，赋值到某个变量。

// 例:将Math对象的对数、正弦、余弦三个方法，赋值到对应的变量上
let { log, sin, cos } = Math;
如果变量名与属性名不一致，必须写成下面这样。
```js
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: [    //p作为模式
    'Hello',
    { y: 'World' }
  ]
};
let { p: [x, { y }] } = obj;
x // "Hello"
y // "World"

```js
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  // { start: { line: 1, column: 5 } }
start // { line: 1, column: 5 }

上面代码有三次解构赋值，分别是对loc、start、line三个属性的解构赋值。注意，最后一次对line属性的解构赋值之中，只有line是变量，loc和start都是模式，不是变量。

默认值

对象的解构也可以指定默认值。

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