co庫 原理分析

前言

在談到async/await原理 咱們就得談到co庫，由於他們從使用上是十分類似的

這是co庫的使用

co(function* () {
  var result = yield Promise.resolve(true);
  return result;
}).then(function (value) {
  console.log(value);
}, function (err) {
  console.error(err.stack);
});
複製代碼

換成async/await的用法以下

(async function () {
  var result = await Promise.resolve(true);
  return result;
}).then(function (value) {
  console.log(value);
}, function (err) {
  console.error(err.stack);
});
複製代碼

再來看看generator的一個用法

function* helloWorldGenerator() {
  // 能夠將yield當作return，只不過yield時，還能繼續
  yield 'hello';
  yield 'world';
  return 'ending';
}

var hw = helloWorldGenerator();

hw.next()
// { value: 'hello', done: false }

hw.next()
// { value: 'world', done: false }

hw.next()
// { value: 'ending', done: true }

hw.next()
// { value: undefined, done: true }

複製代碼

雖然咱們如今已經擁有了async/awiat所以咱們就不使用co了，可是仍是能夠看下它的實現邏輯。

分析

co庫的代碼是能夠從下方命令下載

git clone https://github.com/tj/co.git
複製代碼

下載完成以後代碼只有一個文件index.js，咱們來看一下這個文件

/** * slice() reference. */
// 聲明瞭一個slice方法
var slice = Array.prototype.slice;

/** * Expose `co`. */
// 作了兼容導出
module.exports = co['default'] = co.co = co;
複製代碼

咱們再來看下co方法的具體實現

/** * Execute the generator function or a generator * and return a promise. * * @param {Function} fn * @return {Promise} * @api public */
// 參數是一個generator
function co(gen) {
  var ctx = this;
  // 從第1個開始截取到最後 arguments
  var args = slice.call(arguments, 1);

  // we wrap everything in a promise to avoid promise chaining,
  // which leads to memory leak errors.
  // see https://github.com/tj/co/issues/180
  return new Promise(function(resolve, reject) {
    if (typeof gen === 'function') gen = gen.apply(ctx, args);
    if (!gen || typeof gen.next !== 'function') return resolve(gen);

    onFulfilled();

    /** * @param {Mixed} res * @return {Promise} * @api private */

    function onFulfilled(res) {
      var ret;
      try {
        // 對gen執行next()，得到返回值
        ret = gen.next(res);
      } catch (e) {
        return reject(e);
      }
      next(ret);
      return null;
    }

    /** * @param {Error} err * @return {Promise} * @api private */

    function onRejected(err) {
      var ret;
      try {
        ret = gen.throw(err);
      } catch (e) {
        return reject(e);
      }
      next(ret);
    }

    function next(ret) {
        //....先省略
    }
  });
}
複製代碼

能夠看到co最後執行完成返回的是一個Promise對象。

在這個Promise對象中，執行的是onFulfilled方法。

在這個方法當中會對自己gen參數即generator函數進行next方法的執行，執行next方法會返回{ value: '', done: false/true }對象，隨即執行本身內部的next方法。咱們來看下這個next方法的具體實現。

/** * Get the next value in the generator, * return a promise. * * @param {Object} ret * @return {Promise} * @api private */

    function next(ret) {
      // { value: '', done: false/true } 
      // 若是done是true
      if (ret.done) return resolve(ret.value);
      // value爲轉換的promise對象
      var value = toPromise.call(ctx, ret.value);
      // value 執行promise方法 按需執行onFulfilled以及onRejected
      if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
      return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, '
        + 'but the following object was passed: "' + String(ret.value) + '"'));
    }
複製代碼

在方法中，若是done爲true則直接執行resove方法，否則則執行toPromise方法。toPormise方法實際會根據value的類型，最終轉換成一個Promise對象。咱們能夠看一下這個方法。

/** * Convert a `yield`ed value into a promise. * * @param {Mixed} obj * @return {Promise} * @api private */
// 根據obj不一樣類型將其轉換成promsie對象返回
function toPromise(obj) {
  if (!obj) return obj;
  // 若是obj是promise 則直接返回
  if (isPromise(obj)) return obj;
  // 若是obj是一個generator方法，則執行co 返回一個promise對象
  if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj);
  // 將方法轉換成一個promise對象
  if ('function' == typeof obj) return thunkToPromise.call(this, obj);
  // 若是obj是一個數組，就調用 Promise.all
  // 同時會讓數組中的每一個子元素都執行toPromise來先轉換成array
  if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
  // objectToPromise調用
  if (isObject(obj)) return objectToPromise.call(this, obj);
  return obj;
}
複製代碼

在toPromise當中會根據參數obj類型，返回不一樣的promise對象。

咱們回到上述的next方法。隨後這個value因爲是一個Promise對象，它會按照本身內部狀態觸發onFulfilled或者onRejected方法。就這樣在內部遍歷，從而執行完整個gen函數。

總結

以上就是co庫的一個大體原理，經過它咱們也能大體瞭解async函數原理，具體能夠看阮老師的文章(async-函數的實現原理)

大體的邏輯實際是同樣的。