含義
擴展運算符（spread）是三個點（...）。它好比 rest 參數的逆運算，將一個數組轉為用逗號分隔的參數序列。
console.log(...[1, 2, 3]) // 1 2 3 console.log(1, ...[2, 3, 4], 5) // 1 2 3 4 5 [...document.querySelectorAll('div')] // [<div>, <div>, <div>]
該運算符主要用於函數調用。
function push(array, ...items) {
array.push(...items);
}
function add(x, y) {
return x + y;
}
const numbers = [4, 38];
add(...numbers) // 42
上面代碼中，array.push(...items)和add(...numbers)這兩行，都是函數的調用，它們都使用了擴展運算符。該運算符將一個數組，變為參數序列。
擴展運算符與正常的函數參數可以結合使用，非常靈活。
function f(v, w, x, y, z) { }
const args = [0, 1];
f(-1, ...args, 2, ...[3]);
擴展運算符后面還可以放置表達式。
const arr = [ ...(x > 0 ? ['a'] : []), 'b', ];
如果擴展運算符后面是一個空數組，則不產生任何效果。
[...[], 1] // [1]
注意，只有函數調用時，擴展運算符才可以放在圓括號中，否則會報錯。
(...[1, 2]) // Uncaught SyntaxError: Unexpected number console.log((...[1, 2])) // Uncaught SyntaxError: Unexpected number console.log(...[1, 2]) // 1 2
上面三種情況，擴展運算符都放在圓括號里面，但是前兩種情況會報錯，因為擴展運算符所在的括號不是函數調用。
替代函數的 apply 方法
由於擴展運算符可以展開數組，所以不再需要apply方法，將數組轉為函數的參數了。
// ES5 的寫法 function f(x, y, z) { // ... } var args = [0, 1, 2]; f.apply(null, args); // ES6的寫法 function f(x, y, z) { // ... } let args = [0, 1, 2]; f(...args);
下面是擴展運算符取代apply方法的一個實際的例子，應用Math.max方法，簡化求出一個數組最大元素的寫法。
// ES5 的寫法 Math.max.apply(null, [14, 3, 77]) // ES6 的寫法 Math.max(...[14, 3, 77]) // 等同於 Math.max(14, 3, 77);
上面代碼中，由於 JavaScript 不提供求數組最大元素的函數，所以只能套用Math.max函數，將數組轉為一個參數序列，然后求最大值。有了擴展運算符以后，就可以直接用Math.max了。
另一個例子是通過push函數，將一個數組添加到另一個數組的尾部。
// ES5的 寫法 var arr1 = [0, 1, 2]; var arr2 = [3, 4, 5]; Array.prototype.push.apply(arr1, arr2); // ES6 的寫法 let arr1 = [0, 1, 2]; let arr2 = [3, 4, 5]; arr1.push(...arr2);
上面代碼的 ES5 寫法中，push方法的參數不能是數組，所以只好通過apply方法變通使用push方法。有了擴展運算符，就可以直接將數組傳入push方法。
下面是另外一個例子。
// ES5 new (Date.bind.apply(Date, [null, 2015, 1, 1])) // ES6 new Date(...[2015, 1, 1]);
擴展運算符的應用
（1）復制數組
數組是復合的數據類型，直接復制的話，只是復制了指向底層數據結構的指針，而不是克隆一個全新的數組。
const a1 = [1, 2]; const a2 = a1; a2[0] = 2; a1 // [2, 2]
上面代碼中，a2並不是a1的克隆，而是指向同一份數據的另一個指針。修改a2，會直接導致a1的變化。
ES5 只能用變通方法來復制數組。
const a1 = [1, 2]; const a2 = a1.concat(); a2[0] = 2; a1 // [1, 2]
上面代碼中，a1會返回原數組的克隆，再修改a2就不會對a1產生影響。
擴展運算符提供了復制數組的簡便寫法。
const a1 = [1, 2]; // 寫法一 const a2 = [...a1]; // 寫法二 const [...a2] = a1;
上面的兩種寫法，a2都是a1的克隆。
（2）合並數組
擴展運算符提供了數組合並的新寫法。
const arr1 = ['a', 'b']; const arr2 = ['c']; const arr3 = ['d', 'e']; // ES5 的合並數組 arr1.concat(arr2, arr3); // [ 'a', 'b', 'c', 'd', 'e' ] // ES6 的合並數組 [...arr1, ...arr2, ...arr3] // [ 'a', 'b', 'c', 'd', 'e' ]
不過，這兩種方法都是淺拷貝，使用的時候需要注意。
const a1 = [{ foo: 1 }];
const a2 = [{ bar: 2 }];
const a3 = a1.concat(a2);
const a4 = [...a1, ...a2];
a3[0] === a1[0] // true
a4[0] === a1[0] // true
上面代碼中，a3和a4是用兩種不同方法合並而成的新數組，但是它們的成員都是對原數組成員的引用，這就是淺拷貝。如果修改了引用指向的值，會同步反映到新數組。
（3）與解構賦值結合
擴展運算符可以與解構賦值結合起來，用於生成數組。
// ES5 a = list[0], rest = list.slice(1) // ES6 [a, ...rest] = list
下面是另外一些例子。
const [first, ...rest] = [1, 2, 3, 4, 5]; first // 1 rest // [2, 3, 4, 5] const [first, ...rest] = []; first // undefined rest // [] const [first, ...rest] = ["foo"]; first // "foo" rest // []
如果將擴展運算符用於數組賦值，只能放在參數的最后一位，否則會報錯。
const [...butLast, last] = [1, 2, 3, 4, 5]; // 報錯 const [first, ...middle, last] = [1, 2, 3, 4, 5]; // 報錯
（4）字符串
擴展運算符還可以將字符串轉為真正的數組。
[...'hello'] // [ "h", "e", "l", "l", "o" ]
上面的寫法，有一個重要的好處，那就是能夠正確識別四個字節的 Unicode 字符。
'x\uD83D\uDE80y'.length // 4 [...'x\uD83D\uDE80y'].length // 3
上面代碼的第一種寫法，JavaScript 會將四個字節的 Unicode 字符，識別為 2 個字符，采用擴展運算符就沒有這個問題。因此，正確返回字符串長度的函數，可以像下面這樣寫。
function length(str) { return [...str].length; } length('x\uD83D\uDE80y') // 3
凡是涉及到操作四個字節的 Unicode 字符的函數，都有這個問題。因此，最好都用擴展運算符改寫。
let str = 'x\uD83D\uDE80y'; str.split('').reverse().join('') // 'y\uDE80\uD83Dx' [...str].reverse().join('') // 'y\uD83D\uDE80x'
上面代碼中，如果不用擴展運算符，字符串的reverse操作就不正確。
（5）實現了 Iterator 接口的對象
任何定義了遍歷器（Iterator）接口的對象（參閱 Iterator 一章），都可以用擴展運算符轉為真正的數組。
let nodeList = document.querySelectorAll('div');
let array = [...nodeList];
上面代碼中，querySelectorAll方法返回的是一個NodeList對象。它不是數組，而是一個類似數組的對象。這時，擴展運算符可以將其轉為真正的數組，原因就在於NodeList對象實現了 Iterator 。
Number.prototype[Symbol.iterator] = function*() { let i = 0; let num = this.valueOf(); while (i < num) { yield i++; } } console.log([...5]) // [0, 1, 2, 3, 4]
上面代碼中，先定義了Number對象的遍歷器接口，擴展運算符將5自動轉成Number實例以后，就會調用這個接口，就會返回自定義的結果。
對於那些沒有部署 Iterator 接口的類似數組的對象，擴展運算符就無法將其轉為真正的數組。
let arrayLike = { '0': 'a', '1': 'b', '2': 'c', length: 3 }; // TypeError: Cannot spread non-iterable object. let arr = [...arrayLike];
上面代碼中，arrayLike是一個類似數組的對象，但是沒有部署 Iterator 接口，擴展運算符就會報錯。這時，可以改為使用Array.from方法將arrayLike轉為真正的數組。
（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]
上面代碼中，變量go是一個 Generator 函數，執行后返回的是一個遍歷器對象，對這個遍歷器對象執行擴展運算符，就會將內部遍歷得到的值，轉為一個數組。
如果對沒有 Iterator 接口的對象，使用擴展運算符，將會報錯。
const obj = {a: 1, b: 2};
let arr = [...obj]; // TypeError: Cannot spread non-iterable object