第一次在別人的程式碼裡看到「佇列函式」這種寫法時,我完全摸不著頭緒;讀完相關討論才理解,它的存在就是為了保證一群函式嚴格按順序被呼叫,而且還能優雅地處理異步。
若 fn1、fn2、fn3 三個函式要依序執行,最簡單的寫法莫過於:
fn1(); fn2(); fn3();
但實務上,這些函式往往是執行期才一個個被塞進來的,呼叫當下根本不知道總共有幾個、分別是什麼。這時可以先準備一個陣列,註冊時 push 進去,要執行時再依序取出:
var stack = [];
// 執行其他操作,定義 fn1
stack.push(fn1);
// 執行其他操作,定義 fn2、fn3
stack.push(fn2, fn3);
// 調用的時候
stack.forEach(function (fn) { fn(); });
這個寫法有個好處:函式有沒有名字都無所謂,匿名函式丟進去也照樣能跑。
var stack = [];
function fn1() { console.log('第一個調用'); }
stack.push(fn1);
function fn2() { console.log('第二個調用'); }
stack.push(fn2, function () { console.log('第三個調用'); });
stack.forEach(function (fn) { fn(); });
// 依序輸出:第一個調用、第二個調用、第三個調用
先確認你理解下面這段為何輸出 1、3、2:
console.log(1);
setTimeout(function () { console.log(2); }, 0);
console.log(3);
把同樣的異步特性放進佇列,問題立刻浮現:
var stack = [];
function fn1() { console.log('第一個調用'); }
stack.push(fn1);
function fn2() {
setTimeout(function fn2Timeout() {
console.log('第二個調用');
}, 0);
}
stack.push(fn2, function () { console.log('第三個調用'); });
stack.forEach(function (fn) { fn(); });
// 輸出:第一個調用、第三個調用、第二個調用
fn2 確實按序被呼叫了,但它內部 setTimeout 的 fn2Timeout 並不會立刻執行(哪怕延時設為 0)。fn2 呼叫後馬上回傳,fn3 緊接著跑完,才輪到 fn2Timeout 上場。順序因此被打亂。
理想中的樣子大概是:
function fn2() {
setTimeout(function () {
fn2Timeout();
fn3();
}, 0);
}
但這等於把原本的 fn2Timeout 拆掉,換成一個新函式再把兩者塞回去。這種在執行期硬改原函式的技巧有個專有名詞叫 Monkey Patch。用工程師的口頭禪來說:「做肯定是能做」,只是寫起來彆扭,而且很容易把自己繞進去。
退一步想,我們不必堅持等 fn2Timeout 徹底跑完,只要在函式主體的最後一行呼叫下一步即可:
function fn2() {
setTimeout(function fn2Timeout() {
console.log('第二個調用');
next();
}, 0);
}
不過這裡有兩個新問題:定義 fn2 時 fn3 還不存在;而且一旦 fn2 自己負責呼叫 fn3,就不能再靠 stack.forEach 去叫,否則 fn3 會被執行兩次。
結論很清楚——別把 fn3 寫死在 fn2 裡。我們只需要一個 next 函式,由它去 stack 中找出「目前這個函式的下一個」並執行:
var index = 0;
function next() {
var fn = stack[index];
index = index + 1;
// 其實也可以用 shift 把 fn 拿出來
if (typeof fn === 'function') fn();
}
每次呼叫 next,index 就往前推進一格,如此便能依序取出後續函式。實際使用時,佇列裡每個函式都必須在末尾呼叫 next:
var stack = [];
// 定義 index 和 next(同上)
function fn1() {
console.log('第一個調用');
next(); // stack 中每一個函數都必須調用 next
}
stack.push(fn1);
function fn2() {
setTimeout(function fn2Timeout() {
console.log('第二個調用');
next(); // 異步完成後再接力
}, 0);
}
stack.push(fn2, function () {
console.log('第三個調用');
next(); // 最後一個可以不調用,調用了也沒影響
});
next(); // 啟動佇列,最終依序輸出三個訊息
stack.forEach 那一行已經不見了。我們手動呼叫一次 next,它取出 fn1 執行;fn1 內部呼叫 next 取出 fn2;fn2 在 setTimeout 完成後再呼叫 next 取出 fn3,依此類推。切記:每個函式裡都必須呼叫 next,漏掉任何一個,鏈條就在那裡斷掉,後續函式永遠不會被執行。
理解這個模型後,下面這道經典題目就有了解法:
// 實現一個 LazyMan,可以按照以下方式調用:
LazyMan("Hank")
/* 輸出: Hi! This is Hank! */
LazyMan("Hank").sleep(10).eat("dinner")
/* 輸出:
Hi! This is Hank!
// 等待10秒..
Wake up after 10
Eat dinner~
*/
LazyMan("Hank").eat("dinner").eat("supper")
/* 輸出:
Hi This is Hank!
Eat dinner~
Eat supper~
*/
LazyMan("Hank").sleepFirst(5).eat("supper")
/* 等待5秒,輸出:
Wake up after 5
Hi This is Hank!
Eat supper
*/
// 以此類推。
Node.js 裡大名鼎鼎的 connect 框架,正是靠這套思路實作中介軟體佇列,有興趣可以讀讀它的原始碼。
目前的 next 只能放在函式末尾。若挪到中間,原本的問題會捲土重來:
function fn() {
console.log(1);
next();
console.log(2); // next() 若呼叫了異步函數,這行會先執行
}
Redux 與 Koa 則換了另一種實作,讓 next 可以放在函式中間——先執行後續的鏈條,再折回來跑 next 之後的程式碼,手法相當巧妙,值得另外拉一篇來談。