co库与async函数原理-优快云博客

前言

在谈到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;
}
复制代码