1. 数组的解构赋值
基本用法
ES6允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构(Destructuring)。
var a
=
1
;
var b
=
2
;
var c
=
3
;
var
[a
, b
, c
]
=
[
1
,
2
,
3
]
;
上面代码表示,可以从数组中提取值,按照对应位置,对变量赋值。
本质上,这种写法属于“模式匹配”,只要等号两边的模式相同,左边的变量就会被赋予对应的值。下面是一些使用嵌套数组进行解构的例子。
let
[foo
,
[
[bar
]
, baz
]
]
=
[
1
,
[
[
2
]
,
3
]
]
;
foo
bar
baz
let
[
,
, third
]
=
[
"foo"
,
"bar"
,
"baz"
]
;
third
let
[x
,
, y
]
=
[
1
,
2
,
3
]
;
x
y
let
[head
,
...tail
]
=
[
1
,
2
,
3
,
4
]
;
head
tail
let
[x
, y
,
...z
]
=
[
'a'
]
;
x
y
z
如果解构不成功,变量的值就等于undefined。
var
[foo
]
=
[
]
;
var
[bar
, foo
]
=
[
1
]
;
以上两种情况都属于解构不成功,foo的值都会等于undefined。
另一种情况是不完全解构,即等号左边的模式,只匹配一部分的等号右边的数组。这种情况下,解构依然可以成功。
let
[x
, y
]
=
[
1
,
2
,
3
]
;
x
y
let
[a
,
[b
]
, d
]
=
[
1
,
[
2
,
3
]
,
4
]
;
a
b
d
如果等号的右边不是数组(或者严格地说,不是可遍历的结构,参见《Iterator》一章),那么将会报错。
let
[foo
]
=
1
;
let
[foo
]
=
false
;
let
[foo
]
=
NaN
;
let
[foo
]
= undefined
;
let
[foo
]
=
null
;
let
[foo
]
=
{
}
;
上面的表达式都会报错,因为等号右边的值,要么转为对象以后不具备Iterator接口(前五个表达式),要么本身就不具备Iterator接口(最后一个表达式)。
解构赋值不仅适用于var命令,也适用于let和const命令。
var
[v1
, v2
,
...
, vN
]
= array
;
let
[v1
, v2
,
...
, vN
]
= array
;
const
[v1
, v2
,
...
, vN
]
= array
;
let
[x
, y
, z
]
=
new
Set
(
[
"a"
,
"b"
,
"c"
]
)
;
x
事实上,只要某种数据结构具有Iterator接口,都可以采用数组形式的解构赋值。
function
*
fibs
(
)
{
var a
=
0
;
var b
=
1
;
while
(
true
)
{
yield a
;
[a
, b
]
=
[b
, a
+ b
]
;
}
}
var
[first
, second
, third
, fourth
, fifth
, sixth
]
=
fibs
(
)
;
sixth
上面代码中,fibs是一个Generator函数,原生具有Iterator接口。解构赋值会依次从这个接口获取值。
默认值
var
[foo
=
true
]
=
[
]
;
foo
[x
, y
=
'b'
]
=
[
'a'
]
;
[x
, y
=
'b'
]
=
[
'a'
, undefined
]
;
注意,ES6内部使用严格相等运算符(===),判断一个位置是否有值。所以,如果一个数组成员不严格等于undefined,默认值是不会生效的。
var
[x
=
1
]
=
[undefined
]
;
x
var
[x
=
1
]
=
[
null
]
;
x
上面代码中,如果一个数组成员是null,默认值就不会生效,因为null不严格等于undefined。
如果默认值是一个表达式,那么这个表达式是惰性求值的,即只有在用到的时候,才会求值。
function
f
(
)
{
console
.
log
(
'aaa'
)
;
}
let
[x
=
f
(
)
]
=
[
1
]
;
上面代码中,因为x能取到值,所以函数f根本不会执行。上面的代码其实等价于下面的代码。
let x
;
if
(
[
1
]
[
0
]
=== undefined
)
{
x
=
f
(
)
;
}
else
{
x
=
[
1
]
[
0
]
;
}
默认值可以引用解构赋值的其他变量,但该变量必须已经声明。
let
[x
=
1
, y
= x
]
=
[
]
;
let
[x
=
1
, y
= x
]
=
[
2
]
;
let
[x
=
1
, y
= x
]
=
[
1
,
2
]
;
let
[x
= y
, y
=
1
]
=
[
]
;
上面最后一个表达式之所以会报错,是因为x用到默认值y时,y还没有声明。
对象的解构赋值
var
{ foo
, bar
}
=
{ foo
:
"aaa"
, bar
:
"bbb"
}
;
foo
bar
对象的解构与数组有一个重要的不同。数组的元素是按次序排列的,变量的取值由它的位置决定;而对象的属性没有次序,变量必须与属性同名,才能取到正确的值。
var
{ bar
, foo
}
=
{ foo
:
"aaa"
, bar
:
"bbb"
}
;
foo
bar
var
{ baz
}
=
{ foo
:
"aaa"
, bar
:
"bbb"
}
;
baz
上面代码的第一个例子,等号左边的两个变量的次序,与等号右边两个同名属性的次序不一致,但是对取值完全没有影响。第二个例子的变量没有对应的同名属性,导致取不到值,最后等于undefined。
var
{ foo
: baz
}
=
{ foo
:
'aaa'
, bar
:
'bbb'
}
;
baz
let obj
=
{ first
:
'hello'
, last
:
'world'
}
;
let
{ first
: f
, last
: l
}
= obj
;
f
l
这实际上说明,对象的解构赋值是下面形式的简写(参见《对象的扩展》一章)。
var
{ foo
: foo
, bar
: bar
}
=
{ foo
:
"aaa"
, bar
:
"bbb"
}
;
也就是说,对象的解构赋值的内部机制,是先找到同名属性,然后再赋给对应的变量。真正被赋值的是后者,而不是前者。
var
{ foo
: baz
}
=
{ foo
:
"aaa"
, bar
:
"bbb"
}
;
baz
foo
上面代码中,真正被赋值的是变量baz,而不是模式foo。
注意,采用这种写法时,变量的声明和赋值是一体的。对于let和const来说,变量不能重新声明,所以一旦赋值的变量以前声明过,就会报错。
let foo
;
let
{foo
}
=
{foo
:
1
}
;
let baz
;
let
{bar
: baz
}
=
{bar
:
1
}
;
上面代码中,解构赋值的变量都会重新声明,所以报错了。不过,因为var命令允许重新声明,所以这个错误只会在使用let和const命令时出现。如果没有第二个let命令,上面的代码就不会报错。
let foo
;
(
{foo
}
=
{foo
:
1
}
)
;
let baz
;
(
{bar
: baz
}
=
{bar
:
1
}
)
;
上面代码中,let命令下面一行的圆括号是必须的,否则会报错。因为解析器会将起首的大括号,理解成一个代码块,而不是赋值语句。
var obj
=
{
p
:
[
'Hello'
,
{ y
:
'World'
}
]
}
;
var
{ p
:
[x
,
{ y
}
]
}
= obj
;
x
y
var node
=
{
loc
:
{
start
:
{
line
:
1
,
column
:
5
}
}
}
;
var
{ loc
:
{ start
:
{ line
}
}
}
= node
;
line
loc
start
上面代码中,只有line是变量,loc和start都是模式,不会被赋值。
let obj
=
{
}
;
let arr
=
[
]
;
(
{ foo
: obj
.prop
, bar
: arr
[
0
]
}
=
{ foo
:
123
, bar
:
true
}
)
;
obj
arr
var
{x
=
3
}
=
{
}
;
x
var
{x
, y
=
5
}
=
{x
:
1
}
;
x
y
var
{x
:y
=
3
}
=
{
}
;
y
var
{x
:y
=
3
}
=
{x
:
5
}
;
y
var
{ message
: msg
=
'Something went wrong'
}
=
{
}
;
msg
默认值生效的条件是,对象的属性值严格等于undefined。
var
{x
=
3
}
=
{x
: undefined
}
;
x
var
{x
=
3
}
=
{x
:
null
}
;
x
上面代码中,如果x属性等于null,就不严格相等于undefined,导致默认值不会生效。
var
{foo
}
=
{bar
:
'baz'
}
;
foo
如果解构模式是嵌套的对象,而且子对象所在的父属性不存在,那么将会报错。
var
{foo
:
{bar
}
}
=
{baz
:
'baz'
}
;
上面代码中,等号左边对象的foo属性,对应一个子对象。该子对象的bar属性,解构时会报错。原因很简单,因为foo这时等于undefined,再取子属性就会报错,请看下面的代码。
var _tmp
=
{baz
:
'baz'
}
;
_tmp
.foo
.bar
如果要将一个已经声明的变量用于解构赋值,必须非常小心。
var x
;
{x
}
=
{x
:
1
}
;
上面代码的写法会报错,因为JavaScript引擎会将{x}理解成一个代码块,从而发生语法错误。只有不将大括号写在行首,避免javascript将其解释为代码块,才能解决这个问题。
上面代码将整个解构赋值语句,放在一个圆括号里面,就可以正确执行。关于圆括号与解构赋值的关系,参见下文。
解构赋值允许,等号左边的模式之中,不放置任何变量名。因此,可以写出非常古怪的赋值表达式。
(
{
}
=
[
true
,
false
]
)
;
(
{
}
=
'abc'
)
;
(
{
}
=
[
]
)
;
上面的表达式虽然毫无意义,但是语法是合法的,可以执行。
对象的解构赋值,可以很方便地将现有对象的方法,赋值到某个变量。
let
{ log
, sin
, cos
}
= Math
;
上面代码将Math对象的对数、正弦、余弦三个方法,赋值到对应的变量上,使用起来就会方便很多。
由于数组本质是特殊的对象,因此可以对数组进行对象属性的解构。
var arr
=
[
1
,
2
,
3
]
;
var
{
0
: first
,
[arr
.length
-
1
]
: last
}
= arr
;
first
last
上面代码对数组进行对象结构。数组arr的0键对应的值是1,[arr.length - 1]就是2键,对应的值是3。方括号这种写法,属于“属性名表达式”,参见《对象的扩展》一章。
字符串的解构赋值
字符串也可以解构赋值。这是因为此时,字符串被转换成了一个类似数组的对象。
const
[a
, b
, c
, d
, e
]
=
'hello'
;
a
b
c
d
e
类似数组的对象都有一个length属性,因此还可以对这个属性解构赋值。
let
{length
: len
}
=
'hello'
;
len
解构赋值时,如果等号右边是数值和布尔值,则会先转为对象。
let
{toString
: s
}
=
123
;
s
=== Number
.prototype
.toString
let
{toString
: s
}
=
true
;
s
=== Boolean
.prototype
.toString
上面代码中,数值和布尔值的包装对象都有toString属性,因此变量s都能取到值。
解构赋值的规则是,只要等号右边的值不是对象,就先将其转为对象。由于undefined和null无法转为对象,所以对它们进行解构赋值,都会报错。
let
{ prop
: x
}
= undefined
;
let
{ prop
: y
}
=
null
;
函数参数的解构赋值
function
add
(
[x
, y
]
)
{
return x
+ y
;
}
add
(
[
1
,
2
]
)
;
上面代码中,函数add的参数表面上是一个数组,但在传入参数的那一刻,数组参数就被解构成变量x和y。对于函数内部的代码来说,它们能感受到的参数就是x和y。
[
[
1
,
2
]
,
[
3
,
4
]
]
.
map
(
(
[a
, b
]
)
=
> a
+ b
)
;
function
move
(
{x
=
0
, y
=
0
}
=
{
}
)
{
return
[x
, y
]
;
}
move
(
{x
:
3
, y
:
8
}
)
;
move
(
{x
:
3
}
)
;
move
(
{
}
)
;
move
(
)
;
上面代码中,函数move的参数是一个对象,通过对这个对象进行解构,得到变量x和y的值。如果解构失败,x和y等于默认值。
function
move
(
{x
, y
}
=
{ x
:
0
, y
:
0
}
)
{
return
[x
, y
]
;
}
move
(
{x
:
3
, y
:
8
}
)
;
move
(
{x
:
3
}
)
;
move
(
{
}
)
;
move
(
)
;
上面代码是为函数move的参数指定默认值,而不是为变量x和y指定默认值,所以会得到与前一种写法不同的结果。
[
1
, undefined
,
3
]
.
map
(
(x
=
'yes'
)
=
> x
)
;
圆括号问题
解构赋值虽然很方便,但是解析起来并不容易。对于编译器来说,一个式子到底是模式,还是表达式,没有办法从一开始就知道,必须解析到(或解析不到)等号才能知道。
由此带来的问题是,如果模式中出现圆括号怎么处理。ES6的规则是,只要有可能导致解构的歧义,就不得使用圆括号。
但是,这条规则实际上不那么容易辨别,处理起来相当麻烦。因此,建议只要有可能,就不要在模式中放置圆括号。
var
[
(a
)
]
=
[
1
]
;
var
{x
:
(c
)
}
=
{
}
;
var
(
{x
: c
}
)
=
{
}
;
var
{
(x
: c
)
}
=
{
}
;
var
{
(x
)
: c
}
=
{
}
;
var
{ o
:
(
{ p
: p
}
)
}
=
{ o
:
{ p
:
2
}
}
;
上面三个语句都会报错,因为它们都是变量声明语句,模式不能使用圆括号。
function
f
(
[
(z
)
]
)
{
return z
;
}
(3)赋值语句中,不能将整个模式,或嵌套模式中的一层,放在圆括号之中。
(
{ p
: a
}
)
=
{ p
:
42
}
;
(
[a
]
)
=
[
5
]
;
上面代码将整个模式放在圆括号之中,导致报错。
[
(
{ p
: a
}
)
,
{ x
: c
}
]
=
[
{
}
,
{
}
]
;
上面代码将嵌套模式的一层,放在圆括号之中,导致报错。
可以使用圆括号的情况
可以使用圆括号的情况只有一种:赋值语句的非模式部分,可以使用圆括号。
[
(b
)
]
=
[
3
]
;
(
{ p
:
(d
)
}
=
{
}
)
;
[
(parseInt
.prop
)
]
=
[
3
]
;
上面三行语句都可以正确执行,因为首先它们都是赋值语句,而不是声明语句;其次它们的圆括号都不属于模式的一部分。第一行语句中,模式是取数组的第一个成员,跟圆括号无关;第二行语句中,模式是p,而不是d;第三行语句与第一行语句的性质一致。
上面代码交换变量x和y的值,这样的写法不仅简洁,而且易读,语义非常清晰。
函数只能返回一个值,如果要返回多个值,只能将它们放在数组或对象里返回。有了解构赋值,取出这些值就非常方便。
function
example
(
)
{
return
[
1
,
2
,
3
]
;
}
var
[a
, b
, c
]
=
example
(
)
;
function
example
(
)
{
return
{
foo
:
1
,
bar
:
2
}
;
}
var
{ foo
, bar
}
=
example
(
)
;
function
f
(
[x
, y
, z
]
)
{
...
}
f
(
[
1
,
2
,
3
]
)
;
function
f
(
{x
, y
, z
}
)
{
...
}
f
(
{z
:
3
, y
:
2
, x
:
1
}
)
;
var jsonData
=
{
id
:
42
,
status
:
"OK"
,
data
:
[
867
,
5309
]
}
;
let
{ id
, status
, data
: number
}
= jsonData
;
console
.
log
(id
, status
, number
)
;
jQuery
.ajax
=
function
(url
,
{
async
=
true
,
beforeSend
=
function
(
)
{
}
,
cache
=
true
,
complete
=
function
(
)
{
}
,
crossDomain
=
false
,
global
=
true
,
}
)
{
}
;
指定参数的默认值,就避免了在函数体内部再写var foo = config.foo || 'default foo';这样的语句。
任何部署了Iterator接口的对象,都可以用for...of循环遍历。Map结构原生支持Iterator接口,配合变量的解构赋值,获取键名和键值就非常方便。
var map
=
new
Map
(
)
;
map
.
set
(
'first'
,
'hello'
)
;
map
.
set
(
'second'
,
'world'
)
;
for
(
let
[key
, value
]
of map
)
{
console
.
log
(key
+
" is "
+ value
)
;
}
如果只想获取键名,或者只想获取键值,可以写成下面这样。
for
(
let
[key
]
of map
)
{
}
for
(
let
[
,value
]
of map
)
{
}
加载模块时,往往需要指定输入那些方法。解构赋值使得输入语句非常清晰。
const
{ SourceMapConsumer
, SourceNode
}
=
require
(
"source-map"
)
;
本文转自:http://www.f-z.cn/id/281