遍歷集合是最日常的操作,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,都會順暢許多。