DIV CSS 佈局教程網

從 Q 的演進看 Promise 的實作原理
編輯:JavaScript基礎知識     

Promise 核心說明

雖然 Promise 早已有自己的規範,各家實作庫在細節上仍互有差異,部分 API 的語意甚至完全不同。但核心是一致的:那就是 then 方法。術語中所說的 promise,指的就是一個擁有 then 方法、且該方法能觸發特定行為的物件或函數。

因此核心說明不會涉及任何具體實作——它的意思是:這就是最終要達成的樣子,請照著這個結果反推程式碼該怎麼寫。

起步:換個角度理解 Promise

先回想 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 方法的物件。

從 defer 開始

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 與 promise 分開

前面的 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 時會派上用場。

實作 then 的串接

接下來是相當關鍵的一步。到 q3 為止的 promise 都無法串接,但我們熟悉的寫法應該是:

promise.then(step1).then(step2);

也就是說,promise 必須能產生出新的 promise,並沿用舊 promise 的值。要達成這點,需要三件事:

  • then 方法必須回傳 promise。
  • 該 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 庫,思路走得非常明確。再複雜的庫也都是從幾個基本要點長出來的——若我們自己要動手做類似的事,也該保持這樣的心態,一點一點往前推進。

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