DIV CSS 佈局教程網

深入解析 JavaScript 中的 Promise:從回呼地獄到規範實作
編輯:關於JavaScript     

JavaScript 一向以回呼函式(callback)作為處理非同步程式設計的主要手法。從同步思維過渡到非同步回呼本就需要一段適應期,一旦出現多層回呼嵌套,也就是我們常說的「回呼金字塔」(Pyramid of Doom),那絕對是一場噩夢般的開發體驗。為了解決這個痛點,CommonJS 提出了 Promises/A 規範。本文將先梳理 Promise 的相關規範,再透過解讀一個迷你版的 Promise 實作來加深理解。

什麼是 Promise
一個 Promise 物件代表一個目前還不可用、但在未來某個時間點可以被解析的值。它讓你能夠以近乎同步的寫法來組織非同步程式碼。舉例來說,如果你想非同步呼叫一個遠端伺服器,就需要先建立一個代表「未來將由服務回傳資料」的 Promise 物件,此時資料尚未到來,Promise 便扮演著真實資料的代理角色。等到請求完成、資料從伺服器返回後,你就能在 Promise 上綁定回呼函式,一旦真實資料就緒,回呼便會被觸發。

Promise 這種概念其實早已存在於許多程式語言之中。

告別回呼金字塔(Pyramid of Doom)
JavaScript 中最常見的反模式,就是在回呼裡再層層嵌套回呼。

 // 回調金字塔 asyncOperation(function(data){ // 處理 `data` anotherAsync(function(data2){ // 處理 `data2` yetAnotherAsync(function(){ // 完成 }); }); }); 

導入 Promise 之後,程式碼變成這樣:

 promiseSomething() .then(function(data){ // 處理 `data` return anotherAsync(); }) .then(function(data2){ // 處理 `data2` return yetAnotherAsync(); }) .then(function(){ // 完成 }); 

Promise 把原本層層縮進的嵌套回呼,改造成一連串 .then 的鏈式呼叫,徹底擺脫了難以維護的縮排地獄。它並非解決某個具體問題的演算法,而是一種更優秀的程式碼組織模式。當你接受這種新模式時,也會逐漸以全新的視角去理解非同步呼叫。

各個語言平台都有對應的 Promise 實現:

  • Java 的 java.util.concurrent.Future
  • Python 的 Twisted deferreds 與 PEP-3148 futures
  • F# 的 Async
  • .Net 的 Task
  • C++ 11 的 std::future
  • Dart 的 Future
  • JavaScript 的 Promises/A/B/D/A+

接下來,我們就來逐一了解 JavaScript 環境下各個規範的一些細節。

Promises/A 規範
promise 代表一個最終值,這個值由某個操作完成時返回。

  • promise 有三種狀態:未完成(unfulfilled)、完成(fulfilled)與失敗(failed)。
  • promise 的狀態只能由「未完成」轉為「完成」,或由「未完成」轉為「失敗」。
  • promise 的狀態轉換只會發生一次。

promise 有一個 then 方法,可以接受三個函式作為參數。前兩個函式分別對應 fulfilled 與 rejected 兩種狀態的回呼,第三個函式則用於處理進度資訊(進度回呼屬於可選支援)。

 promiseSomething().then(function(fulfilled){ //當promise狀態變成fulfilled時,調用此函數 },function(rejected){ //當promise狀態變成rejected時,調用此函數 },function(progress){ //當返回進度信息時,調用此函數 }); 

如果 promise 還支援以下兩個附加方法,則稱之為「可互動的 promise」:

  • get(propertyName)

取得當前 promise 最終值上的一個屬性,返回值是一個新的 promise。

  • call(functionName, arg1, arg2, ...)

呼叫最終值上的一個方法,返回值同樣是一個新的 promise。

Promises/B 規範
在 Promises/A 的基礎上,Promises/B 進一步定義了一組 promise 模組需要實現的 API。

when(value, callback, errback_opt)
若 value 不是 promise,則在下一個事件迴圈呼叫 callback,並將 value 作為傳入值;若 value 是 promise,當其狀態已完成或轉為完成時,於下一事件迴圈呼叫 callback 並傳入 resolve 的值,當其狀態已失敗或轉為失敗時,於下一事件迴圈呼叫 errback 並傳入失敗原因。

asap(value, callback, errback_opt)
與 when 最大的差別在於:若 value 不是 promise,會被立即執行,而不必等到下一個事件迴圈。

enqueue(task Function)
盡快在接下來的事件迴圈中呼叫 task 方法。

get(object, name)
返回一個取得物件屬性的 promise。

post(object, name, args)
返回一個呼叫物件方法的 promise。

put(object, name, value)
返回一個修改物件屬性的 promise。

del(object, name)
返回一個刪除物件屬性的 promise。

makePromise(descriptor Object, fallback Function)
返回一個 promise 物件,該物件必須是可呼叫的函式,也可能是可被實例化的建構函式。

  • 第一個參數接受一個描述物件,其結構如下:
 { "when": function(errback){...}, "get": function(name){...}, "put": function(name, value){...}, "post": function(name, args){...}, "del": function(name){...}, } 

上述每一個註冊的 handle 都會返回一個 resolved value 或 promise。

  • 第二個參數接受一個 fallback(message,...args) 函式,當找不到對應的 handle 時便會觸發,並返回一個 resolved value 或 promise。

defer()
返回一個物件,其中包含一個 resolve(value) 方法與一個 promise 屬性。當 resolve(value) 第一次被呼叫時,promise 屬性的狀態變為「完成」,所有觀察該 promise 的 promise 狀態也一併轉為「完成」。若 value 不是 promise,會被包裝成一個 ref。resolve 方法會忽略之後的所有呼叫。

reject(reason String)
返回一個被標記為「失敗」的 promise。當在失敗的 promise 上呼叫 when(message) 時,會採用以下兩種做法之一:
1. 若存在 errback,則以 reason 作為參數呼叫 errback,when 會返回 errback 的返回值。
2. 若不存在 errback,when 會返回一個新的、以同一 reason 為參數的 reject 狀態 promise。

ref(value)
若 value 是 promise 物件,直接返回 value 本身;否則返回一個 resolved 的 promise,並攜帶以下 handle:
1. when(errback),忽略 errback,返回 resolved 值
2. get(name),返回 resolved 值的對應屬性
3. put(name, value),設定 resolved 值的對應屬性
4. del(name),刪除 resolved 值的對應屬性
5. post(name, args),呼叫 resolved 值的對應方法
6. 其他所有呼叫都返回一個 reject,並攜帶「Promise does not handle NAME」的理由。

isPromise(value) Boolean
判斷一個物件是否為 promise。

method(name String)
取得一個返回 name 對應方法的 promise,返回值為「get」、「put」、「del」與「post」對應的方法,但會在下一事件迴圈返回。

Promises/D 規範
為了提升不同 promise 實作之間的可互操作性,Promises/D 規範對 promise 物件與 Promises/B 做了進一步約定,以達到「鴨子類型」(Duck-type Promise)的效果。簡單來說,它做了兩件事:一是定義如何判斷一個物件是不是 Promise;二是對 Promises/B 規範進行細節補充。

辨識一個 Promise 物件
Promise 物件必須實現 promiseSend 方法。
1. 在 promise 函式庫的上下文中,只要物件含有 promiseSend 方法,就可辨識為 promise 物件。
2. promiseSend 方法必須接受一個操作名稱作為第一個參數。
3. 操作名稱是一個可擴充的集合,以下是一些保留名稱:
when,此時第三個參數必須是 rejection 回呼,且該回呼必須接受一個 rejection 原因(可以是任何值)作為第一個參數;
get,此時第三個參數為屬性名(字串型別);
put,此時第三個參數為屬性名,第四個參數為新屬性值;
del,此時第三個參數為屬性名;
post,此時第三個參數為方法屬性名,接下來的變參為方法的呼叫參數;
isDef。
4. promiseSend 方法的第二個參數為 resolver 方法。
5. promiseSend 方法可接受變參。
6. promiseSend 方法必須返回 undefined。

對 Promises/B 規範的補充
Promises/D 對 Promises/B 中定義的 ref、reject、def、defer 等方法做了更細緻的約束,此處暫且略過這些細節。

Promises/A+ 規範
前面提到的 Promises/A/B/D 都由 CommonJS 組織提出,而 Promises/A+ 則由一個自稱為 Promises/A+ 的組織發布。它以 Promises/A 為基礎進行補充與修訂,旨在提升各 promise 實作之間的可互操作性。

Promises/A+ 對 then 方法做了細緻補充,定義了明確的 Promise Resolution Procedure 流程,並將 then 方法作為辨識 promise 物件的依據。此外,它還提供了相容性測試工具,用於驗證各個實作的相容程度。

實作一個迷你版的 Promise
聊了這麼多規範,接下來我們看看如何打造一個簡單而精簡的 Promise。

1、狀態機

 var PENDING = 0; var FULFILLED = 1; var REJECTED = 2; function Promise() { // store state which can be PENDING, FULFILLED or REJECTED var state = PENDING; // store value or error once FULFILLED or REJECTED var value = null; // store sucess & failure handlers attached by calling .then or .done var handlers = []; } 

2、狀態變遷
僅支援兩種狀態變遷:fulfill 與 reject。

 // ... function Promise() { // ... function fulfill(result) { state = FULFILLED; value = result; } function reject(error) { state = REJECTED; value = error; } } 

fulfill 與 reject 較為底層,通常會對外開放更高層的 resolve 方法。

 // ... function Promise() { // ... function resolve(result) { try { var then = getThen(result); if (then) { doResolve(then.bind(result), resolve, reject) return } fulfill(result); } catch (e) { reject(e); } } } 

resolve 方法可以接受一個普通值或另一個 promise 作為參數;若接受的是 promise,則會等待其完成。由於 promise 不允許被另一個 promise fulfill,所以需要開放 resolve 方法。resolve 依賴以下幾個輔助方法:

 /** * Check if a value is a Promise and, if it is, * return the `then` method of that promise. * * @param {Promise|Any} value * @return {Function|Null} */ function getThen(value) { var t = typeof value; if (value && (t === 'object' || t === 'function')) { var then = value.then; if (typeof then === 'function') { return then; } } return null; } /** * Take a potentially misbehaving resolver function and make sure * onFulfilled and onRejected are only called once. * * Makes no guarantees about asynchrony. * * @param {Function} fn A resolver function that may not be trusted * @param {Function} onFulfilled * @param {Function} onRejected */ function doResolve(fn, onFulfilled, onRejected) { var done = false; try { fn(function (value) { if (done) return done = true onFulfilled(value) }, function (reason) { if (done) return done = true onRejected(reason) }) } catch (ex) { if (done) return done = true onRejected(ex) } } 

這裡 resolve 與 doResolve 之間的遞迴設計相當巧妙,專門用來處理 promise 的層層嵌套(也就是 promise 的 value 又是一個 promise 的情況)。

建構函式

 // ... function Promise(fn) { // ... doResolve(fn, resolve, reject); } 

.done 方法

 // ... function Promise(fn) { // ... function handle(handler) { if (state === PENDING) { handlers.push(handler); } else { if (state === FULFILLED && typeof handler.onFulfilled === 'function') { handler.onFulfilled(value); } if (state === REJECTED && typeof handler.onRejected === 'function') { handler.onRejected(value); } } } this.done = function (onFulfilled, onRejected) { // ensure we are always asynchronous setTimeout(function () { handle({ onFulfilled: onFulfilled, onRejected: onRejected }); }, 0); } // ... } 

.then 方法

 // ... function Promise(fn) { // ... this.then = function (onFulfilled, onRejected) { var self = this; return new Promise(function (resolve, reject) { return self.done(function (result) { if (typeof onFulfilled === 'function') { try { return resolve(onFulfilled(result)); } catch (ex) { return reject(ex); } } else { return resolve(result); } }, function (error) { if (typeof onRejected === 'function') { try { return resolve(onRejected(error)); } catch (ex) { return reject(ex); } } else { return reject(error); } }); }); } // ... } 

$.promise
在 jQuery 1.8 之前的版本中,jQuery 的 then 只是一種能同時呼叫 done、fail 與 progress 三種回呼的速寫方法,而 Promises/A 規範中的 then 在行為上更近似 jQuery 的 pipe。jQuery 1.8 修正了這個問題,讓 then 成為 pipe 的同義詞。不過受限於向後相容,jQuery 的 Promise 無論多麼向 Promises/A 靠攏,都不太討喜。

此外,在 Promises/A 規範中,由 then 生成的 promise 究竟是被執行還是被拒絕,取決於 then 所呼叫的那個回呼是返回值還是拋出錯誤。而在 jQuery 的 promise 回呼中拋出錯誤是個糟糕的做法,因為錯誤不會被捕獲。

小結
最後一個範例揭示了:實作 Promise 的關鍵在於把 doResolve 方法寫好,並在完成後觸發回呼;而為了確保非同步,`setTimeout(fun, 0);` 是至關重要的一步。

Promise 一直用得很順手,它極大地優化了 NodeJS 非同步處理時的程式碼結構。但對於它的工作原理,過去總有些一知半解與好奇,於是花了些心力查閱並翻譯了 Promise 的規範,以充分理解其細節。

以上就是關於 JavaScript 中 Promise 使用方法的介紹,希望對大家的學習有所幫助。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved