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-函数的实现原理)

大体的逻辑实际是同样的。