陣列是 JavaScript 最基礎的資料結構,而迴圈是處理它的主要工具。本文從建立語法開始,逐一示範七個實務上一定會用到的操作,並附上舊瀏覽器的相容寫法。
var arrObject = new Array("val1", "val2"); // 作為物件的陣列
var arrLiteral = ["val1", "val2"]; // 陣列直接量(literal)
對開發者而言兩者沒有差別,直接量上也能呼叫所有 Array 方法。但對 JavaScript 引擎來說,每次求值陣列直接量時都必須重新建立一個新物件,寫在函式或迴圈內部時會產生額外開銷。因此實務上一律優先用直接量 []。
另外要注意 new Array(3) 與 new Array(3, 4) 的行為完全不同:單一數字參數會被當成長度,建立出一個 length 為 3 但沒有元素的稀疏陣列;只有兩個以上參數才會被當成元素。這是 new Array 最惡名的一點。
JavaScript 陣列是零索引的:第一個元素索引為 0,最後一個為「長度減 1」。
<script type="text/javascript">
var animals = new Array("cat", "dog", "whale", "seal");
var animalString = "";
for (var i = 0; i < animals.length - 1; i++) {
animalString += animals[i] + " ";
}
alert(animalString);
</script>
for 迴圈是最直覺的遍歷方式,用 length 決定何時結束。(範例刻意寫成 length - 1 以跳過最後一項,實戰中通常要寫 length。)現代的替代寫法:
animals.forEach(a => console.log(a));
for (const a of animals) { console.log(a); } // 需要 break 時用這個
animals.map(a => a.toUpperCase()); // 需要新陣列時用這個
<script type="text/javascript">
var queue = new Array();
// 進入佇列
queue.push("first");
queue.push("second");
queue.push("third");
// 取出兩個
alert(queue.shift());
alert(queue.shift());
alert(queue);
</script>
push 在陣列尾端新增元素,每次呼叫 length 自增。shift 從前端取出並移除元素,回傳該值,length 自減。兩者搭配就是標準的佇列:先進去的先出來。
<script type="text/javascript">
var stack = new Array();
stack.push("first");
stack.push("second");
stack.push("third");
alert(stack.pop()); // third
alert(stack.pop()); // second
alert(stack); // first
</script>
pop 從尾端取出並移除元素,回傳該值。堆疊的規則是「最後放上去的最先拿下來」,push + pop 就是它的標準實作。順帶一提,push 與 pop 的效能比 shift 好得多,因為前者不需要搬移整個陣列的索引;若大量需要 FIFO,用 push 搭配一個 head 指標會比 shift 有效率。
<script type="text/javascript">
var animals = new Array("dog", "cat", "seal", "elephant", "lion");
alert(animals.indexOf("elephant")); // 3
alert(animals.indexOf("seal", 2)); // 2,從索引 2 開始找
</script>
indexOf 與 lastIndexOf 在 ES5 中正式標準化(雖然更早就有瀏覽器支援)。兩者都接受搜尋值並逐項比較,找到就回傳索引,找不到回傳 -1。差別是 indexOf 回傳第一個符合的、lastIndexOf 回傳最後一個。
相容性寫法:
<script type="text/javascript">
if (!Array.prototype.indexOf) {
Array.prototype.indexOf = function (elt/*, from*/) {
var len = this.length >>> 0;
var from = Number(arguments[1]) || 0;
from = (from < 0) ? Math.ceil(from) : Math.floor(from);
if (from < 0) { from += len; }
for (; from < len; from++) {
if (from in this && this[from] === elt) { return from; }
}
return -1;
}
}
</script>
<script type="text/javascript">
function replaceElement(element, index, array) {
if (element == "ab") { array[index] = "**"; }
}
var charSets = new Array("ab", "bb", "cd", "ab", "cc", "ab", "dd", "ab");
charSets.forEach(replaceElement)
alert(charSets); // **,bb,cd,**,cc,**,dd,**
</script>
forEach 接受一個回呼函式,該函式收到三個參數:元素值、索引、陣列本身。它沒有回傳值,只用來做副作用。相容寫法:
<script type="text/javascript">
if (!Array.prototype.forEach) {
Array.prototype.forEach = function (fun/*, thisp*/) {
var len = this.length >>> 0;
if (typeof fun != "function") { throw new TypeError(); }
var thisp = arguments[1];
for (var i = 0; i < len; i++) {
if (i in this) { fun.call(thisp, this[i], i, this); }
}
};
}
</script>
<script type="text/javascript">
function removeChars(element, index, array) {
return element !== "**";
}
var charSets = new Array("**", "bb", "cd", "**", "cc", "**", "dd", "**");
var newArray = charSets.filter(removeChars);
alert(newArray); // bb,cd,cc,dd
</script>
filter 把回呼函式套用到每個元素,回呼回傳 true 的元素會被收進新陣列,回傳 false 的則被排除。原陣列不受影響,這是它與 forEach 最關鍵的差別。相容寫法:
<script type="text/javascript">
if (!Array.prototype.filter) {
Array.prototype.filter = function (fun/*, thisp*/) {
var len = this.length >>> 0;
if (typeof fun != "function") { throw new TypeError(); }
var res = new Array();
var thisp = arguments[1];
for (var i = 0; i < len; i++) {
if (i in this) {
var val = this[i]; // 先存起來,避免 fun 修改了 this
if (fun.call(thisp, val, i, this)) { res.push(val); }
}
}
return res;
};
}
</script>
<script type="text/javascript">
function testValue(element, index, array) {
var re = /^[a-zA-Z]+$/;
return re.test(element);
}
var elemSet = new Array("**", 123, "abc", "-", "AAA");
alert(elemSet.every(testValue)); // false,只要有不符合就回傳 false
</script>
兩者的差異在於「何時提早結束」:
every:只要有一個元素讓回呼回傳 false,就立即停止並回傳 false;全部通過才回傳 true。some:只要有一個元素讓回呼回傳 true,就立即停止並回傳 true;全部都沒通過才回傳 false。相容寫法:
<script type="text/javascript">
if (!Array.prototype.some) {
Array.prototype.some = function (fun/*, thisp*/) {
var i = 0, len = this.length >>> 0;
if (typeof fun != "function") { throw new TypeError(); }
var thisp = arguments[1];
for (; i < len; i++) {
if (i in this && fun.call(thisp, this[i], i, this)) { return true }
}
return false;
};
}
if (!Array.prototype.every) {
Array.prototype.every = function (fun/*, thisp*/) {
var len = this.length >>> 0;
if (typeof fun != "function") { throw new TypeError(); }
var thisp = arguments[1];
for (var i = 0; i < len; i++) {
if (i in this && !fun.call(thisp, this[i], i, this)) { return false }
}
return true;
};
}
</script>
這些 ES5 方法在今天的瀏覽器與 Node.js 中全部原生支援,polyfill 已無必要(除非你要支援 IE8)。但理解它們的實作原理仍有價值:特別是「回呼函式會收到元素、索引、陣列三個參數」這個統一設計,以及 filter/map/forEach 的差異——map 與 filter 回傳新陣列,forEach 不回傳,選錯會導致整段程式邏輯出錯。
另外提醒一個共同陷阱:這些方法都跳過稀疏陣列中的空洞。若你的陣列是 new Array(5) 這種有長度沒元素的狀態,回呼根本不會被執行。