解构赋值
ES6 允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这种称为解构
数组的解构赋值
| let [a, b, c] = [1, 2, 3];
console.log(a, b, c)
// 1 2 3
|
上面代码表示,可以从数组中提取值,按照对应位置,对变量赋值。
嵌套数组进行解构的例子
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 | let [foo, [[bar], baz]] = [1, [[2], 3]];
console.log(foo) // 1
console.log(bar) // 2
console.log(baz) // 3
let [ , , third] = ["foo", "bar", "baz"];
console.log(third) // "baz"
let [x, , y] = [1, 2, 3];
console.log(x) // 1
console.log(y) // 3
let [head, ...tail] = [1, 2, 3, 4];
console.log(head) // 1
console.log(tail) // [2, 3, 4]
let [a, b, ...c] = ['a'];
console.log(a) // "a"
console.log(b) // undefined
console.log(c) // []
|
如果解构不成功,变量的值就等于undefined
| let [foo] = [];
console.log(foo) // undefined
let [a, b] = [1];
console.log(b); // undefined
|
不完全解构:
| let [x, y] = [1, 2, 3];
console.log(x) // 1
console.log(y) // 2
let [a, [b], d] = [1, [2, 3], 4];
console.log(a) // 1
console.log(b) // 2
console.log(d) // 4
|
默认值
| let [foo = true] = [];
console.log(foo) // true
let [x, y = 'b'] = ['a'];
console.log(x) // 'a'
console.log(y) // 'b'
let [a, b = 'b'] = ['a', undefined];
console.log(a) // 'a'
console.log(b) // 'b'
|
注意,ES6 内部使用严格相等运算符(===
)来判断一个位置是否有值。所以,只有当一个数组成员严格等于undefined
,默认值才会生效
| let [x = 1] = [undefined];
console.log(x) // 1
let [a = 1] = [null];
console.log(a) // null
|
如果默认值是一个表达式,那么这个表达式是惰性求值的,即只有在用到的时候,才会求值
默认值可以引用解构赋值的其他变量,但该变量必须已经声明
| 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
|
对象的解构赋值
| let { foo, bar } = { foo: 'aaa', bar: 'bbb' };
console.log(foo) // "aaa"
console.log(bar) // "bbb"
|
对象的解构与数组有一个重要的不同。数组的元素是按次序排列的,变量的取值由它的位置决定;而对象的属性没有次序,变量必须与属性同名,才能取到正确的值。
| let { bar, foo } = { foo: 'aaa', bar: 'bbb' };
foo // "aaa"
bar // "bbb"
let { baz } = { foo: 'aaa', bar: 'bbb' };
baz // undefined
|
对象的解构赋值,可以很方便地将现有对象的方法,赋值到某个变量。
| // 例一
let { log, sin, cos } = Math
console.log(log(1)) // 0
// 例二
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"}]
|
下面是另一个例子。
1
2
3
4
5
6
7
8
9
10
11
12 | 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]
|
默认值
| 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
|
注意点
如果要将一个已经声明的变量用于解构赋值,必须非常小心。
| // 错误的写法
let x;
{x} = {x: 1};
// SyntaxError: syntax error
|
上面代码的写法会报错,因为 JavaScript 引擎会将{x}
理解成一个代码块,从而发生语法错误。只有不将大括号写在行首,避免 JavaScript 将其解释为代码块,才能解决这个问题。
| // 正确的写法
let x;
({x} = {x: 1});
|
由于数组本质是特殊的对象,因此可以对数组进行对象属性的解构。
| 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
|
用途
交换变量的值
| let x = 1;
let y = 2;
[x, y] = [y, x];
|
从函数返回多个值
1
2
3
4
5
6
7
8
9
10
11
12
13 | // 返回一个数组
function example() {
return [1, 2, 3];
}
let [a, b, c] = example();
// 返回一个对象
function example() {
return {
foo: 1,
bar: 2
};
}
let { foo, bar } = example();
|
函数参数的定义
| // 参数是一组有次序的值
function f([x, y, z]) { ... }
f([1, 2, 3]);
// 参数是一组无次序的值
function f({x, y, z}) { ... }
f({z: 3, y: 2, x: 1});
|
提取 JSON 数据
| let jsonData = {
id: 42,
status: "OK",
data: [867, 5309]
};
let { id, status, data: number } = jsonData;
console.log(id, status, number);
// 42, "OK", [867, 5309]
|
函数参数的默认值
| jQuery.ajax = function (url, {
async = true,
beforeSend = function () {},
cache = true,
complete = function () {},
crossDomain = false,
global = true,
// ... more config
} = {}) {
// ... do stuff
};
|
指定参数的默认值,就避免了在函数体内部再写var foo = config.foo || 'default foo';
这样的语句。
遍历 Map 结构
任何部署了 Iterator 接口的对象,都可以用for...of
循环遍历。Map 结构原生支持 Iterator 接口,配合变量的解构赋值,获取键名和键值就非常方便。
| const map = new Map();
map.set('first', 'hello');
map.set('second', 'world');
for (let [key, value] of map) {
console.log(key + " is " + value);
}
// first is hello
// second is world
|
如果只想获取键名,或者只想获取键值,可以写成下面这样。
| // 获取键名
for (let [key] of map) {
// ...
}
// 获取键值
for (let [,value] of map) {
// ...
}
|
输入模块的指定方法
加载模块时,往往需要指定输入哪些方法。解构赋值使得输入语句非常清晰。
| const { SourceMapConsumer, SourceNode } = require("source-map");
|