let的解构赋值_数组的解构赋值

```javascript

let [foo, [[bar], baz]] = [1, [[2], 3]]

foo // 1

bar // 2

baz // 3

let [ ,, third] = ['foo', 'bar', 'baz']

third // 'baz'

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, z] = new Set(['a', 'b', 'c'])

x // 'a'

// 以下语句报错

let [foo] = 1

let [foo] = false

let [foo] = NaN

let [fool] = undefined

let [foo] = null

let [foo] = {}

```

>上面报错的语句，是因为等号右边的值，要么转为对象以后不具备Iterator接口(前五个表达式)，要么本身不具备Iterator接口(最后一个表达式)。

事实上，只要某种数据结构具有Iterator接口，都可以采用数组形式的解构赋值。

```

function* fibs () {

let a = 0

let b = 1

while (true) {

yield a

[a, b] = [b, a + b]

}

}

let [first, second, third, fourth, fifth, sixth] = fibs()

first // 0

second // 1

third // 1

fourth // 2

fifth // 3

sixth // 5

```

>上面代码中，`fibs`是一个Generator函数，原生具有Iterator接口，解构赋值会依次从这个接口获取值。

*****

# 解构赋值允许指定默认值

* ES6内部使用严格相等运算符(`===`)来判断一个位置是否有值。所以，只有当一个数组成员严格等于`undefined`，默认值才会生效。

```

let [x = 1] = [undefined]

x // 1

let [x = 1] = [null]

x // null

```

* 如果默认值是一个表达式，那么这个表达式是惰性求值的，即只有在用到的时候才会求值。

```

function f () {

return 'aaa'

}

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

```

> 上面代码中，因为`x`不使用默认值，所以函数`f`根本不会执行。

* 默认值可以引用解构赋值的其他变量，但该变量必须已经声明。

```javascript

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

```