node js co分析1

node js co分析1

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

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

co模块是什么？

不同于PRomise,它是TJ大神基于ECMAScript 6 generator的异步控制解决方案.

和promise一样，用co写出来的异步代码很优雅，一目了然，扩展性也很强。

由于需要ECMAScript 6环境，所以需要下载版本新点的node.注意，不要去官网下，官网上的是最新的稳定版，要到http://nodejs.org/dist/下。另外现在官网的版本是0.10.35，需要下的是不稳定的0.11.x,至于具体版本号，co随时都在变，就用最新的好了。最后，运行node的时候要加上--harmony参数。

ECMAScript 6 generator？

比如，

function* run() {console.log("step in child generator")var b = yield 'running';console.log(b);console.log("step out child generator")}//var runGenerator = run();function* start() {  var a = yield 'start';  console.log(a);  yield *run();  var c = yield 'end';  console.log(c);  return 'over';}var it = start();console.log(it.next());//Object {value: "start", done: false} console.log(it.next(22));//22 step in child generator  object {value: 'running', done: false}console.log(it.next(333));//333 step out child generator  Object {value: 'end', done: false}console.log(it.next(444));//444 Object {value: "over", done: true}

在function后面加上*表示这是一个generator function。

var it=start();的时候，代码是没有开始执行的。it.next();相当于java,python的迭代器。

yield相当于断点调试里面的单步进入。具体的，

第一次调用it.next();，代码会执行到第一个yield声明的地方yield 'start';，此时还没有对a变量赋值。然后就是console.log返回it.next()的返回值，是一个对象，value是yield语句的值，这个值可以是字符串，函数，对象等，这里是字符串，done代表当前的generator function是否执行完毕。

然后是it.next(22);,这个时候a赋值语句开始执行，实际上此时yield 'start'返回的就是22，也就是我们传的参数。一直执行到yield 'running';代码再次断点停住了。next方法的参数会成为上一个yield的返回值。

输出22后，继续执行yield *run();里面的yield 'running';,然后和上面一样，并没有执行赋值语句。

yield的参数如果是generator function，那么当执行yieldgenerator function时，会不停的单步进入，直到最里面的那个yield的传入参数不是generator function为止。

把上面的代码改一下，增加一个generator function。

function* run1() {console.log("step in child generator1")var b = yield 'running1';console.log(b);console.log("step out child generator1")}function* run() {console.log("step in child generator")yield * run1();// console.log(b);console.log("step out child generator")}function* start() {  var a = yield 'start';  console.log(a);  yield *run();  var c = yield 'end';  console.log(c);  return 'over';}var it = start();console.log(it.next());//Object {value: "start", done: false} console.log(it.next(22));//22 step in child generator step in child generator1 object {value: 'running1', done: false}console.log(it.next(333));//333 step out child generator1 step out child generator Object {value: 'end', done: false}console.log(it.next(444));//444 Object {value: "over", done: true}

这下一目了然了。

另外，如果generator function里面如果有return，下面的断点就不再起作用，而是单步跳出，提前返回，并且return的值作为代理调用的返回值。这个后面说co时可以看到有什么用处。

co分析

最新的co版本是4.1,co 4.x是基于promise重写的，稍微激进了点，这个后面会说到。这里先说co 3.x.

首先看个例子,

var co = require('co');var fs = require('fs');function size(file) {  return function(fn){    fs.stat(file, function(err, stat){      if (err) return fn(err);      fn(null, stat.size);    });  }}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);//[13,99,1201]  return results;})();

size()是个异步操作,依次读取文件的大小然后返回。

这里的size()是改写过的，就像jquery里面的deffered,需要改写成一定的形式才能使用。这种形式叫thunk,是co里面yield可以接受的参数的一种。

可以接受的参数形式

有模块可以帮我们进行这样的改写，那就是thunkify.至于为什么要改写成这种形式，后面源码分析就可以看到原因。

参数还可以接受array

co(function *(){  var a = size('.gitignore');  var b = size('index.js');  var c = size('Makefile');  var res = yield [a, b, c];  console.log(res);  // => [ 13, 1687, 129 ]})()

object

co(function *(){  var user = yield {    name: {      first: get('name.first'),      last: get('name.last')    }  };})()

generator

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);//[13,99,1201]  return results;})();

promise

co(function* () {  var result = yield Promise.resolve(true);  return result;}).then(function (value) {  console.log(value);}, function (err) {  console.error(err.stack);});

Promise是自己构造的对象。

另外，上面所有允许的参数形式都支持嵌套。

function *foo(){  var a = yield size('.gitignore');  var b = yield size('Makefile');  var c = yield size('package.json');  return [a, b, c];}function *bar(){  var a = yield size('examples/parallel.js');  var b = yield size('examples/nested.js');  var c = yield size('examples/simple.js');  return [a, b, c];}co(function *(){  var results = yield [foo(), bar()];  console.log(results);})()

如果有回调的话

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;})(function (err,args){  console.log(args);});

可以看到，会向回调传入两个参数，一个是错误信息，一个是返回值的数组。这是在size()里面就定义了的。

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

里面的fn就是后面co要执行的回调。如果变成fn(stat.size),也就是只有一个参数。

function size(file) {  return function(fn){    fs.stat(file, function(err, stat){      if (err) return fn(null);      fn(stat.size);    });  }}co(function *(){  var results = yield *foo();  console.log(results);  return results;})(function (args){  console.log(args);//13});

这时只会返回第一个异步操作的结果。因为co规定了回调只允许传入前面说的那两个参数。如果异步操作的结果是多个值。

function size(file) {  return function(fn){    fs.stat(file, function(err, stat){      if (err) return fn(err);      fn(null,stat.size,stat.atime);    });  }}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;})(function (err,args){  console.log(args);});

可以看到结果是被添加到一个数组里面。