DIV CSS 佈局教程網

JavaScript 迭代器與生成器深入解析:從 for 循環到無限序列
編輯:JavaScript綜合知識     

遍歷集合是最日常的操作,JavaScript 提供了從 for、forEach 到 map()、filter() 的各種手段。而迭代器與生成器則帶來了一套更底層、更可控的遍歷機制,讓自定義遍歷邏輯變得優雅。

一、迭代器是什麼

迭代器是一個「記得自己走到哪裡」的對象。它提供 next() 方法返回序列中的下一個元素,當所有元素耗盡時拋出 StopIteration 異常。

var lang = { name: 'JavaScript', birthYear: 1995 };
var it = Iterator(lang);

var pair = it.next();   // ["name", "JavaScript"]
pair = it.next();       // ["birthday", 1995]
pair = it.next();       // 拋出 StopIteration

顯式調用顯然麻煩,所以可以直接用 for...in 讓循環自動處理終止:

var it = Iterator(lang);
for (var pair in it)
    print(pair);   // 每次輸出一個 [key, value]

如果只想要鍵,往 Iterator() 傳第二個參數 true 即可:

var it = Iterator(lang, true);
for (var key in it)
    print(key);

用 Iterator() 還有一個附加好處:掛在 Object.prototype 上的自定義屬性不會被遍歷出來,這在多人協作的老項目裡尤為可貴。

它同樣適用於數組,此時產出的是 [index, value] 鍵值對:

var langs = ['JavaScript', 'Python', 'Haskell'];
var it = Iterator(langs);
for (var pair in it)
    print(pair);   // [0, 'JavaScript']、[1, 'Python']……

// 傳 true 只取索引
var it2 = Iterator(langs, true);
for (var i in it2) print(i);   // 0、1、2

// 配合 let 做解構賦值,一次拿到索引和值
for (let [i, lang] in it)
    print(i + ': ' + lang);

二、自定義迭代器

有些集合天生需要特定的遍歷方式:樹要用深度優先或廣度優先、數據庫結果集要逐行返回、無限數學序列不能一次性建構。這時就需要自己定義迭代邏輯。

以一個區間對象為例:

function Range(low, high){
    this.low = low;
    this.high = high;
}

function RangeIterator(range){
    this.range = range;
    this.current = this.range.low;
}
RangeIterator.prototype.next = function(){
    if (this.current > this.range.high)
        throw StopIteration;
    else
        return this.current++;
};

// 關鍵:通過 __iterator__ 把兩者關聯起來
Range.prototype.__iterator__ = function(){
    return new RangeIterator(this);
};

var range = new Range(3, 5);
for (var i in range)
    print(i);   // 3、4、5

可以看到,自定義迭代器需要顯式維護 current 這個內部狀態,代碼量不小,也相對容易出錯。這正是生成器要解決的痛點。

三、生成器:更輕便的迭代器工廠

只要函數體裡出現了一個或多個 yield 表達式,它就是生成器。生成器的好處是自動維護狀態——不需要你手寫 current、不需要手寫狀態判斷。

function simpleGenerator(){
    yield "first";
    yield "second";
    yield "third";
    for (var i = 0; i < 3; i++)
        yield i;
}

var g = simpleGenerator();
print(g.next());   // "first"
print(g.next());   // "second"
print(g.next());   // 0、1、2……
print(g.next());   // 拋出 StopIteration

調用生成器函數時函數體並不會立即執行,而是返回一個 generator-iterator 對象。每次調用 next(),執行才推進到下一個 yield 並交出結果。用生成器重寫上面的 Range,代碼量瞬間縮減:

Range.prototype.__iterator__ = function(){
    for (var i = this.low; i <= this.high; i++)
        yield i;
};

更妙的是,生成器可以永不終止,天然適合表達無限序列:

function fibonacci(){
    var fn1 = 1, fn2 = 1;
    while (1) {
        var current = fn2;
        fn2 = fn1;
        fn1 = fn1 + current;
        yield current;
    }
}

var sequence = fibonacci();
print(sequence.next());   // 1、1、2、3、5、8、13……

生成器也能接參數,並可用 return 提前終止:

function fibonacci(limit){
    var fn1 = 1, fn2 = 1;
    while(1){
        var current = fn2;
        fn2 = fn1;
        fn1 = fn1 + current;
        if (limit && current > limit)
            return;
        yield current;
    }
}

四、生成器的高級能力

send():雙向通信。除了 next(),generator-iterator 還有 send() 方法,傳入的值會成為上一個 yield 表達式的求值結果,讓外部能反向影響生成器內部狀態:

var reset = yield current;
if (reset) {
    fn1 = 1;
    fn2 = 1;
}

// 使用前提是至少先調用過一次 next()
print(sequence.send(true));   // 序列重置,重新從 1 開始

注意 send(undefined) 與 next() 完全等價;但在啟動一個新生成器時,傳入 undefined 以外的值會拋出 TypeError。

throw():主動拋異常。可以強制生成器拋出一個異常,該異常從當前上下文拋出並暫停生成器,效果類似把 yield 換成 throw value。若處理過程中沒有遇到 yield,異常會一直傳遞到調用方。

close():強制結束。結束生成器會觸發三件事:所有有效的 finally 子句執行;若 finally 拋出 StopIteration 以外的異常則傳遞給調用者;生成器終止。

五、生成器表達式與惰性求值

數組推導式有個明顯缺點:它會立即在內存中構造整個數組。輸入很小時無所謂,但面對大數組甚至無限序列就會出問題。

// 數組推導式:立即生成完整數組
var doubles = [i * 2 for (i in it)];

// 生成器表達式:把方括號換成圓括號,按需計算
var it2 = (i * 2 for (i in it));
print(it2.next());   // 只算第一個偶數
print(it2.next());   // 只算第二個偶數

當生成器表達式作為函數參數時,最外層圓括號可以省略:

var result = doSomething(i * 2 for (i in it));

六、今天的標準寫法

需要說明的是,本文描述的是早期 JavaScript 1.7 提案中的語法,其中 Iterator()、__iterator__、StopIteration 以及無括號的 yield 寫法在現代引擎中已被移除或替換。今天的標準寫法是:

// 自定義迭代器:實現 Symbol.iterator 協議
const range = {
    from: 3, to: 5,
    [Symbol.iterator]() {
        let current = this.from;
        const last = this.to;
        return {
            next() {
                return current <= last
                    ? { value: current++, done: false }
                    : { value: undefined, done: true };
            }
        };
    }
};

// 生成器函數:function* 加 yield
function* fibonacci(limit = Infinity) {
    let [a, b] = [0, 1];
    while (a <= limit) {
        yield a;
        [a, b] = [b, a + b];
    }
}

for (const n of fibonacci(100)) console.log(n);
const [x, y, z] = fibonacci(10);   // 0, 1, 1

核心思想並沒有變:迭代器把「遍歷」從集合中剝離出來變成獨立對象,生成器則用函數控制流自動管理這個對象的狀態。理解這層抽象,再去讀 async/await(本質上是異步生成器)和 RxJS 的 Observable,都會順暢許多。

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