ES6学习笔记(十五)Generator函数的异步应用
1.传统方法
ES6 诞生以前,异步编程的方法,大概有下面四种。
- 回调函数
- 事件监听
- 发布/订阅
- Promise 对象
Generator 函数将 JavaScript 异步编程带入了一个全新的阶段。
2.基本概念
异步
所谓"异步",简单说就是一个任务不是连续完成的,可以理解成该任务被人为分成两段,先执行第一段,然后转而执行其他任务,等做好了准备,再回过头执行第二段。
比如,有一个任务是读取文件进行处理,任务的第一段是向操作系统发出请求,要求读取文件。然后,程序执行其他任务,等到操作系统返回文件,再接着执行任务的第二段(处理文件)。这种不连续的执行,就叫做异步。
相应地,连续的执行就叫做同步。由于是连续执行,不能插入其他任务,所以操作系统从硬盘读取文件的这段时间,程序只能干等着。
回调函数
JavaScript 语言对异步编程的实现,就是回调函数。所谓回调函数,就是把任务的第二段单独写在一个函数里面,等到重新执行这个任务的时候,就直接调用这个函数。回调函数的英语名字callback
,直译过来就是"重新调用"。
最典型的回调,读取文件进行处理,是这样写的。
fs.readFile('/etc/passwd', 'utf-8', function (err, data) { if (err) throw err; console.log(data); });
上面代码中,readFile
函数的第三个参数,就是回调函数,也就是任务的第二段。等到操作系统返回了/etc/passwd
这个文件以后,回调函数才会执行。
一个有趣的问题是,为什么 Node 约定,回调函数的第一个参数,必须是错误对象err
(如果没有错误,该参数就是null
)?
原因是执行分成两段,第一段执行完以后,任务所在的上下文环境就已经结束了。在这以后抛出的错误,原来的上下文环境已经无法捕捉,只能当作参数,传入第二段。
Promise
回调函数本身并没有问题,它的问题出现在多个回调函数嵌套。假定读取A
文件之后,再读取B
文件,代码如下。
fs.readFile(fileA, 'utf-8', function (err, data) { fs.readFile(fileB, 'utf-8', function (err, data) { // ... }); });
不难想象,如果依次读取两个以上的文件,就会出现多重嵌套。代码不是纵向发展,而是横向发展,很快就会乱成一团,无法管理。因为多个异步操作形成了强耦合,只要有一个操作需要修改,它的上层回调函数和下层回调函数,可能都要跟着修改。这种情况就称为"回调函数地狱"(callback hell)。
Promise 对象就是为了解决这个问题而提出的。它不是新的语法功能,而是一种新的写法,允许将回调函数的嵌套,改成链式调用。采用 Promise,连续读取多个文件,写法如下。
1 var readFile = require('fs-readfile-promise'); 2 3 readFile(fileA) 4 .then(function (data) { 5 console.log(data.toString()); 6 }) 7 .then(function () { 8 return readFile(fileB); 9 }) 10 .then(function (data) { 11 console.log(data.toString()); 12 }) 13 .catch(function (err) { 14 console.log(err); 15 });
上面代码中,我使用了fs-readfile-promise
模块,它的作用就是返回一个 Promise 版本的readFile
函数。Promise 提供then
方法加载回调函数,catch
方法捕捉执行过程中抛出的错误。
可以看到,Promise 的写法只是回调函数的改进,使用then
方法以后,异步任务的两段执行看得更清楚了,除此以外,并无新意。
Promise 的最大问题是代码冗余,原来的任务被 Promise 包装了一下,不管什么操作,一眼看去都是一堆then
,原来的语义变得很不清楚。
那么,有没有更好的写法呢?那就是最新的async/await语法,比Generator更加简单,号称异步的终极解决方案。
3.Generator 函数
协程
传统的编程语言,早有异步编程的解决方案(其实是多任务的解决方案)。其中有一种叫做"协程"(coroutine),意思是多个线程互相协作,完成异步任务。
协程有点像函数,又有点像线程。它的运行流程大致如下。
- 第一步,协程
A
开始执行。 - 第二步,协程
A
执行到一半,进入暂停,执行权转移到协程B
。 - 第三步,(一段时间后)协程
B
交还执行权。 - 第四步,协程
A
恢复执行。
上面流程的协程A
,就是异步任务,因为它分成两段(或多段)执行。
举例来说,读取文件的协程写法如下。
function* asyncJob() { // ...其他代码 var f = yield readFile(fileA); // ...其他代码 }
上面代码的函数asyncJob
是一个协程,它的奥妙就在其中的yield
命令。它表示执行到此处,执行权将交给其他协程。也就是说,yield
命令是异步两个阶段的分界线。
协程遇到yield
命令就暂停,等到执行权返回,再从暂停的地方继续往后执行。它的最大优点,就是代码的写法非常像同步操作,如果去除yield
命令,简直一模一样。
协程的 Generator 函数实现
Generator 函数是协程在 ES6 的实现,最大特点就是可以交出函数的执行权(即暂停执行)。
整个 Generator 函数就是一个封装的异步任务,或者说是异步任务的容器。异步操作需要暂停的地方,都用yield
语句注明。Generator 函数的执行方法如下。
function* gen(x) { var y = yield x + 2; return y; } var g = gen(1); g.next() // { value: 3, done: false } g.next() // { value: undefined, done: true }
上面代码中,调用 Generator 函数,会返回一个内部指针(即遍历器)g
。这是 Generator 函数不同于普通函数的另一个地方,即执行它不会返回结果,返回的是指针对象。
调用指针g
的next
方法,会移动内部指针(即执行异步任务的第一段),指向第一个遇到的yield
语句,上例是执行到x + 2
为止。
换言之,next
方法的作用是分阶段执行Generator
函数。每次调用next
方法,会返回一个对象,表示当前阶段的信息(value
属性和done
属性)。value
属性是yield
语句后面表达式的值,表示当前阶段的值;done
属性是一个布尔值,表示 Generator 函数是否执行完毕,即是否还有下一个阶段。
Generator 函数的数据交换和错误处理
Generator 函数可以暂停执行和恢复执行,这是它能封装异步任务的根本原因。除此之外,它还有两个特性,使它可以作为异步编程的完整解决方案:函数体内外的数据交换和错误处理机制。
next
返回值的 value 属性,是 Generator 函数向外输出数据;next
方法还可以接受参数,向 Generator 函数体内输入数据。
function* gen(x){ var y = yield x + 2; return y; } var g = gen(1); g.next() // { value: 3, done: false } g.next(2) // { value: 2, done: true }
Generator 函数内部还可以部署错误处理代码,捕获函数体外抛出的错误。
1 function* gen(x){ 2 try { 3 var y = yield x + 2; 4 } catch (e){ 5 console.log(e); 6 } 7 return y; 8 } 9 10 var g = gen(1); 11 g.next(); 12 g.throw('出错了'); 13 // 出错了
上面代码的最后一行,Generator 函数体外,使用指针对象的throw
方法抛出的错误,可以被函数体内的try...catch
代码块捕获。这意味着,出错的代码与处理错误的代码,实现了时间和空间上的分离,这对于异步编程无疑是很重要的。
异步任务的封装
var fetch = require('node-fetch'); function* gen(){ var url = 'https://api.github.com/users/github'; var result = yield fetch(url); console.log(result.bio); }
上面代码中,Generator 函数封装了一个异步操作,该操作先读取一个远程接口,然后从 JSON 格式的数据解析信息。就像前面说过的,这段代码非常像同步操作,除了加上了yield
命令。
执行这段代码的方法如下。
var g = gen(); var result = g.next(); result.value.then(function(data){ return data.json(); }).then(function(data){ g.next(data); });
上面代码中,首先执行 Generator 函数,获取遍历器对象,然后使用next
方法(第二行),执行异步任务的第一阶段。由于Fetch
模块返回的是一个 Promise 对象,因此要用then
方法调用下一个next
方法。
可以看到,虽然 Generator 函数将异步操作表示得很简洁,但是流程管理却不方便(即何时执行第一阶段、何时执行第二阶段)。
4.Thunk 函数
Thunk 函数是自动执行 Generator 函数的一种方法。也就是说不用每次调next()了?
参数的求值策略
Thunk 函数早在上个世纪 60 年代就诞生了。
那时,编程语言刚刚起步,计算机学家还在研究,编译器怎么写比较好。一个争论的焦点是"求值策略",即函数的参数到底应该何时求值。
var x = 1; function f(m) { return m * 2; } f(x + 5)
上面代码先定义函数f
,然后向它传入表达式x + 5
。请问,这个表达式应该何时求值?
一种意见是"传值调用"(call by value),即在进入函数体之前,就计算x + 5
的值(等于 6),再将这个值传入函数f
。C 语言就采用这种策略。
f(x + 5) // 传值调用时,等同于 f(6)
另一种意见是“传名调用”(call by name),即直接将表达式x + 5
传入函数体,只在用到它的时候求值。Haskell 语言采用这种策略。
f(x + 5) // 传名调用时,等同于 (x + 5) * 2
传值调用和传名调用,哪一种比较好?
回答是各有利弊。传值调用比较简单,但是对参数求值的时候,实际上还没用到这个参数,有可能造成性能损失。假如根本用不到这个参数,岂不是白求值了。
function f(a, b){ return b; } f(3 * x * x - 2 * x - 1, x);
上面代码中,函数f
的第一个参数是一个复杂的表达式,但是函数体内根本没用到。对这个参数求值,实际上是不必要的。因此,有一些计算机学家倾向于"传名调用",即只在执行时求值。
JavaScript是传值调用。
Thunk 函数的含义
编译器的“传名调用”实现,往往是将参数放到一个临时函数之中,再将这个临时函数传入函数体。这个临时函数就叫做 Thunk 函数。
1 function f(m) { 2 return m * 2; 3 } 4 5 f(x + 5); 6 7 // 等同于 8 9 var thunk = function () { 10 return x + 5; 11 }; 12 13 function f(thunk) { 14 return thunk() * 2; 15 }
上面代码中,函数 f 的参数x + 5
被一个函数替换了。凡是用到原参数的地方,对Thunk
函数求值即可。
这就是 Thunk 函数的定义,它是“传名调用”的一种实现策略,用来替换某个表达式。
JavaScript 语言的 Thunk 函数
JavaScript 语言是传值调用,它的 Thunk 函数含义有所不同。在 JavaScript 语言中,Thunk 函数替换的不是表达式,而是多参数函数,将其替换成一个只接受回调函数作为参数的单参数函数。
1 // 正常版本的readFile(多参数版本) 2 fs.readFile(fileName, callback); 3 4 // Thunk版本的readFile(单参数版本) 5 var Thunk = function (fileName) { 6 return function (callback) { 7 return fs.readFile(fileName, callback); 8 }; 9 }; 10 11 var readFileThunk = Thunk(fileName); 12 readFileThunk(callback);
上面代码中,fs
模块的readFile
方法是一个多参数函数,两个参数分别为文件名和回调函数。经过转换器处理,它变成了一个单参数函数,只接受回调函数作为参数。这个单参数版本,就叫做 Thunk 函数。
任何函数,只要参数有回调函数,就能写成 Thunk 函数的形式。下面是一个简单的 Thunk 函数转换器。
1 // ES5版本 2 var Thunk = function(fn){ 3 return function (){ 4 var args = Array.prototype.slice.call(arguments); 5 return function (callback){ 6 args.push(callback); 7 return fn.apply(this, args); 8 } 9 }; 10 }; 11 12 // ES6版本 13 const Thunk = function(fn) { 14 return function (...args) { 15 return function (callback) { 16 return fn.call(this, ...args, callback); 17 } 18 }; 19 };
使用上面的转换器,生成fs.readFile
的 Thunk 函数。
var readFileThunk = Thunk(fs.readFile); readFileThunk(fileA)(callback);
下面是另一个完整的例子。
function f(a, cb) { cb(a); } const ft = Thunk(f); ft(1)(console.log) // 1
Generator 函数的流程管理
你可能会问, Thunk 函数有什么用?回答是以前确实没什么用,但是 ES6 有了 Generator 函数,Thunk 函数现在可以用于 Generator 函数的自动流程管理。
Generator 函数可以自动执行。
function* gen() { // ... } var g = gen(); var res = g.next(); while(!res.done){ console.log(res.value); res = g.next(); }
上面代码中,Generator 函数gen
会自动执行完所有步骤。
但是,这不适合异步操作。如果必须保证前一步执行完,才能执行后一步,上面的自动执行就不可行。这时,Thunk 函数就能派上用处。以读取文件为例。下面的 Generator 函数封装了两个异步操作。
1 var fs = require('fs'); 2 var thunkify = require('thunkify'); 3 var readFileThunk = thunkify(fs.readFile); 4 5 var gen = function* (){ 6 var r1 = yield readFileThunk('/etc/fstab'); 7 console.log(r1.toString()); 8 var r2 = yield readFileThunk('/etc/shells'); 9 console.log(r2.toString()); 10 };
上面代码中,yield
命令用于将程序的执行权移出 Generator 函数,那么就需要一种方法,将执行权再交还给 Generator 函数。
这种方法就是 Thunk 函数,因为它可以在回调函数里,将执行权交还给 Generator 函数。为了便于理解,我们先看如何手动执行上面这个 Generator 函数。
1 var g = gen(); 2 3 var r1 = g.next(); 4 r1.value(function (err, data) { 5 if (err) throw err; 6 var r2 = g.next(data); 7 r2.value(function (err, data) { 8 if (err) throw err; 9 g.next(data); 10 }); 11 });
上面代码中,变量g
是 Generator 函数的内部指针,表示目前执行到哪一步。next
方法负责将指针移动到下一步,并返回该步的信息(value
属性和done
属性)。
仔细查看上面的代码,可以发现 Generator 函数的执行过程,其实是将同一个回调函数,反复传入next
方法的value
属性。这使得我们可以用递归来自动完成这个过程。
Thunk 函数的自动流程管理
Thunk 函数真正的威力,在于可以自动执行 Generator 函数。下面就是一个基于 Thunk 函数的 Generator 执行器。
1 function run(fn) { 2 var gen = fn(); 3 4 function next(err, data) { 5 var result = gen.next(data); 6 if (result.done) return; 7 result.value(next); 8 } 9 10 next(); 11 } 12 13 function* g() { 14 // ... 15 } 16 17 run(g);
上面代码的run
函数,就是一个 Generator 函数的自动执行器。内部的next
函数就是 Thunk 的回调函数。next
函数先将指针移到 Generator 函数的下一步(gen.next
方法),然后判断 Generator 函数是否结束(result.done
属性),如果没结束,就将next
函数再传入 Thunk 函数(result.value
属性),否则就直接退出。
有了这个执行器,执行 Generator 函数方便多了。不管内部有多少个异步操作,直接把 Generator 函数传入run
函数即可。当然,前提是每一个异步操作,都要是 Thunk 函数,也就是说,跟在yield
命令后面的必须是 Thunk 函数。
var g = function* (){ var f1 = yield readFileThunk('fileA'); var f2 = yield readFileThunk('fileB'); // ... var fn = yield readFileThunk('fileN'); }; run(g);
上面代码中,函数g
封装了n
个异步的读取文件操作,只要执行run
函数,这些操作就会自动完成。这样一来,异步操作不仅可以写得像同步操作,而且一行代码就可以执行。
Thunk 函数并不是 Generator 函数自动执行的唯一方案。因为自动执行的关键是,必须有一种机制,自动控制 Generator 函数的流程,接收和交还程序的执行权。回调函数可以做到这一点,Promise 对象也可以做到这一点。
5.co 模块
co 模块是著名程序员 TJ Holowaychuk 于 2013 年 6 月发布的一个小工具,用于 Generator 函数的自动执行。
下面是一个 Generator 函数,用于依次读取两个文件。
var gen = function* () { var f1 = yield readFile('/etc/fstab'); var f2 = yield readFile('/etc/shells'); console.log(f1.toString()); console.log(f2.toString()); };
co 模块可以让你不用编写 Generator 函数的执行器。
var co = require('co'); co(gen);
上面代码中,Generator 函数只要传入co
函数,就会自动执行。
co
函数返回一个Promise
对象,因此可以用then
方法添加回调函数。
co(gen).then(function (){ console.log('Generator 函数执行完成'); });
co 模块的原理
co 模块其实就是将两种自动执行器(Thunk 函数和 Promise 对象),包装成一个模块。使用 co 的前提条件是,Generator 函数的yield
命令后面,只能是 Thunk 函数或 Promise 对象。如果数组或对象的成员,全部都是 Promise 对象,也可以使用 co,详见后文的例子。
基于 Promise 对象的自动执行
还是沿用上面的例子。首先,把fs
模块的readFile
方法包装成一个 Promise 对象。
1 var fs = require('fs'); 2 3 var readFile = function (fileName){ 4 return new Promise(function (resolve, reject){ 5 fs.readFile(fileName, function(error, data){ 6 if (error) return reject(error); 7 resolve(data); 8 }); 9 }); 10 }; 11 12 var gen = function* (){ 13 var f1 = yield readFile('/etc/fstab'); 14 var f2 = yield readFile('/etc/shells'); 15 console.log(f1.toString()); 16 console.log(f2.toString()); 17 };
然后,手动执行上面的 Generator 函数。
var g = gen(); g.next().value.then(function(data){ g.next(data).value.then(function(data){ g.next(data); }); });
手动执行其实就是用then
方法,层层添加回调函数。理解了这一点,就可以写出一个自动执行器。
1 function run(gen){ 2 var g = gen(); 3 4 function next(data){ 5 var result = g.next(data); 6 if (result.done) return result.value; 7 result.value.then(function(data){ 8 next(data); 9 }); 10 } 11 12 next(); 13 } 14 15 run(gen);
上面代码中,只要 Generator 函数还没执行到最后一步,next
函数就调用自身,以此实现自动执行。
co 模块的源码
co 就是上面那个自动执行器的扩展,它的源码只有几十行,非常简单。
首先,co 函数接受 Generator 函数作为参数,返回一个 Promise 对象。
function co(gen) { var ctx = this; return new Promise(function(resolve, reject) { }); }
在返回的 Promise 对象里面,co 先检查参数gen
是否为 Generator 函数。如果是,就执行该函数,得到一个内部指针对象;如果不是就返回,并将 Promise 对象的状态改为resolved
。
function co(gen) { var ctx = this; return new Promise(function(resolve, reject) { if (typeof gen === 'function') gen = gen.call(ctx); if (!gen || typeof gen.next !== 'function') return resolve(gen); }); }
接着,co 将 Generator 函数的内部指针对象的next
方法,包装成onFulfilled
函数。这主要是为了能够捕捉抛出的错误。
1 function co(gen) { 2 var ctx = this; 3 4 return new Promise(function(resolve, reject) { 5 if (typeof gen === 'function') gen = gen.call(ctx); 6 if (!gen || typeof gen.next !== 'function') return resolve(gen); 7 8 onFulfilled(); 9 function onFulfilled(res) { 10 var ret; 11 try { 12 ret = gen.next(res); 13 } catch (e) { 14 return reject(e); 15 } 16 next(ret); 17 } 18 }); 19 }
最后,就是关键的next
函数,它会反复调用自身。
1 function next(ret) { 2 if (ret.done) return resolve(ret.value); 3 var value = toPromise.call(ctx, ret.value); 4 if (value && isPromise(value)) return value.then(onFulfilled, onRejected); 5 return onRejected( 6 new TypeError( 7 'You may only yield a function, promise, generator, array, or object, ' 8 + 'but the following object was passed: "' 9 + String(ret.value) 10 + '"' 11 ) 12 ); 13 }
上面代码中,next
函数的内部代码,一共只有四行命令。
第一行,检查当前是否为 Generator 函数的最后一步,如果是就返回。
第二行,确保每一步的返回值,是 Promise 对象。
第三行,使用then
方法,为返回值加上回调函数,然后通过onFulfilled
函数再次调用next
函数。
第四行,在参数不符合要求的情况下(参数非 Thunk 函数和 Promise 对象),将 Promise 对象的状态改为rejected
,从而终止执行。
处理并发的异步操作
co 支持并发的异步操作,即允许某些操作同时进行,等到它们全部完成,才进行下一步,就像Promise.all();
这时,要把并发的操作都放在数组或对象里面,跟在yield
语句后面。
实例:处理 Stream
Node 提供 Stream 模式读写数据,特点是一次只处理数据的一部分,数据分成一块块依次处理,就好像“数据流”一样。这对于处理大规模数据非常有利。Stream 模式使用 EventEmitter API,会释放三个事件。
data
事件:下一块数据块已经准备好了。end
事件:整个“数据流”处理完了。error
事件:发生错误。
使用Promise.race()
函数,可以判断这三个事件之中哪一个最先发生,只有当data
事件最先发生时,才进入下一个数据块的处理。从而,我们可以通过一个while
循环,完成所有数据的读取。
1 const co = require('co'); 2 const fs = require('fs'); 3 4 const stream = fs.createReadStream('./les_miserables.txt'); 5 let valjeanCount = 0; 6 7 co(function*() { 8 while(true) { 9 const res = yield Promise.race([ 10 new Promise(resolve => stream.once('data', resolve)), 11 new Promise(resolve => stream.once('end', resolve)), 12 new Promise((resolve, reject) => stream.once('error', reject)) 13 ]); 14 if (!res) { 15 break; 16 } 17 stream.removeAllListeners('data'); 18 stream.removeAllListeners('end'); 19 stream.removeAllListeners('error'); 20 valjeanCount += (res.toString().match(/valjean/ig) || []).length; 21 } 22 console.log('count:', valjeanCount); // count: 1120 23 });
上面代码采用 Stream 模式读取《悲惨世界》的文本文件,对于每个数据块都使用stream.once
方法,在data
、end
、error
三个事件上添加一次性回调函数。变量res
只有在data
事件发生时才有值,然后累加每个数据块之中valjean
这个词出现的次数。
这一节还真是有点绕啊,先过一遍,待以后理解。。。