異步隊列是一個鏈式物件,用來強化回呼函數的管理與呼叫,專門處理異步任務。它有兩種狀態:初始化(unresolved)、成功(resolved)、失敗(rejected)。要執行哪些回呼,取決於狀態;而狀態一旦變成成功或失敗就不再改變。回呼的綁定則是同步或異步皆可,任何時刻都能掛上去。
對外暴露的方法清單刻意排除了 resolve/reject/cancel:
promiseMethods = "done fail isResolved isRejected promise then always pipe".split(" ");
內部用閉包維護四個狀態變數:callbacks(回呼陣列)、fired(已存上下文與參數,同時作為「已完成」的標記)、firing(正在執行,避免重入)、cancelled(是否已取消)。
done: function () {
if (!cancelled) {
var args = arguments, i, length, elem, type, _fired;
if (fired) { _fired = fired; fired = 0; } // 備份上下文與參數
for (i = 0, length = args.length; i < length; i++) {
elem = args[i];
type = jQuery.type(elem);
if (type === "array") {
deferred.done.apply(deferred, elem); // 陣列則遞迴
} else if (type === "function") {
callbacks.push(elem);
}
}
if (_fired) { deferred.resolveWith(_fired[0], _fired[1]); } // 已執行過就立刻補跑
}
return this;
}
resolveWith: function (context, args) {
if (!cancelled && !fired && !firing) {
args = args || []; // 避免 null 造成 ReferenceError 的常見技巧
firing = 1;
try {
while (callbacks[0]) { // 遍歷動態陣列的巧妙寫法
callbacks.shift().apply(context, args);
}
} finally {
fired = [context, args];
firing = 0;
}
}
return this;
}
isResolved: function () { return !!(firing || fired); }
cancel: function () { cancelled = 1; callbacks = []; return this; }
注意 isResolved() 在「執行中」與「已執行完」兩種狀態下都回傳 true,所以把 fired 翻譯成「已解決」並不精準。
完整的 Deferred 有兩個回呼陣列。為了程式碼複用,內部先建立兩個 _Deferred,再把它們接起來:
Deferred: function (func) {
var deferred = jQuery._Deferred(),
failDeferred = jQuery._Deferred(),
promise;
jQuery.extend(deferred, {
then: function (doneCallbacks, failCallbacks) {
deferred.done(doneCallbacks).fail(failCallbacks);
return this;
},
always: function () {
return deferred.done.apply(deferred, arguments).fail.apply(this, arguments);
},
fail: failDeferred.done,
rejectWith: failDeferred.resolveWith,
reject: failDeferred.resolve,
isRejected: failDeferred.isResolved,
pipe: function (fnDone, fnFail) {
return jQuery.Deferred(function (newDefer) {
jQuery.each({
done: [fnDone, "resolve"],
fail: [fnFail, "reject"]
}, function (handler, data) {
var fn = data[0], action = data[1], returned;
if (jQuery.isFunction(fn)) {
deferred[handler](function () {
returned = fn.apply(this, arguments);
if (returned && jQuery.isFunction(returned.promise)) {
returned.promise().then(newDefer.resolve, newDefer.reject);
} else {
newDefer[action](returned);
}
});
} else {
deferred[handler](newDefer[action]);
}
});
}).promise();
},
promise: function (obj) {
if (obj == null) {
if (promise) { return promise; }
promise = obj = {};
}
var i = promiseMethods.length;
while (i--) { obj[promiseMethods[i]] = deferred[promiseMethods[i]]; }
return obj;
}
});
// 一個隊列跑完就取消另一個,確保狀態不會交叉
deferred.done(failDeferred.cancel).fail(deferred.cancel);
delete deferred.cancel; // 不對外公開 cancel
if (func) { func.call(deferred, deferred); }
return deferred;
}
promise() 的意義是「唯讀視圖」:只給出 done/fail/then 等查詢與綁定方法,抽掉 resolve 與 reject。這正是 $.ajax 從 1.5 版起不再回傳 XMLHttpRequest,而是回傳一個包含 promise 介面的物件的原因——把觸發權保留在 ajax 內部,外部無法提早放行回呼。
when: function (firstParam) {
var args = arguments, i = 0, length = args.length, count = length,
deferred = length <= 1 && firstParam && jQuery.isFunction(firstParam.promise) ?
firstParam : jQuery.Deferred();
function resolveFunc(i) {
return function (value) {
args[i] = arguments.length > 1 ? sliceDeferred.call(arguments, 0) : value;
if (!(--count)) {
deferred.resolveWith(deferred, sliceDeferred.call(args, 0));
}
};
}
// 多參數時逐一掛 then;非 Deferred 的參數直接遞減計數器
// 全部完成(count 歸零)才觸發 resolve
return deferred.promise();
}
設計要點:傳入單一 Deferred 時直接復用它,多參數時才新建一個,並用計數器等待所有非異步參數到齊。
閉包計數:
function a() {
var guid = 1;
return function () { return guid++; };
}
var defer = a();
defer(); // 1
defer(); // 2
防 null:args = args || [];
遍歷可變陣列:while (callbacks[0]) { callbacks.shift().apply(context, args); }
try/catch/finally:finally 區塊中的程式碼在其它流程之後無條件執行,拿來重置狀態旗標最合適。
鏈式物件:done、resolveWith、resolve、cancel 全部回傳 this,呼叫鏈才不會中斷。
把 Deferred 想成「把回呼管理從散落各處收攏到一個物件上」,你就能理解它為何能讓複雜的異步流程變得可讀——這也是後來 Promise/async-await 標準的思想源頭。