5种有趣的 Javascript 解构

回顾之前写的代码，处处能看到解构赋值。 读取对象属性和访问数组内容是常常的操做。解构赋值可让这种操做变得简洁明了。 这篇文章中我介绍了 5 种解构方式，它们超出了基本的使用范畴。

1. 交换变量

一般状况下，交换变量的场景以下：

let a = 1;
let b = 2;
let temp;

temp = a;
a = b;
b = temp;

a; // => 2
b; // => 1
复制代码

temp 做为临时变量保存了 a 的值。而后 a 保存了 b 的值，b 保存了 temp 的值。

解构的方式就比较简单了，它没有用到任何临时变量，以下：

let a = 1;
let b = 2;

[a, b] = [b, a];

a; // => 2
b; // => 1
复制代码

[a, b] = [b, a] 是一种解构赋值。右侧的数组建立了 [b, a] 对应值是 [2, 1]。第一个项 2 赋值给了 a，第二个项 1 赋值给了 b。

参数的个数是不受限定的，请参考下面的列子：

let zero = 2;
let one = 1;
let two = 0;

[zero, one, two] = [two, one, zero];

zero; // => 0
one;  // => 1
two;  // => 2
复制代码

2. 访问数组

若是存在一个可能有空项的数组。你须要访问其中任意位置的元素，可是这个元素不必定存在。 一般使用数组的长度属性来遍历：

const colors = [];

let firstColor = 'white';
if (colors.length > 0) {
 firstColor = colors[0];
}

firstColor; // => 'white'
复制代码

解构能够更优雅的实现：

const colors = [];

const [firstColor = 'white'] = colors;

firstColor; // => 'white'
复制代码

const [firstColor = 'white'] = colors 给 firstColor 解构了 colors 数组而后赋值。若是数组没有任何元素，那么 默认值是 white。

它还能够更灵活。若是你只想访问第二个元素，能够这样写：

const colors = [];

const [, secondColor = 'black'] = colors;

secondColor; // => 'black'
复制代码

注意左边的逗号，它的意思是忽略第一个元素。secondColor 从 colors 数组中的第二项开始指派。

3. 不可变操做

在 react 和 redux 中，咱们经常须要遵循不可变数据的规范。刚开始作可能以为有点难，以后会发现它的好处：能够很容易处理无序数据流。

不可变意味着禁止改变对象。解构能够帮助你在不可变方法中容易地实现某些操做。

解构经过 ... 剩余操做符来清理数组的第一个元素：

const numbers = [1, 2, 3];

const [, ...fooNumbers] = numbers;

fooNumbers; // => [2, 3]
numbers; // => [1, 2, 3]
复制代码

解构操做建立了新的数组，注意左边的逗号，新数组忽略了 numbers 数组的第一个元素。 同时 numbers 保持不变。 一样的不可变操做能够从对象中删除属性。咱们试试从其余对象中删除 foo 属性。

const big = {
 foo: 'value Foo',
 bar: 'value Bar'
};

const { foo, ...small } = big;

small; // => { bar: 'value Bar' }
big; // => { foo: 'value Foo', bar: 'value Bar' }
复制代码

4. 解构迭代

以前的例子都是在数组中。咱们也能够解构任何对象，来实现迭代控制。

许多原始基本类型和对象能够迭代。数组，字符串，类数组，set，和 map 等。 好比你能够解构一个字符串：

const str = 'cheese';

const [firstChar = ''] = str;

firstChar; // => 'c'
复制代码

没必要受限于基本类型。解构能够做用在任何能够迭代的数据中。

movies 是一个对象。当解构它时，咱们想获得movie 的 title。来看看下面自定义的迭代：

const movies = {
  list: [
    { title: 'Heat' },
    { title: 'Interstellar' }
  ],
  [Symbol.iterator]() {
    let index = 0;
    return {
      next: () => {
        if (index < this.list.length) {
          const value = this.list[index++].title;
          return { value, done: false };
        }
        return { done: true };
      }
    };
  }
};

const [firstMovieTitle] = movies;
console.log(firstMovieTitle); // => 'Heat'
复制代码

经过定义 Symbol.iterator 来实现迭代协议。该协议遵循解构对象时执行的过程，当经过 const [firstMovieTitle] = movies; 访问时，只会返回 title。

5. 解构动态属性

就我我的经验，解构对象属性比解构数组要常见。 解构对象看起来比较简单：

const movie = { title: 'Heat' };

const { title } = movie;

title; // => 'Heat'
复制代码

const { title } = movie 建立了一个 title 变量，而后把 movie.title 赋值给了该变量。

你可使用动态属性名来解构对象。

function greet(obj, nameProp) {
 const { [nameProp]: name = 'Unknown' } = obj;
 return `Hello, ${name}!`;
}

greet({ name: 'Batman' }, 'name'); // => 'Hello, Batman!'
greet({ }, 'name'); // => 'Hello, Unknown!'
复制代码

greet 方法调用两个参数，对象和属性名。 在 greet 内部，解构赋值读取了动态属性名，使用方括号包起来。

更好的方式是添加一个默认值 unknown，以防属性不存在。

6.总结

解构在访问对象属性和数组元素时，是十分有用的。在上面的例子中，解构在交换变量，访问元素执行不变对象操做都有体现。你还有什么其余的解构方案吗？请在评论区留言。

参考文章

1. 5-interesting-uses-javascript-destructuring