2018-07-05 (变量的解构赋值)

变量的解构赋值

从数组和对象中提取值,对变量进行赋值,这被称为解构。


let [a,b,c] = [1,2,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 [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



上面 两个例子,属于 不完全解构,但是可以成功。

如果等号右边 不是数组,那么将会报错。
(严格地说 , 不可遍历的结构)

所以,等号两边的模式相同,才可以对其 赋值。

布尔值

返回的是 true 和 false。

解构赋值 的 规则是 , 只要等号右边的值,不是对象或数组,就先将其转为对象。

由于,undefined 和 null 无法 转为 对象,所以,对他们进行解构赋值,都会报错。


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

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

函数参数的解构赋值。

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

    
   function add([x,y]){
 
   return x + y

}

add([1,2]);  // 3

函数add的参数表面上是一个数组,但在传入参数的那一刻,数组参数就被解构成变量x和y。对于函数内部的代码来说,它们能感受到的参数就是 x 和 y 。

    [ [1,2],[3,4] ].map( ([a,b]) => a+b );

    //   [3,7];

首先,这是个,箭头函数, 传参传的是数组,a,b 。
箭头函数,如果,不写 {} 大括号,直接返回,
如果不需要直接返回的话,写上{},

然后,用 map 这个 方法,循环,解构数组,
先算,二维数组的 求(1,2) 返回 3 ,
再算,(3,4) ,返回 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] 

圆括号问题

解构赋值虽然很方便,但是解析起来并不容易。对于编译器来说,一个式子到底是模式,还是表达式,没有办法从一开始就知道,必须解析到(或解析不到)等号才能知道。

由此带来的问题是,如果模式中出现圆括号怎么处理。ES6 的规则是,只要有可能导致解构的歧义,就不得使用圆括号。

但是,这条规则实际上不那么容易辨别,处理起来相当麻烦。因此,建议只要有可能,就不要在模式中放置圆括号。

不能 使用 圆括号 的 情况。

  1. 变量 声明 语句。
   //  全部报错
   
   let [(a)] = [1];

 let {x: (c)} = {};
 let ({x: c}) = {};
 let {(x: c)} = {};
 let {(x): c} = {};

 let { o: ({ p: p }) } = { o: { p: 2 } };


上面 6 个语句都会报错,因为它们都是变量声明语句,模式不能使用圆括号。

  1. 函数 参数。
// 报错
function f([(z)]) { return z; }
// 报错
function f([z,(x)]) { return x; }



  1. 赋值语句的模式。
// 全部报错
({ p: a }) = { p: 42 };
([a]) = [5];

// 报错
[({ p: a }), { x: c }] = [{}, {}];