node js co分析2

转载请注明： TheViper http://www.cnblogs.com/TheViper 

更好的可以看http://purplebamboo.github.io/2014/05/24/koa-source-analytics-2/

源码

function co(fn) {
  var isGenFun = isGeneratorFunction(fn);

  return function (done) {
    var ctx = this;

    // in toThunk() below we invoke co()
    // with a generator, so optimize for
    // this case
    var gen = fn;
    // we only need to parse the arguments
    // if gen is a generator function.
    if (isGenFun) {
      var args = slice.call(arguments), len = args.length;
      var hasCallback = len && 'function' == typeof args[len - 1];
      done = hasCallback ? args.pop() : error;
      gen = fn.apply(this, args);
    } else {
      done = done || error;
    }

    next();

    // #92
    // wrap the callback in a setImmediate
    // so that any of its errors aren't caught by `co`
    function exit(err, res) {
      setImmediate(function(){
        done.call(ctx, err, res);
      });
    }

    function next(err, res) {
      var ret;

      // ok
      if (!err) {
        try {
          ret = gen.next(res);
        } catch (e) {
          return exit(e);
        }
      }

      // done
      if (ret.done) return exit(null, ret.value);

      // normalize
      ret.value = toThunk(ret.value, ctx);

      // run
      if ('function' == typeof ret.value) {
        var called = false;
        try {
          ret.value.call(ctx, function(){
            if (called) return;
            called = true;
            next.apply(ctx, arguments);
          });
        } catch (e) {
          setImmediate(function(){
            if (called) return;
            called = true;
            next(e);
          });
        }
        return;
      }
    }
  }
}

var isGenFun = isGeneratorFunction(fn);,判断是不是generator function,其实这个从例子看来基本上都是。然后判断有没有回调。即是不是有

co(function *(){
  var results = yield *foo();
  console.log(results);
  return results;
})(function(err,res){
    console.log('res')
});

里面的function(err,res){...},如果有，将其赋值给done.然后是gen = fn.apply(this, args);,也就是上一篇里面说generator时候的var it = start();，start是一个generator function，这时，函数还没有执行。

然后是next();，ret = gen.next(res);,开始运行*foo()里面的第一个yield size(),返回形如{value:[function],done:false}的对象。

function *foo(){
  var a = yield size('node_modules/thunkify/.npmignore');
  var b = yield size('node_modules/thunkify/Makefile');
  var c = yield size('node_modules/thunkify/package.json');
  return [a, b, c];
}

然后ret.done判断是不是完成了。如果完成了，exit()执行回调.可以看到这里向回调传入了两个参数，err是错误信息，res是yield执行返回的结果。

    function exit(err, res) {
      setImmediate(function(){
        done.call(ctx, err, res);
      });
    }

如果没有完成，ret.value = toThunk(ret.value, ctx);，对yield执行返回的结果格式化一下，

function toThunk(obj, ctx) {
  if (isGeneratorFunction(obj)) {
    return co(obj.call(ctx));
  }

  if (isGenerator(obj)) {
    return co(obj);
  }

  if (isPromise(obj)) {
    return promiseToThunk(obj);
  }

  if ('function' == typeof obj) {
    return obj;
  }

  if (isObject(obj) || Array.isArray(obj)) {
    return objectToThunk.call(ctx, obj);
  }

  return obj;
}

如果ret.value是generator,继续co(fn),如果是promise,返回thunk形式

function promiseToThunk(promise) {
  return function(fn){
    promise.then(function(res) {
      fn(null, res);
    }, fn);
  }
}

如果是函数，返回函数。

如果是object或array，稍微复杂点，这个最后说。

然后如果ret.value是函数，执行这个函数并传入一个回调函数，

function(){
     if (called) return;
     called = true;
     next.apply(ctx, arguments);
}

这也就是为什么给yield传入的函数要写出形如

function size(file) {
  return function(fn){
    fs.stat(file, function(err, stat){
      if (err) return fn(err);
      fn(null,stat.size);
    });
  }
}

当这个异步操作执行后，会向fn传入两个参数，因为function next(err, res)。

上一篇里面有一个例子将回调变为一个参数，也就是fn(stat.size)取代fn(null,stat.size)，只会返回第一个yield结果，因为这里没有参数移位，只通过参数的位置判断传入的参数所对应的形参，所以stat.size就被认为是err了,也就是直接exit（）了，所以定义thunk的时候一定要传入两个参数，而且位置不能变。

顺便说一下上一篇里面提到的thunkify,它是用来将一般异步操作变成thunk形式，源码很简单

function thunkify(fn){
  assert('function' == typeof fn, 'function required');

  return function(){
    var args = new Array(arguments.length);
    var ctx = this;

    for(var i = 0; i < args.length; ++i) {
      args[i] = arguments[i];
    }

    return function(done){
      var called;

      args.push(function(){
        if (called) return;
        called = true;
        done.apply(null, arguments);
      });
      try {
        fn.apply(ctx, args);
      } catch (err) {
        done(err);
      }
    }
  }
};

使用

var size=thunkify(fs.stat);
function *foo(){
  var a = yield size('node_modules/thunkify/.npmignore');
  var b = yield size('node_modules/thunkify/Makefile');
  var c = yield size('node_modules/thunkify/package.json');
  return [a, b, c];
}

co(function *(){
  var results = yield *foo();
  console.log(results);
  return results;
})();

思想就是把参数添加到args数组，最后再向args数组添加

function(){
        if (called) return;
        called = true;
        done.apply(null, arguments);
 }

这个回调，作为fn.apply(ctx, args);执行后的回调。里面的done是上面co源码里面的

function(){
   if (called) return;
   called = true;
   next.apply(ctx, arguments);
}

done这里就相当于自己写的thunk里面的fn.

thunk的总结下就是在异步操作外面封装一个return function(fn),fn是co向thunk传入的回调，里面有next().然后在异步操作回调里面要触发fn,以保证fn的next()会执行。

回到主线，然后next.apply(ctx,arguments);,执行下一个yield.

最后说一下toThunk()里面的objectToThunk

function objectToThunk(obj){
  var ctx = this;
  var isArray = Array.isArray(obj);

  return function(done){
    var keys = Object.keys(obj);
    var pending = keys.length;
    var results = isArray
      ? new Array(pending) // predefine the array length
      : new obj.constructor();
    var finished;// prepopulate object keys to preserve key ordering
    if (!isArray) {
      for (var i = 0; i < pending; i++) {
        results[keys[i]] = undefined;
      }
    }

    for (var i = 0; i < keys.length; i++) {
      run(obj[keys[i]], keys[i]);
    }

    function run(fn, key) {
      if (finished) return;
      try {
        fn = toThunk(fn, ctx);

        if ('function' != typeof fn) {
          results[key] = fn;
          return --pending || done(null, results);
        }

        fn.call(ctx, function(err, res){
          if (finished) return;

          if (err) {
            finished = true;
            return done(err);
          }

          results[key] = res;
          --pending || done(null, results);
        });
      } catch (err) {
        finished = true;
        done(err);
      }
    }
  }
}

例子

function *foo(){
  var a= yield {
    name: {
      first: yield size('node_modules/thunkify/.npmignore'),
      last:yield size('node_modules/thunkify/Makefile')
    }
  };
  return a;//{name:{first:13,last:39}
}

Object.keys(obj)将oject的所有key添加到一个数组。这里是是['name'],['first','last']，然后初始化最终返回的results.接着就是run()

    for (var i = 0; i < keys.length; i++) {
      run(obj[keys[i]], keys[i]);
    }

例子里面有一层嵌套，所以obj[keys[i]]还是对象，这没关系，后面会处理。

注意到fn = toThunk(fn, ctx);，如果fn是对象的话，又会去调用objectToThunk(obj)。....如果fn中有嵌套，toThunk(fn,ctx)会进行深度遍历。

如果返回的fn不是function，则认为确实是嵌套到了尽头，也就是最终函数。--pending判断key是不是key数组的最后一个了，如果是就done(null, results)

如果fn是function,就和上面的next()差不多了，不同的是各个函数执行一次就对公用的长度变量减一，不需要关心各个函数的执行顺序，只要当其中一个函数发现变量变为0时，代表其他函数都执行好了，是最后一个，于是就可以调用回调函数done了。