ES6 系列 —— 变量的解构赋值

1. 什么是解构赋值

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

2. 数组的解构赋值

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 [x, y] = [1, 2, 3];
x // 1
y // 2

3. 对象的解构赋值

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

let {bar, baz} = {bar: "a", baz: "b"};
bar // a
baz // b

let {foo: foo, baz: baz} = {foo: "a", baz: "b"};
foo // a

对象解构赋值的内部机制，是先找到同名属性，再赋给对应的变量，真正被赋值的是后者，而不是前者。前者是匹配的模式，后者是变量。

嵌套结构的对象赋值：
let obj = {
    p: [
        'Hello',
        {y: 'World'}
    ]
}
let {p, p: [x, {y}]} = obj;
p // ['Hello', {y: 'World'}]
x // Hello
y // World

4. 字符串的解构赋值

字符串也可以进行解构赋值。此时，字符串被转换成一个类似数组的对象。

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

5. 用途

• 交换变量的值

let x = 1;
let y = 2;
[x, y] = [y, x];

• 从函数返回多个值 函数只能返回一个值，如果要返回多个值，只能将它们放在数组或对象中返回。使用解构赋值，对于取值会更方便。

// 返回一个数组
function simple() {
    return [1, 2, 3];
}
let [a, b, c] = simple();

// 返回一个对象
function simple() {
    return {
        foo: 1,
        bar: 2
    }
}
let {foo, bar} = simple();

• 函数参数的定义

function f([x, y, z]) {...}
f([1, 2, 3]);

• 提取JSON数据

let jsonData = {
    name: "Champion",
    age: 18,
    hobbies: ["Run", "Badminton", "Coding"]
}
let {name, age, hobbies: interest} = jsonData;
name // Champion
age // 18
hobbies // ["Run", "Badminton", "Coding"]

• 输入模块的指定方法

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