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了。
