事情是這樣開始的:我要在瀏覽器端寫一段腳本,把將近兩百筆使用者資料批次送進公司系統。系統的資料表不是行列式結構,沒辦法直接組 SQL 批次寫入,手工輸入大概要耗掉一整天。於是選擇用 Greasemonkey 寫使用者腳本、以 Firefox 為執行環境,讓程式去模擬點擊與輸入。
腳本要做的事,邏輯上就是一個迴圈:
最直覺的實作看起來是這樣:
for (var i = 0; i < dataArray.length; ++i) {
clickButtonForInputWindow();
waitInputWindow();
enterInputData(dataArray[i]);
clickSubmitButton();
waitInputWindowClose();
}
貼進瀏覽器主控台跑跑看,結果是整頁白屏,幾分鐘後跳出「沒有回應」並被強制終止。原因很單純:JavaScript 執行期間,瀏覽器主執行緒被完全佔用,CPU 忙著跑你的迴圈,根本沒有時間去處理畫面繪製與使用者輸入。而且那些 waitXxx() 也根本沒有真的在等——它們只是空轉。
把迴圈改成計時器派工:
for (var i = 0; i < dataArray.length; ++i) {
setTimeout(clickButtonForInputWindow);
// …
setTimeout(waitInputWindowClose);
}
setTimeout 與 setInterval 是瀏覽器唯一提供的非同步排程機制。它的本質是「把函式丟進佇列,交還控制權給瀏覽器,之後再回來執行」。控制權一交還,畫面就能刷新、使用者操作也會被處理,白屏問題自然消失。
老牌方案是 jQuery 作者的 $await(Wind.js)那類函式庫,寫起來優雅。但對「單一檔案的 userscript」來說,多下一個外部 js 還不如直接複製幾十行相容程式碼來得爽快。所以決定自己寫一個免編譯、好 Copy & Paste 的迷你非同步庫。
同步程式只有三種結構:順序、判斷、迴圈。轉成非同步之後,難點也正好三個:
function asyncWhile(fn, interval) {
if (fn == null || (typeof(fn) != "string" && typeof(fn) != "function"))
return;
var wrapper = function () {
// fn 回傳非 false 就繼續排下一輪
if ((typeof(fn) == "function" ? fn() : eval(fn)) !== false) {
setTimeout(wrapper, interval == null ? 1 : interval);
}
};
wrapper();
}
核心只有一句:回傳值不是 false 就繼續排下一個 setTimeout。用「回傳值」當控制訊號,是這個設計最聰明的地方。
於是「等待並執行」也能用它表達——這其實就是一個非同步迴圈:
asyncWhile(function () {
if (xxxCondition == false) {
return true; // 繼續循環
} else {
doSomeThing();
return false; // 不需要再循環了
}
});
單純「等一下再執行一次」的情境,一個 setTimeout 就夠了,不必動用 asyncWhile。
我的實際需求是三步,但第二步是一個跑一百多次的非同步迴圈。也就是說,表面三步,實際上是一百零三次必須嚴格順序執行的非同步操作。
解法是引入執行鏈(Execution Chain)的概念:
實作方式是替每條鏈維護一個「執行令牌」與當前索引,只有令牌序號與函式序號相符時才允許執行:
function asyncSeq(funcArray, chainName, abortWhenError) {
if (typeof(funcArray) == "function")
return asyncSeq([funcArray], chainName, abortWhenError);
if (funcArray == null || funcArray.length == 0) return;
if (chainName == null) chainName = "__default_seq_chain__";
var tInfos = asyncSeq.chainInfos = asyncSeq.chainInfos || {};
var tInfo = tInfos[chainName] =
tInfos[chainName] || { count: 0, currentIndex: -1, abort: false };
for (var i = 0; i < funcArray.length; ++i) {
asyncWhile(function (item, tIndex) {
return function () {
if (tInfo.abort) return false;
if (tInfo.currentIndex < tIndex) {
return true; // 還沒輪到,再等一個 tick
} else if (tInfo.currentIndex == tIndex) {
try {
item();
} catch (e) {
if (abortWhenError) tInfo.abort = true;
} finally {
tInfo.currentIndex++;
}
} else {
if (abortWhenError) tInfo.abort = true;
}
return false;
};
}(funcArray[i], tInfo.count++));
}
// 延遲啟動,方便除錯
setTimeout(function () {
if (tInfo.count > 0 && tInfo.currentIndex == -1) tInfo.currentIndex = 0;
}, 20);
}
值得欣賞的兩個設計:
(function(item, tIndex){ return function(){…} }(funcArray[i], tInfo.count++))。不這樣做,迴圈變數會被所有閉包共用,全部拿到最後一個值。
function testAsync() {
asyncSeq([
function () { println("aSyncSeq -0 "); },
function () { println("aSyncSeq -1 "); },
function () { println("aSyncSeq -2 "); }
// … 可任意擴充
]);
// 不同 chainName,與上面那條同時進行、互不干擾
asyncSeq([
function () { println("aSyncSeq test-chain -a0 "); },
function () { println("aSyncSeq test-chain -a1 "); }
], "test-chain");
}
var textArea = null;
function println(text) {
if (textArea == null) {
textArea = document.getElementById("text");
textArea.value = "";
}
textArea.value = textArea.value + text + "\r\n";
}
執行結果會看到兩條鏈的輸出交錯出現,但每條鏈內部順序不亂——這就是執行令牌在起作用。
這份程式碼的價值不在它有多先進,而在它把非同步的三個難題(迴圈、判斷、順序)用最少的程式碼講清楚了。不過放到現在,你幾乎不會需要自己寫它,因為語言本身已經內建了答案:
// 非同步迴圈 → 就是 await 加 while
while (condition) {
await doSomething();
}
// 非同步順序 → await 天然保證
await step1();
await step2();
await step3();
// 並行 → Promise.all
await Promise.all(tasks.map(t => t.run()));
async/await 出現之後,「用同步的寫法表達非同步的流程」這件事已經由編譯器(本質上是 generator 加狀態機)代劳,而它在背後做的,正是本文用 currentIndex 令牌手工實作的那套狀態追蹤。
最後補一句實用提醒:批次操作幾百筆資料時,除了避免阻塞主執行緒,也要考慮對伺服器的壓力。每個請求之間加一點隨機延遲、控制併發數量(例如一次只跑 2~3 個),比一路狂送要安全得多,也不容易被後端當成攻擊流量擋掉。