ES6之Generator 函数的异步应用

• 回调函数

• 事件监听

• 发布/订阅

• Promise 对象

基本概念

Generator 函数

协程

• 第一步，协程 A 开始执行。

• 第二步，协程 A 执行到一半，进入暂停，执行权转移到协程 B。

• 第三步，（一段时间后）协程 B 交还执行权。

• 第四步，协程 A 恢复执行。

function* asyncJob() {  // ...其他代码  var f = yield readFile(fileA);  // ...其他代码}

协程的 Generator 函数实现

Generator 函数的数据交换和错误处理

• next 返回值的 value 属性，是 Generator 函数向外输出数据；next 方法还可以接受参数，向 Generator 函数体内输入数据。

• Generator 函数内部还可以部署错误处理代码，捕获函数体外抛出的错误。

异步任务的封装

var fetch = require('node-fetch');function* gen(){  var url = 'https://api.github.com/users/github';  var result = yield fetch(url);  console.log(result.bio);}var g = gen();var result = g.next();result.value.then(function(data){  return data.json();}).then(function(data){  g.next(data);});

Thunk 函数

• 传值调用：call by value，即在进入函数体之前，就计算实参的值，再将这个值传入函数。C 语言就采用这种策略。

• 传名调用：call by name，即在将实参的表达式传入函数体，只在用到它的时候求值。Haskell 语言采用这种策略。

function f(m) {  return m * 2;}f(x + 5);// 等同于var thunk = function () {  return x + 5;};function f(thunk) {  return thunk() * 2;}

// 正常版本的readFile（多参数版本）fs.readFile(fileName, callback);// Thunk版本的readFile（单参数版本）var Thunk = function (fileName) {  return function (callback) {    return fs.readFile(fileName, callback);  };};var readFileThunk = Thunk(fileName);readFileThunk(callback);

// ES5版本var Thunk = function(fn){  return function (){    var args = Array.prototype.slice.call(arguments);    return function (callback){      args.push(callback);      return fn.apply(this, args);    }  };};// ES6版本const Thunk = function(fn) {  return function (...args) {    return function (callback) {      return fn.call(this, ...args, callback);    }  };};

Generator 函数的流程管理

function* gen() {  // ...}var g = gen();var res = g.next();while(!res.done){  console.log(res.value);  res = g.next();}

var fs = require('fs');var thunkify = require('thunkify');var readFileThunk = thunkify(fs.readFile);var gen = function* (){  var r1 = yield readFileThunk('/etc/fstab');  console.log(r1.toString());  var r2 = yield readFileThunk('/etc/shells');  console.log(r2.toString());};

Thunk 函数的自动流程管理

function run(fn) {  var gen = fn();  function next(err, data) {    var result = gen.next(data);    if (result.done) return;    result.value(next);  }  next();}function* g() {  // ...}run(g);

var g = function* (){  var f1 = yield readFileThunk('fileA');  var f2 = yield readFileThunk('fileB');  // ...  var fn = yield readFileThunk('fileN');};run(g);

co 模块

var gen = function* () {  var f1 = yield readFile('/etc/fstab');  var f2 = yield readFile('/etc/shells');  console.log(f1.toString());  console.log(f2.toString());};var co = require('co');co(gen).then(function (){  console.log('Generator 函数执行完成');});

co 模块的原理

co 模块的源码

• 首先，co 函数接受 Generator 函数作为参数，返回一个 Promise 对象。

• 接着，co 将 Generator 函数的内部指针对象的 next 方法，包装成 onFulfilled 函数。这主要是为了能够捕捉抛出的错误。

• 最后，就是关键的 next 函数，它会反复调用自身。

处理并发的异步操作

// 数组的写法co(function* () {  var res = yield [    Promise.resolve(1),    Promise.resolve(2)  ];  console.log(res);}).catch(onerror);// 对象的写法co(function* () {  var res = yield {    1: Promise.resolve(1),    2: Promise.resolve(2),  };  console.log(res);}).catch(onerror);// 另一个例子co(function* () {  var values = [n1, n2, n3];  yield values.map(somethingAsync);});function* somethingAsync(x) {  // do something async  return y}