异步编程之 co 源码分析

Question

如何使用 co

大家如果能消化掉前面的知识，相信这一章的分析也肯定是轻轻松松的。我们这一章就来说说，我们之前一直高调提到的 co 库。co 库，它用 Generator 和 Promise 相结合，完美提升了我们异步编程的体验。我们首先看看如何使用 co 的，我们仍旧以之前的读取Json文件的例子看看：

// 注意readFile已经是Promise化的异步API 
co(function* (){
    var filename = yield readFile('hello3.txt', 'utf-8');
    var json = yield readFile(filename, 'utf-8');
    return JSON.parse(json).message;
}).then(console.log, console.error);

大家看上面的代码，甚至是可以使用同步的思维，不用去理会回调什么鬼的。我们 readFile() 得到 filename，然后再次 readFile() 得到 json，解析完json后输出就结束了，非常清爽。大家如果不相信的话，可以使用原生的异步api尝试一下，fs.readFile() 像上面相互有依赖的，绝对恶心！

我们可以看到，仅仅是在 promise 化的异步 api 前有个 yield 标识符，就可以使 co 完美运作。上一篇我们也假想过 co 的内部是如何实现的，我们再理（fu）顺（zhi）一次：

1. 我们调用遍历器的 next() 得到该异步的promise对象
2. 在promise对象的 then() 中的 resolve 对数据进行处理
3. 把处理后的数据作为参数res传入next(res)，继续到下一次异步操作
4. 重复2，3步骤。直到迭代器的done: true，结束遍历。

如果不清楚我们上面说过的 Generator 遍历器或 promise 对象的，可以先放一放这篇文章，从之前的几篇看起。

进入 co 的世界

获得遍历器

co的源码包括注释和空行仅仅才240行，不能再精简！我们抽出其中主要的代码来进行分析。

function co(gen) {
  var ctx = this; // context
  
  // return a promise
  return new Promise(function(resolve, reject) {
    if (typeof gen === 'function') gen = gen.call(ctx); // 调用构造器来获得遍历器
    if (!gen || typeof gen.next !== 'function') return resolve(gen);
    
    //...下面代码暂时省略...
   })
}

这里我们需要关注的有两点：

1. co函数最终返回的是一个Promise。
2. 第6行代码，我们可以看到gen变量一开始就已经自身调用了。也就是gen从构造器变成了遍历器。<a id="more"></a> 遍历器开始遍历

---

我们首先看看co内部的next(ret)函数，它是整个遍历器自动运行的关键。

function next(ret) {
  if (ret.done) return resolve(ret.value);
  var value = toPromise.call(ctx, ret.value);
  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) + '"'));
}

我们可以看到，ret参数有done和value，那么ret肯定就是遍历器每次next()的结果。如果发现遍历器遍历结束的话，便直接return整个大Promise的resolve(ret.value)方法结束遍历。对了，此遍历器的next()和co的next()在这里是不一样的。当然你可以认为co将遍历器的next()又封装了一遍方便源码使用。

接着看，如果并没有完成遍历。我们就会对ret.value调用toPromise()，这里有知识点延伸，暂且先跳过，因为我们 一个 promise化的异步操作就是返回promise的。不知道大家get到point没？我就透漏一点，当是数组或对象时，co会识别并支持多异步的并行操作，先不管～～

我们在保证我们调用异步操作得到的value是promise后，我们就会调用value.then()方法为promise的onFulfilled()或onRejected()进行回调的绑定。也就是说，这段时间程序都是在干其他和遍历器无关的事的。遍历器没有得到遍历器的next()指令，就一直静静的等着。我们可以想到，next()指令，必定是放在了那两个回调函数（onFulfilled，onRejected）里。

自动运行

promise化的异步API是先绑定了回调方法，然后等待异步完成后进行触发。所以我们把遍历器继续遍历的next()指令放在回调中，就可以达到回调返回数据后再调用遍历器next()指令，遍历器才会继续下一个异步操作。

function onFulfilled(res) {
     var ret;
     try {
       ret = gen.next(res); // 遍历器进行遍历，ret是此次遍历项
     } catch (e) {
       return reject(e);
     }
     next(ret); // ret.value is a promise
   }

我们看到第四行，通过调用遍历器的next(res)，再次启动遍历器得到新的遍历结果，再传入co的next()里，重复之前的操作，达到自动运行的效果。这里需要注意一个地方，我们是通过向遍历器的next(res)传入res变量来实现将异步执行后的数据保存到遍历器里。

理解的关键

我相信我不可能说的很明白，让大家一下子就知道关键重点是哪个。我自己也是悟了不少时间的，最终发现那个可以使思路清晰的就是Deferred延迟对象。我在第二篇也有着重说过Deferred延迟对象，它最重要的一点就是，它是用来延迟触发回调的。我们先通过延迟对象的promise进行回调的绑定，然后在Node的异步操作的回调中触发promise绑定的函数，实现异步操作。当然这里也是如此，我们是把遍历器的next()指令延迟到回调时再触发。当然在co源码里是直接使用了ES6的promise原生对象，我们看不到deferred的存在。

所以我很早前就说了，promise对理解co至关重要。之前在promise上也花费了特别大的精力去理解，并分析原理。所以大家如果没有看之前的有关promise文章的，最好都回去看一看，绝对有好处！

co 其他的内容

---

分析完co最关键的部分，接下来就是其他各种有用的源码分析。关于thunk转化为promise我就不说了，毕竟它也是被淘汰了的东西。那要说的东西其实就两个，一个是多异步并行，一个是将co-generator转化为常规函数。我们一个一个来讲：

多异步并行

之前也有提到过，就是我们需要对迭代对象的值进行toPromise()操作。这个操作顾名思义，就是将所有需要yield的值，通通转化为promise对象。它的源码就是这样的，并不能看到实质的东西：

function toPromise(obj) {
  if (!obj) return obj;
  if (isPromise(obj)) return obj;
  if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj);
  if ('function' == typeof obj) return thunkToPromise.call(this, obj);
  if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
  if (isObject(obj)) return objectToPromise.call(this, obj);
  return obj;
}

我们还记得在co的next()函数里可以看到有一个注释是这样的：

‘You may only yield a function, promise, generator, array, or object’

意思是，我们不仅仅只可以yield一个promise对象。function和promise我们就不说了，重点就是在array和object上，它们都是通过递归调用toPromise()来实现每一个并行操作都是promise化的。

数组 Array

我们先看看相对简单的array的源码：

function arrayToPromise(obj) {
  return Promise.all(obj.map(toPromise, this));
}

map是ES5的array的方法，这个相信也有人经常使用的。我们将数组里的每一项的值，再进行一次toPromise操作，然后得到全部都是promise对象的数组交给Promise.all方法使用。这个方法在promise文章的第二篇也讲过它的实现，它会在所有异步都执行完后才会执行回调。最后resolve(res)的res是一个存有所有异步操作执行完后的值的数组。

对象 Object

Object就相对复杂些，不过原理依然是大同小异的，最后都是回归到一个promise数组然后使用Promise.all()。使用Object的好处就是，异步操作的名字和值是可以对应起来的，来看看代码：

function objectToPromise(obj){
  var results = new obj.constructor();
  var keys = Object.keys(obj); // 得到的是一个存对象keys名字的数组
  var promises = [];           // 用于存放promise
  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    var promise = toPromise.call(this, obj[key]);
    if (promise && isPromise(promise)) defer(promise, key);
    else results[key] = obj[key];
  }
  return Promise.all(promises).then(function () {
    return results;
  });

  function defer(promise, key) {
    // predefine the key in the result
    results[key] = undefined;
    promises.push(promise.then(function (res) {
      results[key] = res;
    }));
  }
}

第一个就是新建一个和传入的对象一样构造器的对象（这个写法太厉害了）。我们先获得了对象的所有的keys属性名，然后根据keys，来获取到每一个对象的属性值。一样是用toPromise()让属性值——也就是并行操作promise化，当然非promise的值就会直接存到results这个对象里。如果是promise，就会执行内部定义的defer(promise, key)函数。

所以理解defer函数是关键，我们看到是在defer函数里，我们才将当前的promise推入到promises数组里。并且每一个promise都是绑定了一个resolve()方法的，就是将结果保存到results的对象中。最后我们就得到一组都是 promise 的数组，通过 Promise.all() 方法进行异步并行操作，这样每个promise的结果都会保存到result对象相应的key里。而我们需要进行数据操作的也就是那个对象里的数据。

这里强烈建议大家动手模拟实现一遍 objectToPromise。

co.wrap(*generatorFunc)

下一个很有用的东西就是co.wrap()，它允许我们将co-generator函数转化成常规函数，我觉得这个还是需要举例子来表明它的作用。假设我们有多个异步的读取文件的操作，我们用co来实现。

/读取文件1
co(function* (){
    var filename = yield readFile('hello1.txt', 'utf-8');
    return filename;
}).then(console.log, console.error);
//读取文件2
co(function* (){
    var filename = yield readFile('hello2.txt', 'utf-8');
    return filename;
}).then(console.log, console.error);

天啊，我仿佛又回到了不会使用函数的年代，一个功能一段函数，不能复用。当然co.wrap()就是帮你解决这个问题的。

var getFile = co.wrap(function* (file){
    var filename = yield readFile(file, 'utf-8');
    return filename;
});

getFile('hello.txt').then(console.log);
getFile('hello2.txt').then(console.log);

例子很简单，我们可以将co-generator里的变量抽取出来，形成一个常规的Promise函数(regular-function)。这样子就无论是复用性还是代码结构都是优化了不少。

既然知道了怎么用，就该看看它内部如何实现的啦，毕竟这是一次源码分析。其实如果对函数柯里化（偏函数）比较了解，就会觉得非常简单。

co.wrap = function (fn) {
  createPromise.__generatorFunction__ = fn; // 这个应该是像函数constructor的东西
  return createPromise;
  function createPromise() {
    return co.call(this, fn.apply(this, arguments));
  }
};

就是一个偏函数，借助于高阶函数的特性，返回一个新函数createPromise(),然后传给它的参数都会被导入到Generator函数中。