异步编程之co——源码分析

异步编程系列教程:

  1. (翻译)异步编程之Promise(1)——初见魅力
  2. 异步编程之Promise(2):探究原理
  3. 异步编程之Promise(3):拓展进阶
  4. 异步编程之Generator(1)——领略魅力
  5. 异步编程之Generator(2)——剖析特性
  6. 异步编程之co——源码分析

如何使用co


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

1
2
3
4
5
6
// 注意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行,不能再精简!我们抽出其中主要的代码来进行分析。

1
2
3
4
5
6
7
8
9
10
11
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从构造器变成了遍历器。 遍历器开始遍历

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

1
2
3
4
5
6
7
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参数有donevalue,那么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()指令,必定是放在了那两个回调函数(onFulfilledonRejected)里。

自动运行

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

1
2
3
4
5
6
7
8
9
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),再次启动遍历器得到新的遍历结果,再传入conext()里,重复之前的操作,达到自动运行的效果。这里需要注意一个地方,我们是通过向遍历器的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对象。它的源码就是这样的,并不能看到实质的东西:

1
2
3
4
5
6
7
8
9
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;
}

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

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

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

数组Array

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

1
2
3
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的好处就是,异步操作的名字和值是可以对应起来的,来看看代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
2
3
4
5
6
7
8
9
10
//读取文件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()就是帮你解决这个问题的。

1
2
3
4
5
6
7
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)。这样子就无论是复用性还是代码结构都是优化了不少。

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

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

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