JavaScript异步co

上三篇分别介绍了Promise，Generator，Thunk自动执行Generator，本篇介绍用co模块将Generator和Promise结合起来，自动执行Generator。co模块参照这里，以前co模块返回的是Thunk，现在返回的是promise。

仍旧以读取文件为例，先用Promise来执行异步操作：

var fs = require('fs'); 
var readFile = function (fileName, options) {
    return new Promise(function (resolve, reject){
        fs.readFile(fileName, options, function(error, data){
            if (error) return reject(error);
            resolve(data);
        });
    });
};

readFile('./apples.txt', 'utf8').then(function(data){
    console.log(data);
    return readFile('./oranges.txt', 'utf8'); 
}).then(function(data){
    console.log(data);
}).catch(function(error){
    console.log(error);
});

先将异步函数fs.readFile封装成一个Promise对象，起名readFile。然后调用then依次执行异步操作。

但看起来一堆then，代码不够清晰，改成用Generator来定义异步操作的步骤：

var gen = function* () {
    var f1 = yield readFile('./apples.txt', 'utf8');
    console.log(f1);
    var f2 = yield readFile('./oranges.txt', 'utf8');
    console.log(f2);
};

var g = gen();
g.next().value.then(function(data) {
    g.next(data).value.then(function(data) {
        g.next(data);
    });
});

有了上两篇的基础，这些代码应该很容易就能看懂了。用Generator定义异步步骤，确实比Promise的then清晰很多，维护方便。但Generator的问题是，一步步执行next很麻烦。我们需要让Generator自动执行起来：

function run(gen){
    var g = gen();
    function next(data){
        var result = g.next(data);
        if (result.done) return result.value;
        result.value.then(function(data){
            next(data);
        });
    }
    next();
}
run(gen);

这些都是之前三篇介绍过的，炒炒冷饭。co源代码就是上面run方法的扩展， 因为源代码非常短，干脆直接贴出来看看它是怎么实现的：（为缩减篇幅，删除了源代码里的注释）

function co(gen) {	//co函数接受Generator函数作参数，最终返回一个 Promise 对象
  var ctx = this;
  var args = slice.call(arguments, 1);

  return new Promise(function(resolve, reject) {		//co函数返回的是一个Promise对象
    //先检查参数，如果是Generator函数就获得一个遍历器对象。
    //如果不是，或没有next方法，就将其转成一个状态为Resolved的Promise对象，并返回。
    if (typeof gen === 'function') gen = gen.apply(ctx, args);
    if (!gen || typeof gen.next !== 'function') return resolve(gen);

    onFulfilled();	//Generator函数的next方法被封装在此处

    function onFulfilled(res) {
      var ret;
      try {
        ret = gen.next(res);
      } catch (e) {
        return reject(e);
      }
      next(ret);	//关键在这里，详见下面next方法
      return null;
    }

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

    //该函数会无限递归，直到Generator函数执行完毕为止
    function next(ret) {
      //返回值的done属性为true表示Generator函数遍历完毕，返回Promise对象
      if (ret.done) return resolve(ret.value);

      //源码中定义了toPromise方法可以将Object，Array，Thunk，Generator转成Promise对象。
      //即你需要确保Generator函数的yield命令后面，是这些对象
      var value = toPromise.call(ctx, ret.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源代码加上注释后应该可以理解。用co模块自动执行Generator函数只需一行代码：co(gen);。是不是简单到令人发指？完整代码如下：

var fs = require('fs');
var co = require('co');

var readFile = function (fileName, options) {
    return new Promise(function (resolve, reject){
        fs.readFile(fileName, options, function(error, data){
            if (error) return reject(error);
            resolve(data);
        });
    });
};
var gen = function* () {
    var f1 = yield readFile('./apples.txt', 'utf8');
    console.log(f1);
    var f2 = yield readFile('./oranges.txt', 'utf8');
    console.log(f2);
};
co(gen);

先定义一个Promise对象将异步函数封装起来，用Generator函数定义异步操作流程，co模块里将yield命令后的异步操作包装成一个Promise对象，用then交回执行权来递归自动执行Generator函数。