变量的解构赋值

一、数组的解构赋值

基本用法

ES6允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构。

下面的代码表示，可以从数组中提取值，按照位置的对应关系对变量赋值。这种写法属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值。

var [a,b,c]=[1,2,3]
a // 1
b // 2
c // 3

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 [a,[b],d]=[1,[2,3],4];
a //1 
b //2
d //4

 如果等号的右边不是数组，或者严格地说，不是可遍历的结构，那么将会报错。下面的表达式都将报错。

let [foo]=1;
let [foo]=false;
let [foo]=NaN;

 对于Set结构，也可以使用数组的解构赋值。

let [x,y,z]=new Set(["a","b","c"]);
x // "a"

 事实上，只要某种数据结构具有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 //5

 默认值

 解构赋值允许指定默认值。注意ES6内部使用严格相等运算符（“===”）判断一个位置是否有值。所以，如果一个数组成员不严格等于undefined,默认值是不会生效的。

var [x,y='b']=['a'] // x='a'  y='b'

var [x=1]=[undefined]  // x=1

var [x=1]=[null]  // x=null null不严格等于undefined，默认值不生效

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

function f(){
    console.log('aaa');
}
let [x=f()]=[1];

上面的代码中，因为x能取到值，所以函数f根本不会执行。

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

let [x=1,y=2]=[]  // x=1 y=2
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 x用到默认值y时，y还没有声明

 

 二、对象的解构赋值

 对象的解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值由它的位置决定；而对象的属性没有次序，变量必须与属性同名，才能取到正确的值。

var {bar,foo}={foo:'aaa',bar:'bbb'};
foo // 'aaa'
bar // 'bbb'

var {baz}={foo:'aaa',bar:'bbb'};
baz // undefined

 等号左边的baz，bar,foo是变量名，等号右边的foo,bar是属性名

如果变量名与属性名不一致，必须写成下面这样

var {foo:baz}={foo:'aaa',bar:'bbb'};
baz // 'aaa'
foo // error: foo is not defined

let obj={first:'hello',last:'world'};
let {first:f,last:l}=obj;
f // 'hello'
l // 'world'

对象的解构赋值的内部机制，是先找到同名属性，然后再赋给对应的变量。真正被赋值的是后者，而不是前者。比如上面例子中，真正赋值的是baz而不是模式foo。

注意：采用这种写法时，变量的声明和赋值是一体的。对于let和const而言，变量不能重新声明，所以一旦赋值的变量以前声明过，就会报错。

let foo;
let {foo}={foo:1}; // SyntaxError:Duplicate declaration 'foo'

let baz;
let {bar:baz}={bar:1}; // SyntaxError:Duplicate declaration 'baz'

 上面代码中解构赋值的变量都会重新声明，所以报错了。不过因为var命令允许重新声明，所以这个错误只会在使用let和const命令时出现。如果没有第二个let命令，上面的代码就不会报错。

let foo;
({foo}={foo:1}); // 成功 注意大括号

let baz;
({bar:baz}={bar:1}); // 成功 注意大括号

上面的代码是将一个已经声明的变量用于赋值，必须非常小心。

var x;
{x}={x:1}; // SynaxError: syntax error;

 上面的代码写法会报错，因为JS引擎会将{x}理解成一个代码块，从而发生语法错误。只有不将大括号写在行首，避免JS将其解释为代码块，才能解决这个问题。

 和数组一样，解构也可以用于嵌套结构的对象。

var obj={
    p:[
        "Hello",
        {y:'world'}
    ]
};
var {p:[x,{y}]}=obj;
x // 'Hello'
y // 'world'
p // error: p is undefined

这时p是模式，不是变量，因此不会被赋值。

let obj={};
let arr=[];
({foo:obj.prop,bar:arr[0]}={foo:123,bar:true});
obj // {prop:123}
arr // [true]

 对象的解构也可以指定默认值。默认值生效的条件是，对象的属性值严格等于undefined。

var {x,y=5}={x:1} // x=1 y=5

var {message:msg="somthing went wrong"}={};
msg // somthing went wrong

如果解构失败，变量的值就等于undefined。

如果解构模式是嵌套的对象，而且子对象所在的父属性不存在，那么就会报错。

var {foo:{bar}}={bar:'baz'} // 报错

 等号左边对象的foo属性对应一个子对象。该子对象的bar属性解构时会报错。因为foo这时等于undefined，再取子属性就会报错

var temp={baz:'baz'};
temp.foo.bar // 报错

 解构赋值允许等号左边的模式中不放置任何变量名。因此，可以写出非常古怪的赋值表达式。

({}=[true,false]);
({}='abc');
({}=[]);

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

let {log,sin,cos}=Math;

上面的代码将Math对象的取对数、正弦、余弦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

 

四、数值和布尔值的解构赋值

解构赋值时，如果等号右边是数值或布尔值，则会先转为对象。

解构赋值的规则是只要等号右边的值不是对象，就先将其转为对象。由于undefined和null无法转为对象，所以对他们进行解构赋值都会报错。

let {toString:s}=123; // s=Number.prototype.toString

let {prop:x}=undefined; // TypeError
let {prop:y}=null; // TypeError

 

五、函数参数的解构赋值赋值

函数的参数也可以解构赋值。

function add([x,y]){
    return x+y;
}
add([1,2]); //3

上面代码中，函数add的参数实际上不是一个数组，而是通过解构得到的变量x和y。

下面是另一个例子：

[[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]

上面代码中，函数move的参数是一个对象，通过对这个对象进行解构，得到变量x和y的值。如果解构失败，x和y等于默认值。

注意，下面的写法会得到不一样的结果。

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]

上面代码是为函数move的参数指定默认值，而不是为变量x和y指定默认值，所以会得到与前一种写法不同的结果。

undefined会触发函数参数的默认值。

[1, undefined, 3].map((x = 'yes') => x);
// [ 1, 'yes', 3 ]

 

六、圆括号问题

建议只要有可能，就不要在模式中放置圆括号。

七、用途

1）交换变量的值

[x, y] = [y, x];

 

2）从函数返回多个值

函数只能返回一个值，如果要返回多个值，只能将它们放在数组或对象里返回。有了解构赋值，取出这些值就非常方便。

// 返回一个数组

function example() {
  return [1, 2, 3];
}
var [a, b, c] = example();

// 返回一个对象

function example() {
  return {
    foo: 1,
    bar: 2
  };
}
var { 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数据

var jsonData = {
  id: 42,
  status: "OK",
  data: [867, 5309]
};

let { id, status, data: number } = jsonData;

console.log(id, status, number);
// 42, "OK", [867, 5309]

 

5）函数参数的默认值

6）遍历Map解构

任何部署了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);
}
// first is hello
// second is world

如果只想获取键名，或者只想获取键值，可以写成下面这样。

// 获取键名
for (let [key] of map) {
  // ...
}

// 获取键值
for (let [,value] of map) {
  // ...
}

 

7）输入模块的指定方法

加载模块时，往往需要指定输入那些方法。解构赋值使得输入语句非常清晰。

const { SourceMapConsumer, SourceNode } = require("source-map");