JavaScript 的非同步由來已久,無論是計時函式、事件處理器還是 AJAX 非同步載入,都是非同步編程的一種形式。我們以 Node.js 中非同步讀取檔案為例,寫一個傳統意義的非同步函式:
var fs = require('fs');
function readJSON(filename, callback) {
fs.readFile(filename, 'utf8', function (err, res) {
if (err) {
return callback(err, null);
}
try {
var res = JSON.parse(res);
} catch (ex) {
return callback(ex);
}
callback(null, res);
});
}
這個函式接受兩個參數:檔名與回呼函式。檔名必不可少,關鍵在 callback 上。當我們要執行 readJSON 時,得自己構造回呼函式;而在 readJSON 內部傳遞 callback 時,並不知道它的參數是什麼,這對呼叫方並不友善。
再看另一種寫法——連續讀三個檔案:
fs.readFile('file1.txt', 'utf8', function (err, res) {
fs.readFile('file2.txt', 'utf8', function (err, res) {
fs.readFile('file3.txt', 'utf8', function (err, res) {
console.log(res);
});
});
});
這裡嵌套了三層非同步回呼,她們的執行時刻都無法預測,而且這種巢狀結構完全不符合一般程式的執行流程。問題很清楚了:Promise 就是為了解決上述問題而生的模式。
Promise 是對非同步編程的一種抽象。它是一個代理物件,代表一個必須非同步處理的函式所回傳的值或丟出的異常。也就是說,Promise 物件代表一個非同步操作,能把非同步的「動作」與「回呼函式」分離開來,透過 then 方法在這個非同步操作上綁定回呼。
以下遵循 CommonJS 的 Promise/A+ 規範介紹具體 API。
Promise 有三種狀態:
pending:待處理,也是初始狀態。fulfilled:已完成。rejected:已拒絕。Promise 唯一的介面是 then 方法,需要兩個參數:onResolved 與 onRejected,並回傳一個新的 Promise 物件以支援鏈式呼叫。
Promise 的建構函式接受一個函式參數,參數形式是固定的非同步任務:
function sendXHR(resolve, reject) {
var xhr = new XMLHttpRequest();
xhr.open('get', 'QueryUser', true);
xhr.onload = function () {
if ((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304) {
resolve(xhr.responseText);
} else {
reject(new Error(xhr.statusText));
}
};
xhr.onerror = function () {
reject(new Error(xhr.statusText));
};
xhr.send(null);
}
要實作 Promise 物件,先想清楚兩個問題:
// 全域巨集定義
var PENDING = 0;
var FULFILLED = 1;
var REJECTED = 2;
function Promise(fn) {
var self = this;
self.state = PENDING; // 初始化狀態
self.value = null; // 儲存非同步結果的變數
self.handlers = []; // 儲存回呼函式(這裡沒保存失敗回呼,算是個 demo 簡化)
// 非同步任務成功後的處理
function fulfill(result) {
if (self.state === PENDING) {
self.state = FULFILLED;
self.value = result;
for (var i = 0; i < self.handlers.length; i++) {
self.handlers[i](result);
}
}
}
// 非同步任務失敗後的處理
function reject(err) {
if (self.state === PENDING) {
self.state = REJECTED;
self.value = err;
}
}
fn && fn(fulfill, reject);
}
建構函式接受一個非同步函式並執行它,藉此修改 Promise 物件的狀態與結果。注意 fulfill 與 reject 都有 if (state === PENDING) 的守衛——這保證了狀態只能從 pending 轉出一次,之後的呼叫一律被忽略,對應 A+ 規範的要求。
Promise.prototype.then = function (onResolved, onRejected) {
var self = this;
return new Promise(function (resolve, reject) {
// 成功回呼的包裝:把這次回呼的結果往下一個 then 傳遞
var onResolvedFade = function (val) {
var ret = onResolved ? onResolved(val) : val;
if (Promise.isPromise(ret)) {
// 回呼函式回傳值也是 promise 時,等它完成再 resolve
ret.then(function (val) {
resolve(val);
});
} else {
resolve(ret);
}
};
var onRejectedFade = function (val) {
var ret = onRejected ? onRejected(val) : val;
reject(ret);
};
self.handlers.push(onResolvedFade);
if (self._status === FULFILLED) {
onResolvedFade(self._value);
}
if (self._status === REJECTED) {
onRejectedFade(self._value);
}
});
};
藉由這段程式碼,前面兩個問題都獲得了解答:
state、value、handlers 三個屬性,這三者解決了「狀態與回呼分離」的問題,並且在呼叫 then 時才把回呼 push 進 handlers(此時 state 可能已是 FULFILLED,所以後面那段程式碼會立即執行 onResolved)。then 中回傳的新 Promise 物件實現,並由 onResolvedFade 把上一個回呼的回傳值當作這次的 result 參數往下傳遞。function async(value) {
var pms = new Promise(function (resolve, reject) {
setTimeout(function () {
resolve(value);
}, 1000);
});
return pms;
}
async(1).then(function (result) {
console.log('the result is ', result); // the result is 1
return result + 1; // 回傳值會往下一個 then 傳
}).then(function (result) {
console.log(result); // 2
});
把上面的範例改寫成原本的巢狀讀檔,就能看出差異有多明顯:
readFile('file1.txt')
.then(res => readFile('file2.txt'))
.then(res => readFile('file3.txt'))
.then(res => console.log(res))
.catch(err => console.error(err));
錯誤處理也從「每層都要寫 if (err)」收斂到末尾一個 catch,這正是 Promise 最大的價值所在。
總之,不同框架對 Promise 的實作大同小異,上面的程式碼是 ECMAScript 6 標準 Promise 的簡化實作。jQuery 與其他框架也有各自版本,不過聽說 jQuery 的實作品質相當糟糕——它沒有遵循 A+ 規範,在 then 內部拋出錯誤時不會被下一個 then 攔下,混用時容易踩坑。
補充一點:ES2017 之後有了 async/await,它其實只是 Promise 的語法糖。用 async 函式改寫上面的例子會更貼近同步程式碼的可讀性,而錯誤處理依然靠 try/catch,底層運作機制完全相同。