让我们来想想generator函数和async有啥区别？唯一的区别是async函数会自动执行，而generator每次需要调用next函数。仅此而已。

首先我们来看一个简单的例子

function *gen() {
  yield new Promise(((resolve, reject) => {resolve()}))
  yield new Promise(((resolve, reject) => {resolve()}))
  yield new Promise(((resolve, reject) => {resolve()}))
}

这是一个很简单的generator,接下来看我怎么写的

let g = gen();
let ret = g.next;
ret.value.then(() => {
  g.next();
})

哈哈哈,现在就大功告成啦。我们只要找到一个适当的办法让g.next()一直持续下去就可以做到自动执行啦。
所以关键是yield后的value必须是一个promise,那现在让我们来看看co是怎么把这些东西都转化成promise的吧！

function co(gen) {
  var ctx = this; //  把上下文转化成当前调用co的对象
  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
  // 不管你的gen是什么, 都先用Promise包裹起来
  return new Promise(function(resolve, reject) {
    // 如果gen是函数, 则修改gen的this为co中的this对象并执行gen

    if (typeof gen === 'function') gen = gen.apply(ctx, args);

    // 因为执行了gen,现在的gen是一个有next和value的对象 如果gen不存在或者不是函数不是generator 则直接返回gen

    if (!gen || typeof gen.next !== 'function') return resolve(gen);

    // 开始执行上一个代码段类似的g.next()
    onFulfilled();

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

    function onFulfilled(res) {
      var ret;
      try {
        ret = gen.next(res); // 执行每一个gen.next()
      } catch (e) {
        return reject(e);
      }
      next(ret); // 把执行得到的返回值传入next函数中。next函数是自动执行的关键
    }

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

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

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

    function next(ret) {
      // 如果ret.done = true 说明已经迭代完毕,返回最后一次迭代的value
      if (ret.done) return resolve(ret.value);

      // 把无论ret.value里是什么都转化成Promise,且把上下文指向ctx
      var value = toPromise.call(ctx, ret.value);
      // then()方法里第一个参数是onCompleted, 第二个参数是onRejected

      // 如果value是promise对象且存在 那继续在then方法中调用onFulfilled
      // 相当于从头开始
      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) + '"'));
    }
  });
}

代码比较长,大家可以先看注释再看我下面写的话。
所以co的思想就是把一个generator函数封装在一个promise对象里,然后在这个promise对象中再次把它g.next()的对象也封装成promise对象,当这个子promise对象完成的时候重复调用g.next()。当所有迭代完成时,把父promise对象resolve掉。这就成了一个类async函数了。

大神写的代码太美了,既简洁又抽象。真的美呀！