ES6学习（解构）

解构

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

相比较于之前的直接给变量赋值，ES6可以写成这样：

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

相当于之前的：

var a = 1;
var b = 2;
var c = 3;

如果解构不成功，变量的值就等于undefined（比如下面例子中的 foo）。

var [foo] = [];    //undefined
var [bar, foo] = [1];     //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

从上面的例子可以看见：等号左边的模式，只匹配一部分的等号右边的数组。这种情况下，解构依然可以成功。

默认值

解构赋值允许指定默认值。之前在第一篇关于ES6的博客中也学习到了默认值这一属性。

var [foo = true] = [];
foo // true

[x, y = 'b'] = ['a']; // x='a', y='b'
[x, y = 'b'] = ['a', undefined]; // x='a', y='b'

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

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

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

上面代码中，如果一个数组成员是null，默认值就不会生效，因为null不严格等于undefined。

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

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

上面最后一个表达式之所以会报错，是因为x用到默认值y时，y还没有声明。

对象解构

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

var { x,y } = { x: "x", y: "y" };
x // "x"
y // "y"

对于下面的例子，等号左边的两个变量的次序，与等号右边两个同名属性的次序不一致，但是对取值完全没有影响。第二个例子的变量没有对应的同名属性，导致取不到值，最后等于undefined。

var { x, y } = { x: "x", y: "y" };
x // "x"
y // "y"

var { a } = { foo: "aaa", bar: "bbb" };
a // undefined

如果变量名和属性值不一样，如下写（从格式中能看出来）：

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

对象的解构也可以指定默认值。

var {x = 3} = {};
x // 3

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

上面代码中，如果x属性等于null，就不严格相等于undefined，导致默认值不会生效。

数组解构

由于数组本质是特殊的对象，因此可以对数组进行对象属性的解构。

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

上面代码对数组进行对象解构。数组arr的0键对应的值是1，[arr.length - 1]就是2键，对应的值是3

比如交换两个数字的值。以前的写法：

let a = 3;
let b = 4;
let temp;
temp = a;
a = b ;
b = temp;

学习了解构之后，可以这样：

字符串的解构

字符串也可以解构赋值。这是因为此时，字符串被转换成了一个类似数组的对象。

const [a, b, c, d, e, f, g] = 'Jackyjk';
a // "J"
b // "a"
c // "c"
d // "k"
e // "y"
f // "j"
g // "k"

let {length : len} = 'Jackyjk';
len // 7

函数参数的解构

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

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]

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

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