Promise 主要用來解決兩件事:回呼函式嵌套過深,以及本該併行卻被迫序列化的流程。一個 Promise 代表某個非同步操作的最終結果,與它互動的方式是透過 then() 註冊回呼,接收最終結果。相關規範有 Promises/A 與 Promises/A+ 兩版。
與其背誦定義,不如自己刻一個出來。以下依「Promise 類別 → Deferred 類別 → 工具函式 → 實際使用」的順序拆解。
需要三個屬性:等待中的回呼佇列 queue(初始化為空陣列)、結果值 value(初始化為 null)、狀態 status(初始化為 'pending')。再配上 getQueue、getStatus、setStatus 三個存取方法。
setStatus() 是整個狀態機的核心:它只接受 fulfilled 與 rejected,設定完成後清空佇列,並用 Object.freeze 凍結物件——因為狀態一旦定案就不可逆。
then(onFulfilled, onRejected) 則把兩個回呼打包成 handler,附上一個 Deferred 作為回傳憑證。若目前仍在 pending,就把 handler 推進佇列;若已定案,立刻交給工具函式處理。最後回傳 handler.deferred.promise,這正是鏈式呼叫得以成立的原因。
<script>
Promise = function() {
this.queue = [];
this.value = null;
this.status = 'pending'; // pending | fulfilled | rejected
};
Promise.prototype.getQueue = function() {
return this.queue;
};
Promise.prototype.getStatus = function() {
return this.status;
};
Promise.prototype.setStatus = function(s, value) {
if (s === 'fulfilled' || s === 'rejected') {
this.status = s;
this.value = value || null;
this.queue = [];
var freezeObject = Object.freeze || function(){};
freezeObject(this); // promise 狀態不可逆
} else {
throw new Error({ message: "doesn't support status: " + s });
}
};
Promise.prototype.isFulfilled = function() {
return this.status === 'fulfilled';
};
Promise.prototype.isRejected = function() {
return this.status === 'rejected';
};
Promise.prototype.isPending = function() {
return this.status === 'pending';
};
Promise.prototype.then = function(onFulfilled, onRejected) {
var handler = {
'fulfilled': onFulfilled,
'rejected': onRejected
};
handler.deferred = new Deferred();
if (!this.isPending()) {
// 允許先改變狀態後再添加回呼
utils.procedure(this.status, handler, this.value);
} else {
this.queue.push(handler);
}
return handler.deferred.promise; // then 必須回傳 promise
};
I notice the last article block got cut off and malformed. Let me output the remaining articles properly, continuing from 6136.
6136
從零打造一個 Promise:把 then 鏈的內部機制寫出來
Promise 主要用來解決兩件事:回呼函式嵌套過深,以及本該併行卻被迫序列化的流程。一個 Promise 代表某個非同步操作的最終結果,與它互動的方式是透過 then() 註冊回呼,接收最終結果。相關規範有 Promises/A 與 Promises/A+ 兩版。
與其背誦定義,不如自己刻一個出來。以下依「Promise 類別 → Deferred 類別 → 工具函式 → 實際使用」的順序拆解。
一、設計 Promise 類別
需要三個屬性:等待中的回呼佇列 queue(初始化為空陣列)、結果值 value(初始化為 null)、狀態 status(初始化為 'pending')。再配上 getQueue、getStatus、setStatus 三個存取方法。
setStatus() 是整個狀態機的核心:它只接受 fulfilled 與 rejected,設定完成後清空佇列,並用 Object.freeze 凍結物件——因為狀態一旦定案就不可逆。
then(onFulfilled, onRejected) 則把兩個回呼打包成 handler,附上一個 Deferred 作為回傳憑證。若目前仍在 pending,就把 handler 推進佇列;若已定案,立刻交給工具函式處理。最後回傳 handler.deferred.promise,這正是鏈式呼叫得以成立的原因。
二、設計 Deferred 類別
Deferred 只負責一個屬性 promise,以及 resolve() 與 reject() 兩個方法。兩者的邏輯幾乎對稱:先確認 promise 仍在 pending(否則直接返回,這一步保證了狀態單向性),取出佇列,逐一交給工具函式處理,最後設定狀態。
三、工具函式 procedure()
它接收「類型、handler、結果」三個參數,取出對應的處理函式並執行。最關鍵的一段是:若回呼的返回值本身是 thenable(帶有 then 方法),就必須「接納」它的狀態——把它 resolve 時的責任轉交給下一個 deferred。這裡用高階函式 makeSignaler 產生兩個綁定好 deferred 與類型的函式,避免閉包直接寫死造成的引用問題。
<script>
/* ============ Promise ============ */
Promise = function() {
this.queue = [];
this.value = null;
this.status = 'pending'; // pending | fulfilled | rejected
};
Promise.prototype.getQueue = function() {
return this.queue;
};
Promise.prototype.getStatus = function() {
return this.status;
};
Promise.prototype.setStatus = function(s, value) {
if (s === 'fulfilled' || s === 'rejected') {
this.status = s;
this.value = value || null;
this.queue = [];
var freezeObject = Object.freeze || function(){};
freezeObject(this); // promise 狀態不可逆
} else {
throw new Error({ message: "doesn't support status: " + s });
}
};
Promise.prototype.isFulfilled = function() {
return this.status === 'fulfilled';
};
Promise.prototype.isRejected = function() {
return this.status === 'rejected';
};
Promise.prototype.isPending = function() {
return this.status === 'pending';
};
Promise.prototype.then = function(onFulfilled, onRejected) {
var handler = {
'fulfilled': onFulfilled,
'rejected': onRejected
};
handler.deferred = new Deferred();
if (!this.isPending()) {
// 允許先改變狀態,後再添加回呼
utils.procedure(this.status, handler, this.value);
} else {
this.queue.push(handler);
}
return handler.deferred.promise; // then 必須回傳 promise
};
/* ============ 工具函式 ============ */
var utils = (function(){
var makeSignaler = function(deferred, type) {
return function(result) {
transition(deferred, type, result);
};
};
var procedure = function(type, handler, result) {
var func = handler[type];
var def = handler.deferred;
if (func) {
try {
var newResult = func(result);
if (newResult && typeof newResult.then === 'function') {
// thenable:直接接納它的狀態
newResult.then(
makeSignaler(def, 'fulfilled'),
makeSignaler(def, 'rejected')
);
} else {
transition(def, type, newResult);
}
} catch(err) {
transition(def, 'rejected', err);
}
} else {
transition(def, type, result);
}
};
var transition = function(deferred, type, result) {
if (type === 'fulfilled') {
deferred.resolve(result);
} else if (type === 'rejected') {
deferred.reject(result);
} else if (type !== 'pending') {
throw new Error({ 'message': "doesn't support type: " + type });
}
};
return { 'procedure': procedure };
})();
/* ============ Deferred ============ */
Deferred = function() {
this.promise = new Promise();
};
Deferred.prototype.resolve = function(result) {
if (!this.promise.isPending()) { return; }
var queue = this.promise.getQueue();
for (var i = 0, len = queue.length; i < len; i++) {
utils.procedure('fulfilled', queue[i], result);
}
this.promise.setStatus('fulfilled', result);
};
Deferred.prototype.reject = function(err) {
if (!this.promise.isPending()) { return; }
var queue = this.promise.getQueue();
for (var i = 0, len = queue.length; i < len; i++) {
utils.procedure('rejected', queue[i], err);
}
this.promise.setStatus('rejected', err);
};
</script>
四、實際使用:用它包裝 ajax
// 以 Deferred 封裝原生 XHR
ajax = function(url) {
var def = new Deferred();
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function() {
if (xhr.readyState === 4) {
if ((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304) {
def.resolve(xhr.responseText);
} else {
def.reject(new Error({ message: xhr.status }));
}
}
};
xhr.open('get', url, true);
xhr.send(null);
return def.promise;
};
// 鏈式呼叫
ajax('test.php?act=1').then(function(data1) {
console.log(data1);
return ajax('test.php?act=2');
}).then(function(data2) {
console.log(data2);
return ajax('test.php?act=3');
}, function(err) {
console.error(err);
}).then(function(data3) {
console.log(data3);
alert('success');
}, function(err) {
console.error(err);
});
後端只要依 act 參數回傳不同內容即可驗證:
<?php
if($_GET['act'] == 1){
echo json_encode(array("code" => 200));
} else if($_GET['act'] == 2){
echo json_encode(array("code" => 300));
} else if($_GET['act'] == 3){
echo json_encode(array("code" => 400));
}

寫完這一輪就會發現,Promise 並不神祕:它只是把「回呼登錄」與「結果通知」拆成兩個角色——Deferred 負責對外發布結果,Promise 負責對內保存狀態與佇列,而 then 回傳新 Promise 這一步,讓整串流程得以平鋪展開。真正需要小心的是 thenable 的接納邏輯與狀態不可逆這兩點,實作時多數 bug 都出在這裡。