ES6 允许按照一定模式, 从数组和对象中提取值, 对变量进行赋值, 这被称为解构 (Destructuring).
1. 数组的解构赋值
- let [foo, [[bar], baz]] = [1, [[2], 3]];
- foo // 1
- bar // 2
- baz // 3
- let [ , , third] = ["foo", "bar", "baz"];
- third // "baz"
- let [x, , y] = [1, 2, 3];
- x // 1
- y // 3
- let [head, ...tail] = [1, 2, 3, 4];
- head // 1
- tail // [2, 3, 4]
- let [x, y, ...z] = ['a'];
- x // "a"
- y // undefined
- z // []
- // 如果解构不成功, 变量的值就等于 undefined.
- let [foo] = [];
- let [bar, foo] = [1];
- foo // undefined
- let [x, y] = [1, 2, 3];
- x // 1
- y // 2
- let [a, [b], d] = [1, [2, 3], 4];
- a // 1
- b // 2
- d // 4
- // 报错
- let [foo] = 1;
- let [foo] = false;
- let [foo] = NaN;
- let [foo] = undefined;
- let [foo] = null;
- let [foo] = {};
默认值
- let [foo = true] = [];
- foo // true
- let [x, y = 'b'] = ['a']; // x='a', y='b'
- let [x, y = 'b'] = ['a', undefined]; // x='a', y='b'
- // 注意, ES6 内部使用严格相等运算符 (===), 判断一个位置是否有值. 所以, 只有当一个数组成员严格等于 undefined, 默认值才会生效.
- let [x = 1] = [undefined];
- x // 1
- let [x = 1] = [null];
- x // 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
2. 对象的解构赋值
对象的解构与数组有一个重要的不同. 数组的元素是按次序排列的, 变量的取值由它的位置决定; 而对象的属性没有次序, 变量必须与属性同名, 才能取到正确的值.
- let { bar, foo } = { foo: "aaa", bar: "bbb" };
- foo // "aaa"
- bar // "bbb"
- let { baz } = { foo: "aaa", bar: "bbb" };
- baz // undefined
如果变量名与属性名不一致, 必须写成下面这样.
- 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 obj = {
- p: [
- 'Hello',
- { y: 'World' }
- ]
- };
- let { p: [x, { y }] } = obj;
- x // "Hello"
- y // "World"
- let obj = {
- p: [
- 'Hello',
- { y: 'World' }
- ]
- };
- let { p, p: [x, { y }] } = obj;
- x // "Hello"
- y // "World"
- p // ["Hello", {y: "World"}]
- 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
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
4. 数值和布尔值的解构赋值
解构赋值时, 如果等号右边是数值和布尔值, 则会先转为对象.
- let {toString: s} = 123;
- s === Number.prototype.toString // true
- let {toString: s} = true;
- s === Boolean.prototype.toString // true
上面代码中, 数值和布尔值的包装对象都有 toString 属性, 因此变量 s 都能取到值.
解构赋值的规则是, 只要等号右边的值不是对象或数组, 就先将其转为对象. 由于 undefined 和 null 无法转为对象, 所以对它们进行解构赋值, 都会报错.
- let { prop: x } = undefined; // TypeError
- let { prop: y } = null; // TypeError
5. 函数参数的解构赋值
函数的参数也可以使用解构赋值.
- function add([x, y]){
- return x + y;
- }
- add([1, 2]); // 3
- [[1, 2], [3, 4]].map(([a, b]) => a + b);
- // [ 3, 7 ]
函数参数的解构也可以使用默认值.
- function move({x = 0, y = 0} = {}) {
- return [x, y];
- }
- move({x: 3, y: 8}); // [3, 8]
- move({x: 3}); // [3, 0]
- move({}); // [0, 0]
- move(); // [0, 0]
- function move({x, y} = { x: 0, y: 0 }) {
- return [x, y];
- }
- move({x: 3, y: 8}); // [3, 8]
- move({x: 3}); // [3, undefined]
- move({}); // [undefined, undefined]
- move(); // [0, 0]
6. 用途
(1) 交换变量的值
- let x = 1;
- let y = 2;
- [x, y] = [y, x];
(2) 从函数返回多个值
函数只能返回一个值, 如果要返回多个值, 只能将它们放在数组或对象里返回. 有了解构赋值, 取出这些值就非常方便.
- // 返回一个数组
- function example() {
- return [1, 2, 3];
- }
- let [a, b, c] = example();
- // 返回一个对象
- function example() {
- return {
- foo: 1,
- bar: 2
- };
- }
- let { foo, bar } = example();
(3) 函数参数的定义
// 参数是一组有次序的值
function f([x, y, z]) { ... }
- f([1, 2, 3]);
- // 参数是一组无次序的值
function f({x, y, z}) { ... }
f({z: 3, y: 2, x: 1});
(4) 提取 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]
(5) 函数参数的默认值
指定参数的默认值, 就避免了在函数体内部再写 var foo = config.foo || 'default foo'; 这样的语句.
- jQuery.ajax = function (url, {
- async = true,
- beforeSend = function () {},
- cache = true,
- complete = function () {},
- crossDomain = false,
- global = true,
- // ... more config
- } = {}) {
- // ... do stuff
- };
(6) 遍历 Map 结构
- 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) {
- // ...
- }
(7) 输入模块的指定方法
加载模块时, 往往需要指定输入哪些方法. 解构赋值使得输入语句非常清晰.
const { SourceMapConsumer, SourceNode } = require("source-map");
来源: http://www.qdfuns.com/article/18271/b60d713dc1de5b9532fd658cdcb3783b.html