陣列是 JavaScript 裡最常被使用的資料結構,而它身上的方法幾乎撐起了日常開發的一半工作。這篇文章把 22 個原生方法拆成十類:物件繼承、型別轉換、堆疊與佇列、排序、拼接、建立子陣列、刪改、位置搜尋、歸併、迭代,並標明哪些會改動原陣列。
陣列本質上是特殊的物件,因此繼承了 Object 的 toString()、toLocaleString() 與 valueOf()。
[1,2,3].toString(); // '1,2,3' ['a','b','c'].toString(); // 'a,b,c' [1,[2,'c']].toString(); // '1,2,c'(巢狀會被攤平串接) alert([1,2,3]); // '1,2,3',alert 內部會呼叫 toString() var a = [1, 2, 3]; a.valueOf() instanceof Array; // true,valueOf 回傳陣列本身
toLocaleString() 是 toString() 的地區化版本,它呼叫的是每個元素的 toLocaleString(),因此結果不一定相同:
var person1 = { toLocaleString: function(){ return 'Nikolaos'; },
toString: function(){ return 'Nicholas'; } };
var person2 = { toLocaleString: function(){ return 'Grigorios'; },
toString: function(){ return 'Greg'; } };
var people = [person1, person2];
people.toString(); // 'Nicholas,Greg'
people.toLocaleString(); // 'Nikolaos,Grigorios'
無論哪一個方法,元素為 null 或 undefined 時都會以空字串呈現:[1,undefined,2,null,3].toString() 得到 '1,,2,,3'。
join() 可以自訂分隔符,是 String.split() 的逆向操作。不傳參數時等同於逗號分隔。
var a = [1,2,3];
a.join(); // '1,2,3'
a.join(' '); // '1 2 3'
a.join(''); // '123'
new Array(10).join('-'); // '---------',九個連字號
// 也可作用在類陣列物件上
Array.prototype.join.call('hello', '-'); // "h-e-l-l-o"
Array.prototype.join.call({0:'a',1:'b',length:2}, '-'); // 'a-b'
push() 與 pop() 一頭進、一頭出,構成 LIFO 堆疊;shift() 與 push() 搭配則是 FIFO 佇列。這四個方法都會改動原陣列。
var a = [];
a.push(1); // 回傳新長度 1
a.push('a'); // 2
a.push(true, {}); // 4
var b = ['a','b','c'];
b.pop(); // 回傳 'c',b 變成 ['a','b']
b.shift(); // 回傳 'a',b 變成 ['b']
b.unshift('x','y','z'); // 回傳 5,元素順序與參數一致
// 合併兩個陣列
var x = [1,2,3], y = [4,5,6];
Array.prototype.push.apply(x, y); // x 變成 [1,2,3,4,5,6]
空陣列呼叫 pop() 或 shift() 不會拋錯,而是回傳 undefined。另外注意,用 call 傳陣列會被當成單一參數塞進去,這與 apply 的行為不同。
reverse() 反轉順序,sort() 預設以字串形式做字典序排序,兩者都會改動原陣列。這也是為什麼 [1,5,10,50].sort() 會得到 [1,10,5,50]。
function compare(a, b) { return a - b; }
[5,50,1,10].sort(compare); // [1,5,10,50]
// 不分大小寫排序
['ant','Bug','cat','Dog'].sort(function (s, t) {
var a = s.toLowerCase(), b = t.toLowerCase();
return a < b ? -1 : a > b ? 1 : 0;
}); // ['ant','Bug','cat','Dog']
// 順便打亂:經典 but 有效的小技巧
[1,2,3,4,5].sort(function () { return Math.random() - 0.5; });
concat() 先複製一份原陣列,再把參數附加到副本後面,不影響原陣列。參數若是陣列,會被逐一攤平一層;若不是陣列,則整值附加。
var numbers = [1,2]; numbers.concat(3,4); // [1,2,3,4] numbers.concat([5,4],[3,4],1); // [1,2,5,4,3,4,1] numbers.concat(4,[5,[6,7]]); // [1,2,4,5,[6,7]],只攤平一層
不傳參數時回傳的是「淺拷貝」:第一維被複製,但如果成員是物件,複製的是參考而非內容。
slice(start, end) 取出 [start, end) 區間組成新陣列,不影響原陣列。負數索引會加上 length,且 start 不可大於 end。
var numbers = [1,2,3,4,5]; numbers.slice(2); // [3,4,5] numbers.slice(2,3); // [3] numbers.slice(2,1); // [] numbers.slice(-3); // [3,4,5] numbers.slice(0,-3); // [1,2] numbers.slice(-2,-1); // [4] numbers.slice(NaN); // [1,2,3,4,5],NaN 視為 0 numbers.slice(0,NaN); // []
它也是把類陣列轉成真陣列的萬用鑰匙:Array.prototype.slice.call(arguments)、Array.prototype.slice.call(document.querySelectorAll('div'))。
splice() 名字和 slice() 很像,功能卻完全不同:它用來刪除、插入與替換,會改動原陣列,並回傳被刪除元素組成的新陣列。
var a = [1,2,3,4,5,6,7,8]; a.splice(4); // a 變 [1,2,3,4],回傳 [5,6,7,8] a = [1,2,3,4,5,6,7,8]; a.splice(0,2); // a 變 [3,4,5,6,7,8],回傳 [1,2] a = [1,2,3,4,5]; a.splice(2,0,'a','b'); // 純插入,回傳 [] a.splice(2,2,[1,2],3); // 同時替換,回傳被換掉的 ['a','b']
第二個參數若為負數、NaN 或 undefined,刪除數量視為 0;若省略,則從起始位置一路刪到尾端。
這兩個方法使用嚴格相等(===)比較,找不到回傳 -1。差別只在搜尋方向。
var arr = [1,2,3,'1','2','3'];
arr.indexOf('2'); // 4
arr.indexOf(3); // 2
arr.indexOf(0); // -1
var a = ['a','b','c','d','e','a','b'];
a.indexOf('a', 1); // 5
a.indexOf('a', -5); // 5,起點換算為 max(0, -5+7)
a.lastIndexOf('b'); // 6
a.lastIndexOf('b', 1); // 1
需要留意的是物件比對的是參考而非內容:[{name:'Nicholas'}].indexOf(person) 即使內容相同也會回傳 -1。若想把所有符合的索引都找出來,可以迴圈呼叫:
function allIndexOf(array, value) {
var result = [], pos = array.indexOf(value);
while (pos > -1) {
result.push(pos);
pos = array.indexOf(value, pos + 1);
}
return result;
}
allIndexOf([1,2,3,3,2,1], 1); // [0,5]
這兩個方法把陣列逐步壓縮成單一值,也就是函數式編程所說的 fold / inject。不影響原陣列。回調函數可接四個參數:累積值、目前值、索引、原陣列;第二個參數是初始值。
var a = [1,2,3,4,5];
a.reduce(function (x, y) { return x + y; }, 0); // 15 求和
a.reduce(function (x, y) { return x * y; }, 1); // 120 求積
a.reduce(function (x, y) { return x > y ? x : y; }); // 5 最大值
// 二維攤平
[[1,2],[3,4],[5,6]].reduce(function (prev, cur) {
return prev.concat(cur);
}); // [1,2,3,4,5,6]
// 找出最長字串
[1,2,3,'ab',4,'bcd',5].reduce(function (prev, cur) {
return cur.length > prev.length ? cur : prev;
}, ''); // 'bcd'
回傳的型別與初始值一致,因此初始值可以是物件:[1,2,3].reduce((prev,cur)=>{prev.sum+=cur; return prev;},{sum:0}) 得到 {sum:6}。空陣列且不給初始值會丟出 TypeError。reduceRight() 邏輯相同,只是從右往左走。
這五個方法都接受「回調函數 + 可選 this 指向」,回調收到「值、索引、陣列」三個參數。
// map:回傳由每次回調結果組成的新陣列
[1,2,3].map(function (item, i) { return item * i; }); // [0,2,6]
[{name:'t1'},{name:'t2'}].map(function (u) { return u.name; }); // ['t1','t2']
// forEach:沒有回傳值,等同 for 迴圈,但無法用 break 中斷
var sum = 0;
[1,2,3,4].forEach(function (n) { sum += n; }); // 10
// filter:只留下回調回傳 true 的項
[1,2,3,4,5].filter(function (n) { return n > 3; }); // [4,5]
[0,1,'a',false].filter(Boolean); // [1,'a']
// some:任一項為 true 即回傳 true
[1,2,3,4,5].some(function (n) { return n % 2 === 0; }); // true
// every:每一項都為 true 才回傳 true
[1,2,3,4,5].every(function (n) { return n < 10; }); // true
幾個實用細節:稀疏陣列(帶有空洞的陣列)在 map 與 forEach 上會跳過不存在的索引;filter 的回傳結果永遠是「稠密」的,因此常被拿來壓縮空洞;第二個參數可以固定 this,在處理多層 this 指向時特別好用。
JavaScript 的陣列方法被刻意設計成「通用」的,除了 toString() 與 toLocaleString(),其餘都能透過 call / apply 作用在類陣列物件上。
會改動原陣列的共有 7 個,務必記牢:push、pop、shift、unshift、reverse、sort、splice。其餘方法都會回傳新值而不動原陣列。寫程式時養成習慣:只要呼叫這七個方法,就回頭確認一下有沒有其他地方還在依賴原始的順序與內容。