变量的解构赋值

Posted 2020-08-20 爆炒小黄鸡

一、数组的解构赋值

基本用法

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‘);
({}=[]);