ES6扩展运算符（...）

在使用vuex的过程中，经常会碰到以下写法：

...mapGetters('user',['classList','class','subjectList','termList'])

在不了解ES6的扩展运算符前，对这种写法很迷惑，不懂...的作用到底是什么，于是通过《ECMAScript 6 入门》一书，学习了扩展运算符的相关知识。

数组的扩展运算符

概念

扩展运算符（spread）是三个点（...）。它好比 rest 参数的逆运算，将一个数组转为用逗号分隔的参数序列。扩展运算符与正常的函数参数可以结合使用，后面也可以放置表达式，但如果后面是一个空数组，则不产生任何效果。
```
let arr = [];
arr.push(...[1,2,3,4,5]);
console.log(arr); //[1,2,3,4,5]
console.log(1, ...[2, 3, 4], 5) //1 2 3 4 5
console.log(...(1 > 0 ? ['a'] : [])); //a
console.log([...[], 1]); //[1]
```
意义
1. 替代函数的apply方法
  
  由于扩展运算符可以展开数组，所以不再需要apply方法，将数组转为函数的参数了。
```
// ES5 的写法
Math.max.apply(null, [14, 3, 77])
// ES6 的写法
Math.max(...[14, 3, 77])
```
应用
1. 复制数组
```
// ES5 的写法
const a1 = [1, 2];
const a2 = a1.concat();
// ES6 的写法
const a1 = [1, 2];
const a2 = [...a1];
//或
const [...a2] = a1;
```
2. 合并数组
```
// ES5 的写法
[1, 2].concat(more);
arr1.concat(arr2, arr3);
// ES6 的写法
[1, 2, ...more];
[...arr1, ...arr2, ...arr3]
```
3. 与解构赋值结合
```
// ES5 的写法
a = list[0], rest = list.slice(1)
// ES6 的写法
[a, ...rest] = list
```
  注意：如果将扩展运算符用于数组赋值，只能放在参数的最后一位，否则会报错。
4. 转换字符串
  
  扩展运算符还可以将字符串转为真正的数组，并且能够正确识别四个字节的 Unicode 字符。
```
'x\uD83D\uDE80y'.length // 4
[...'x\uD83D\uDE80y'].length // 3

let str = 'x\uD83D\uDE80y';
str.split('').reverse().join('') // 'y\uDE80\uD83Dx'
[...str].reverse().join('')      // 'y\uD83D\uDE80x'
```
5. 实现Iterator接口的对象
  
  任何 Iterator 接口的对象（参阅 Iterator 一章），都可以用扩展运算符转为真正的数组。
6. Map和Set结构、Generator函数
  - 扩展运算符内部调用的是数据结构的 Iterator 接口，因此只要具有 Iterator 接口的对象，都可以使用扩展运算符，比如 Map 结构。
```
let map = new Map([
 [1, 'one'],
 [2, 'two'],
 [3, 'three'],
]);

let arr = [...map.keys()]; // [1, 2, 3]
```
  - Generator 函数运行后，返回一个遍历器对象，因此也可以使用扩展运算符。
```
const go = function*(){
 yield 1;
 yield 2;
 yield 3;
};

[...go()] // [1, 2, 3]
```
  - 如果对没有 Iterator 接口的对象，使用扩展运算符，将会报错。

对象的扩展运算符

概念

对象的解构赋值用于从一个对象取值，相当于将目标对象自身的所有可遍历的（enumerable）、但尚未被读取的属性，分配到指定的对象上面。所有的键和它们的值，都会拷贝到新对象上面。
```
let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
x // 1
y // 2
z // { a: 3, b: 4 }
```
注意：
1. 由于解构赋值要求等号右边是一个对象，所以如果等号右边是undefined或null，就会报错，因为它们无法转为对象。
2. 解构赋值必须是最后一个参数，否则会报错。
3. 解构赋值的拷贝是浅拷贝，即如果一个键的值是复合类型的值（数组、对象、函数）、那么解构赋值拷贝的是这个值的引用，而不是这个值的副本。
```
let obj = { a: { b: 1 } };
let { ...x } = obj;
obj.a.b = 2;
x.a.b // 2
```
4. 扩展运算符的解构赋值，不能复制继承自原型对象的属性。
```
let o1 = { a: 1 };
let o2 = { b: 2 };
o2.__proto__ = o1;
let { ...o3 } = o2;
o3 // { b: 2 }
o3.a // undefined


const o = Object.create({ x: 1, y: 2 });
o.z = 3;

let { x, ...newObj } = o;
let { y, z } = newObj;
x // 1
y // undefined
z // 3

let { x, ...{ y, z } } = o;
// SyntaxError: ... must be followed by an identifier in declaration contexts
```

应用

扩展某个函数的参数，引入其他操作。

function baseFunction({ a, b }) {
// ...
}
function wrapperFunction({ x, y, ...restConfig }) {
// 使用 x 和 y 参数进行操作
// 其余参数传给原始函数
return baseFunction(restConfig);
}

取出参数对象的所有可遍历属性，拷贝到当前对象之中。

let z = { a: 3, b: 4 };
let n = { ...z };
n // { a: 3, b: 4 }

let aClone = { ...a };
// 等同于
let aClone = Object.assign({}, a);

//上面的例子只是拷贝了对象实例的属性，如果想完整克隆一个对象，还拷贝对象原型的属性，可以采用下面的写法。
// 写法一
const clone1 = Object.assign(
Object.create(Object.getPrototypeOf(obj)),
obj
);
// 写法二
const clone2 = Object.create(
Object.getPrototypeOf(obj),
Object.getOwnPropertyDescriptors(obj)
)

合并两个对象。

let ab = { ...a, ...b };
// 等同于
let ab = Object.assign({}, a, b);


//如果用户自定义的属性，放在扩展运算符后面，则扩展运算符内部的同名属性会被覆盖掉。
let aWithOverrides = { ...a, x: 1, y: 2 };
// 等同于
let aWithOverrides = { ...a, ...{ x: 1, y: 2 } };
// 等同于
let x = 1, y = 2, aWithOverrides = { ...a, x, y };
// 等同于
let aWithOverrides = Object.assign({}, a, { x: 1, y: 2 });

修改现有对象部分的属性。

let newVersion = {
...previousVersion,
name: 'New Name' // Override the name property
};

其他
- 如果把自定义属性放在扩展运算符前面，就变成了设置新对象的默认属性值。
- 与数组的扩展运算符一样，对象的扩展运算符后面可以跟表达式。
- 如果扩展运算符后面是一个空对象，则没有任何效果。
- 如果扩展运算符的参数是null或undefined，这两个值会被忽略，不会报错。
- 扩展运算符的参数对象之中，如果有取值函数get，这个函数是会执行的。

ES6扩展运算符（...）

数组的扩展运算符

对象的扩展运算符

猜你喜欢