解构赋值

 

ES6 允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构。我的理解是解析对象的解构，然后取出值的过程。es6中对变量的赋值遵循一个规则，只要左右两边的模式相同，就可以进行合法赋值。就像下面的例子。

let [a, b, c] = [1, 2, 3];
let [foo, [[bar], baz]] = [1, [[2], 3]];
let [bar, foo] = [1];

如果解构不成功，变量值等于undefined，上面例子中 foo 就等于undefined。

1、数组解构

解构过程中，我们应该把每个解构的部分对应在一起，层层解构。

let [a, [b], d] = [1, [2, 3], 4];
a // 1
b // 2
d // 4

就像上面，[b]对应的是[2,3]，单独解构的话b对应的是2，所以层层解构是合法的。

解构赋值允许指定默认值。

let [foo = true] = [];
foo // true

在使用默认值的时候，应该注意undefined，因为undefined是不能赋值的。

let [x = 1] = [undefined];
x // 1

let [x = 1] = [null];
x // null

function f() {
  console.log('aaa');
}

let [x = f()] = [1];

因为函数只有在调用的时候才会执行，上面例子中x虽然后了默认值，但是1的解构赋值是成功的，所以并不会执行f()。

当然，默认值也是可以使用变量的，但是这个变量必须是已经声明的，其实我们可以把默认值作为一种备胎，当找不到合适对象的时候才会使用备胎，但是这个备胎也不能是你凭空想象的，必须是已经存在的，即合法的。

2、对象解构

上面我们说了，解构赋值只要两边解构相同就行，所以对象也是可以解构赋值的。但是需要注意的是对象和数组的解构有一个很大的区别：对象的属性没有次序，变量必须与属性同名，才能取到正确的值。

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

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

上面第一个例子中，bar取到的值是bbb，并不没有取“第一个”foo，因为这里是不存在所谓的第一个的，第二个例子中就是因为找对象中找不到baz，所以baz的值等于undefined。这其实就算是解构失败了。

通过解构，我们可以很容易的把对象的方法复制给变量，

const { log } = console;
log('hello') // hello

上面的例子中我们就很容易的使用了console.log，但是如果我们想要使用自己自定义的方法名，不想用log怎么办呢？

const { log:minelog } = console;
minelog ('hello') // hello

你会发现这样是合法有效的。如果你想要变量名和属性名不一样，一定要用:这种方式。a:b的这种形式中，a必须是对应中的属性名，b就是自己定义的了，只要合法，写成a:a的形式也是可以的。前面一个是匹配的模式，冒号后的才是被赋值的变量。

对象的解构赋值同样是可以层层解构的，

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}}，loc和start都是模式，只有line是变量，所以对应的是node中搞得line，值为1。

另外，数组和对象的混合模式也是可以的。

当我们使用解构赋值的时候，要注意声明变量的作用域问题，

// 错误的写法
let x;
{x} = {x: 1};

// 正确的写法
let x;
({x} = {x: 1});

上面的例子中错误的原因是{x}被认为是一个块级作用域，导致解构失败，我们在使用解构要尽量避免这种大括号直接在行首的情况。

数组中是一个特殊的对象，所以

let arr = [1, 2, 3];
let {0 : first, [arr.length - 1] : last} = arr;
first // 1
last // 3

也是合法的。

3、字符串解构

字符串本身也是一个对象，有时候，可以当成一个数组解构

const [a, b, c, d, e] = 'hello';
a // "h"
b // "e"
c // "l"
d // "l"
e // "o"

有时候，当做一个对象解构

let {length : len} = 'hello';
len // 5

个人理解，解构都可以当做一个对象处理，只要解构的对象有某些属性或者方法就可以使用。

函数的参数也可以使用解构

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

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

这里[1,2]就在使用前解构成了函数参数并被使用。

总结

解构赋值用处很多，可以很方便的交换值

let x = 1;
let y = 2;

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

对于函数来说，使用解构可以一次返回多个值，

function example() {
  return {
    foo: 1,
    bar: 2
  };
}
let { foo, bar } = example();

提取json对象的数据等等。

在使用解构赋值中，我们要注意圆括号()的使用，建议有可能的话尽量避免在模式中使用圆括号。