DIV CSS 佈局教程網

Promise 非同步編程的原理:從回呼地獄到鏈式呼叫
編輯:JavaScript基礎知識     

一、起源:回呼寫法遇到的問題

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。

1. 狀態

Promise 有三種狀態:

  • pending:待處理,也是初始狀態。
  • fulfilled:已完成。
  • rejected:已拒絕。

2. 介面

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 物件,先想清楚兩個問題:

  1. Promise 建構函式中要實現「非同步對象狀態」與「回呼函式」的剝離,而且分離之後還要能讓回呼正常執行。
  2. 如何實現鏈式呼叫並管理狀態。

建構函式

// 全域巨集定義
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+ 規範的要求。

then 方法

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);
        }
    });
};

藉由這段程式碼,前面兩個問題都獲得了解答:

  1. Promise 物件上有 state、value、handlers 三個屬性,這三者解決了「狀態與回呼分離」的問題,並且在呼叫 then 時才把回呼 push 進 handlers(此時 state 可能已是 FULFILLED,所以後面那段程式碼會立即執行 onResolved)。
  2. 鏈式呼叫透過 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,底層運作機制完全相同。

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