雖然 Promise 早已有自己的規範,各家實作庫在細節上仍互有差異,部分 API 的語意甚至完全不同。但核心是一致的:那就是 then 方法。術語中所說的 promise,指的就是一個擁有 then 方法、且該方法能觸發特定行為的物件或函數。
因此核心說明不會涉及任何具體實作——它的意思是:這就是最終要達成的樣子,請照著這個結果反推程式碼該怎麼寫。
先回想 Promise 究竟解決了什麼問題:回呼。假設 doMission1() 代表第一件事,我們想在它完成後接著做 doMission2()。傳統回呼模式是這樣的:
doMission1(doMission2);
它的語意是:「你要這麼做的話,就把 doMission2() 交給我,我結束後幫你呼叫。」而 Promise 模式則把主從關係翻轉了過來——你對 doMission1() 說:「控制權得在我手上。你先改一下,回傳一個特別的東西給我,由我來安排下一件事。」那個特別的東西就是 Promise:
doMission1().then(doMission2);
於是各個環節的流程關係得以集中在主幹上,而不再散落於各個事件函數內部。
要如何完成這個轉換?從最簡單的情況開始。假設原本寫成:
function doMission1(callback) {
var value = 1;
callback(value);
}
那麼改寫為:
function doMission1() {
return {
then: function(callback) {
var value = 1;
callback(value);
}
};
}
轉換就完成了。這裡雖還不是實用的程式,卻已觸及 Promise 最關鍵的要點:把返回值換成一個帶有 then 方法的物件。
design/q0.js 是 Q 初步成型的第一步,它建立了一個名為 defer 的工具函數來產生 Promise:
var defer = function () {
var pending = [], value;
return {
resolve: function (_value) {
value = _value;
for (var i = 0, ii = pending.length; i < ii; i++) {
var callback = pending[i];
callback(value);
}
pending = undefined;
},
then: function (callback) {
if (pending) {
pending.push(callback);
} else {
callback(value);
}
}
};
};
呼叫 defer() 會得到一個同時擁有 resolve 與 then 的物件(與 jQuery 的 Deferred 頗為神似)。then 會看 pending 的狀態:若仍在等待中就把回呼存起來,否則立刻執行;resolve 則肯定這個 Promise,更新值並跑完所有已存的回呼。使用方式如下:
var oneOneSecondLater = function () {
var result = defer();
setTimeout(function () {
result.resolve(1);
}, 1000);
return result;
};
oneOneSecondLater().then(callback);
這裡 oneOneSecondLater() 內部含有非同步內容(setTimeout),但它立刻回傳一個 defer() 產生的物件,並把 resolve 安排在非同步作業結束的位置呼叫,順便帶上結果。
此時有個明顯缺陷:resolve 可能被呼叫多次。因此 design/q1.js 加上了狀態判斷,確保 resolve 只有一次生效:
resolve: function (_value) {
if (pending) {
value = _value;
for (var i = 0, ii = pending.length; i < ii; i++) {
var callback = pending[i];
callback(value);
}
pending = undefined;
} else {
throw new Error("A promise can only be resolved once.");
}
}
對於第二次及後續的呼叫,拋出錯誤或直接忽略都可以。
前面的 defer 產物同時握有 then 與 resolve。但依定義,promise 關心的只有 then;觸發狀態變化的 resolve 是另一回事。於是 Q 把兩者拆開,各自獨立使用,讓職責與權限涇渭分明,邏輯更清晰也更容易調整。design/q3.js 如下:
var isPromise = function (value) {
return value && typeof value.then === "function";
};
var defer = function () {
var pending = [], value;
return {
resolve: function (_value) {
if (pending) {
value = _value;
for (var i = 0, ii = pending.length; i < ii; i++) {
var callback = pending[i];
callback(value);
}
pending = undefined;
}
},
promise: {
then: function (callback) {
if (pending) {
pending.push(callback);
} else {
callback(value);
}
}
}
};
};
與 q1 相比差異很小:不再拋錯(第二次以後的 resolve 直接忽略),並把 then 搬進一個名為 promise 的屬性裡。於 defer() 的結果擁有 resolve,以及一個指向「只有 then 的 promise」的 promise 屬性。分離就此完成。
而 isPromise() 透過是否有 then 方法來判斷(典型的鴨子式判型),這在正確處理分離後的 promise 時會派上用場。
接下來是相當關鍵的一步。到 q3 為止的 promise 都無法串接,但我們熟悉的寫法應該是:
promise.then(step1).then(step2);
也就是說,promise 必須能產生出新的 promise,並沿用舊 promise 的值。要達成這點,需要三件事:
then 方法必須回傳 promise。then 的回呼執行結果來設定。then 的回呼,必須回傳 promise 或一般值。design/q4.js 為此新增了工具函數 ref:
var ref = function (value) {
if (value && typeof value.then === "function") return value;
return {
then: function (callback) {
return ref(callback(value));
}
};
};
它負責把任意值包裝成 promise:若已是 promise 則原樣返回,否則包一層。注意其中的遞迴,它確保包裝後的 promise 依然可以串接。用法如下:
ref("step1").then(function(value) {
console.log(value); // "step1"
return 15;
}).then(function(value) {
console.log(value); // 15
});
接著把 ref 整合進 defer,就能得到可串接的版本:
var defer = function () {
var pending = [], value;
return {
resolve: function (_value) {
if (pending) {
value = ref(_value); // 用 promise 包住值
for (var i = 0, ii = pending.length; i < ii; i++) {
var callback = pending[i];
value.then(callback); // 改以 then 呼叫
}
pending = undefined;
}
},
promise: {
then: function (_callback) {
var result = defer(); // 包住回呼,才能攔下它的回傳值,
// 用以 resolve then 所回傳的 promise
var callback = function (value) {
result.resolve(_callback(value));
};
if (pending) {
pending.push(callback);
} else {
value.then(callback);
}
return result.promise;
}
}
};
};
原本 callback(value) 的呼叫形式都改成了 value.then(callback),效果不變,只是因為 value 已被包裝成 promise。then 的改動較大:它先建立一個新的 defer,並在末尾回傳它的 promise;同時把新 defer 的 resolve 嵌進回呼裡。如此一來,舊 promise 的 resolve 跑完後,新 promise 的 resolve 也會接著跑,事件便能像管線一樣沿著 then 串接的方向一層層傳遞下去。
then 應該接受兩個參數,分別處理肯定與否定狀態(onFulfilled 與 onRejected),且兩者皆為可選。design/q6.js 加入工具函數 reject 來支撐否定狀態:
var reject = function (reason) {
return {
then: function (callback, errback) {
return ref(errback(reason));
}
};
};
它與 ref 的主要差別在於:其 then 只會執行第二個參數 errback。q6.js 其餘部分如下:
var defer = function () {
var pending = [], value;
return {
resolve: function (_value) {
if (pending) {
value = ref(_value);
for (var i = 0, ii = pending.length; i < ii; i++) {
value.then.apply(value, pending[i]);
}
pending = undefined;
}
},
promise: {
then: function (_callback, _errback) {
var result = defer();
// 提供預設的肯定與否定回呼
_callback = _callback || function (value) {
return value; // 預設直接往下一層傳遞肯定結果
};
_errback = _errback || function (reason) {
return reject(reason); // 預設直接往下一層傳遞否定結果
};
var callback = function (value) {
result.resolve(_callback(value));
};
var errback = function (reason) {
result.resolve(_errback(reason));
};
if (pending) {
pending.push([callback, errback]);
} else {
value.then(callback, errback);
}
return result.promise;
}
}
};
};
主要改動是 pending 從只存單一回呼,改為同時保存肯定與否定兩種回呼;並在 then 中定義預設回呼,以滿足「兩個可選參數」的要求。
你可能注意到 defer 仍只有 resolve,沒有類似 jQuery 的 reject。那錯誤處理該如何觸發?看這個例子:
var defer1 = defer(), promise1 = defer1.promise;
promise1.then(function(value) {
console.log("1: value = ", value);
return reject("error happens");
}).then(function(value) {
console.log("2: value = ", value);
}).then(null, function(reason) {
console.log("3: reason = ", reason);
});
defer1.resolve(10);
// 1: value = 10
// 3: reason = error happens
可見每個傳給 then 的回傳值都至關重要,它決定下一次 then 的走向;而回傳 reject 產生的物件,就會切入錯誤處理路徑。
最後來到 design/q7.js。直到 q6 為止還存在一個問題:then 的執行時機可能同步也可能非同步,取決於回呼內容(直接回傳值就是同步,回傳另一個 promise 則可能是非同步)。這種不確定性會埋下地雷。因此 Q 的最後一步,是確保所有 then 一律非同步。它定義了工具函數 enqueue:
var enqueue = function (callback) {
//process.nextTick(callback); // NodeJS
setTimeout(callback, 1); // 瀏覽器端的樸素解
};
顧名思義,它會把任意函數延後到下一輪事件佇列執行。q7.js 的其餘修改(僅列變動處)如下:
var ref = function (value) {
// ...
return {
then: function (callback) {
var result = defer();
enqueue(function () {
result.resolve(callback(value));
});
return result.promise;
}
};
};
var reject = function (reason) {
return {
then: function (callback, errback) {
var result = defer();
enqueue(function () {
result.resolve(errback(reason));
});
return result.promise;
}
};
};
var defer = function () {
var pending = [], value;
return {
resolve: function (_value) {
// ...
enqueue(function () {
value.then.apply(value, pending[i]);
});
// ...
},
promise: {
then: function (_callback, _errback) {
// ...
enqueue(function () {
value.then(callback, errback);
});
// ...
}
}
};
};
也就是把原本所有 value.then 的呼叫都改為非同步。至此,Q 從 q0 到 q7 的 Promise 設計推演全部走完。
即使寫到這個篇幅,談到的也只停留在基礎 Promise。多數 Promise 庫還提供 all()、spread() 等 API 來因應更多情境;但讀到這裡,你已經掌握了實作 Promise 的核心理念。
Promise 在我看來是相當精巧的設計,我花了不少時間才大致理解。Q 作為一個典型的 Promise 庫,思路走得非常明確。再複雜的庫也都是從幾個基本要點長出來的——若我們自己要動手做類似的事,也該保持這樣的心態,一點一點往前推進。