解构赋值的概念

解构赋值：ES6 允许我们，按照一一对应的方式，从数组或者对象中提取值，再将提取出来的值赋值给变量。

解构：分解数据结构；赋值：给变量赋值。

解构赋值在实际开发中可以大量减少我们的代码量，并且让程序结构更清晰。

数组的解构赋值

数组的结构赋值：将数组中的值按照位置提取出来，然后赋值给变量。

语法

在 ES6 之前，当我们在为一组变量赋值时，一般是这样写：

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

或者是这样写：

  1. var arr = [1, 2, 3];
  3. var a = arr[0];
  4. var b = arr[1];
  5. var c = arr[2];

现在有了 ES6 之后，我们可以通过数组解构的方式进行赋值：（根据位置进行一一对应）

  1. let [a, b, c] = [1, 2, 3];

二者的效果是一样的，但明显后者的代码更简洁优雅。

未匹配到的情况

数据的结构赋值，是根据位置进行一一对应来赋值的。可如果左边的数量大于右边的数量时（也就是变量的数量大于值的数量时），多余的变量要怎么处理呢？

答案是：如果变量在一一对应时，没有找到对应的值，那么，多余的变量会被赋值为 undefined。

解构时，左边允许有默认值

在解构赋值时，是允许使用默认值的。举例如下：

  1. {
  2.     //一个变量时
  3.     let [foo = true] = [];
  4.     console.log(foo); //输出结果：true
  5. }
  7. {
  8.     //两个变量时
  9.     let [a, b] = ['生命壹号']; //a 赋值为：生命壹号。b没有赋值
  10.     console.log(a + ',' + b); //输出结果：生命壹号,undefined
  11. }
  13. {
  14.     //两个变量时
  15.     let [a, b = 'smyhvae'] = ['生命壹号']; //a 赋值为：生命壹号。b 采用默认值 smyhvae
  16.     console.log(a + ',' + b); //输出结果：生命壹号,smyhvae
  17. }

将右边的 undefined和null赋值给变量

如果我们在赋值时，采用的是 undefined或者null，那会有什么区别呢？

  1. {
  2.     let [a, b = 'smyhvae'] = ['生命壹号', undefined]; //b 虽然被赋值为 undefined，但是 b 会采用默认值
  3.     console.log(a + ',' + b); //输出结果：生命壹号,smyhvae
  4. }
  6. {
  7.     let [a, b = 'smyhvae'] = ['生命壹号', null]; //b 被赋值为 null
  8.     console.log(a + ',' + b); //输出结果：生命壹号,null
  9. }

上方代码分析：

  • undefined：相当于什么都没有，此时 b 采用默认值。
  • null：相当于有值，但值为 null。

对象的解构赋值

对象的结构赋值：将对象中的值按照属性匹配的方式提取出来，然后赋值给变量。

语法

在 ES6 之前，我们从接口拿到 json 数据后，一般这么赋值：

  1. var name = json.name;
  3. var age = json.age;
  5. var sex = json.sex;

上面这种写法，过于麻烦了。

现在，有了 ES6 之后，我们可以使用对象解构的方式进行赋值。举例如下：

  1. const person = { name: 'qianguyihao', age: 28, sex: '男' };
  2. let { name, age, sex } = person; // 对象的结构赋值
  4. console.log(name); // 打印结果：qianguyihao
  5. console.log(age); // 打印结果：28
  6. console.log(sex); // 打印结果：男

上方代码可以看出，对象的解构与数组的结构，有一个重要的区别：数组的元素是按次序排列的，变量的取值由它的位置决定；而对象的属性没有次序，是根据键来取值的。

未匹配到的情况

对象的结构赋值，是根据属性名进行一一对应来赋值的。可如果左边的数量大于右边的数量时（也就是变量的数量大于值的数量时），多余的变量要怎么处理呢？

答案是：如果变量在一一对应时，没有找到对应的值，那么，多余的变量会被赋值为 undefined。

给左边的变量自定义命名

对象的结构赋值里，左边的变量名一定要跟右边的属性名保持一致么？答案是不一定。我们可以单独给左边的变量自定义命名。

举例如下：

  1. const person = { name: 'qianguyihao', age: 28 };
  2. let { name: myName, age: myAge } = person; // 对象的结构赋值
  4. console.log(myName); // 打印结果：qianguyihao
  5. console.log(myAge); // 打印结果：28
  7. console.log(name); // 打印报错：Uncaught ReferenceError: name is not defined
  8. console.log(age); // 打印报错：Uncaught ReferenceError: age is not defined

上方的第 2 行代码中：（请牢记）

  • 等号左边的属性名 name、age 是对应等号右边的属性名。
  • 等号左边的 myName、myAge 是左边自定义的变量名。

或者，我们也可以理解为：将右边 name 的值赋值给左边的 myName 变量，将右边 age 的值赋值给左边的 myAge 变量。现在，你应该一目了然了吧？

圆括号的使用

如果变量 foo 在解构之前就已经定义了，此时你再去解构，就会出现问题。下面是错误的代码，编译会报错：

  1.     let foo = 'haha';
  2.     { foo } = { foo: 'smyhvae' };
  3.     console.log(foo);

要解决报错，只要在解构的语句外边，加一个圆括号即可：

  1. let foo = 'haha';
  2. ({ foo } = { foo: 'smyhvae' });
  3. console.log(foo); //输出结果：smyhvae

字符串解构

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

  1. const [a, b, c, d] = 'hello';
  2. console.log(a);
  3. console.log(b);
  4. console.log(c);
  6. console.log(typeof a); //输出结果：string

打印结果：

  1. h
  2. e
  3. l
  4. string

for … of 循环

ES6 中，如果我们要遍历一个数组，可以这样做：

  1.     let arr1 = [1, 2, 3, 4, 5];
  3.     for (let value of arr1) {
  4.         console.log(value);
  5.     }

输出结果：

05-ES6：变量的解构赋值 - 图1

for…of 的循环可以避免我们开拓内存空间，增加代码运行效率，所以建议大家在以后的工作中使用for…of循环。

注意，上面的数组中，for ... of获取的是数组里的值；for ... in获取的是index索引值。

Map对象的遍历

for ... of既可以遍历数组，也可以遍历Map对象。

模板字符串

我们以前让字符串进行拼接的时候，是这样做的：（传统写法的字符串拼接）

  1.     var name = 'smyhvae';
  2.     var age = '26';
  3.     console.log('name:'+name+',age:'+age);   //传统写法

这种写法，比较繁琐，而且容易出错。

现在有了 ES6 语法，字符串拼接可以这样写：

  1.     var name = 'smyhvae';
  2.     var age = '26';
  4.     console.log('name:'+name+',age:'+age);   //传统写法
  6.     console.log(`name:${name},age:${age}`);  //ES6 写法

注意，上方代码中，倒数第二行用的符号是单引号，最后一行用的符号是反引号（在tab键的上方）。