DIV CSS 佈局教程網

JavaScript 陣列與迴圈詳解:從建立到七種常見操作
編輯:JavaScript綜合知識     

陣列是 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」。

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());                   // 需要新陣列時用這個

2. 先進先出(FIFO):用 push 與 shift 做佇列

<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 自減。兩者搭配就是標準的佇列:先進去的先出來。

3. 後進先出(LIFO):用 push 與 pop 做堆疊

<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 有效率。

4. 在陣列中搜尋

<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>

5. 對每個元素套用函式:forEach

<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>

6. 過濾出新陣列:filter

<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>

7. 驗證全部或任一元素:every 與 some

<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) 這種有長度沒元素的狀態,回呼根本不會被執行。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved