前言

讲真为了写出更优雅、更易维护的代码，为了解决异步的嵌套问题，真是操碎了心，先是出了个 Promise，然后又是 Generator、yield 组合，直到 ES7 的 async、await 组合。好在事情一直在向好的方向反正。

Generator

生成器对象是由 function* 返回的，并且符合可迭代协议和迭代器协议。
这里有几个概念生成器、可迭代协议、迭代器协议。具体的概念可以点击链接查看 MDN 文档。

function*: 定义一个生成器函数，返回一个 Generator 对象；
可迭代协议： 允许 JavaScript 对象去定义或定制它们的迭代行为；
迭代器协议： 定义了一种标准的方式来产生一个有限或无限序列的值；当一个对象被认为是一个迭代器时，它实现了一个 next() 的方法，next()返回值如下：

{
    "done": true, //false迭代是否结束，
    "value": v //迭代器返回值
}

从这几个基本的概念我们可以了解到，生成器是对象是可以迭代的，那么为什么要可以迭代、可以迭代解决了什么问题。

迭代

下面定义一个简单的迭代生成函数，传入一个数组，则返回一个可以迭代的对象

// 1. 迭代器

let iterator = (items) => {
  let iter = {
    index: 0,
    max: items.length,
    next: function () {
      // 返回调用结果
      return this.index === this.max
        ? { value: undefined, done: true }
        : { value: items[this.index++], done: false };
    },
  };

  return iter;
};

export default iterator;

调用上面的迭代器，并执行

let iter = iterator([1, 2, 3, 4]);
let result = null;
console.log("--------generator----------");
do {
  result = iter.next();
  console.log(result);
} while (!result.done);

运行结果如下：

--------generator----------
{ value: 1, done: false }
{ value: 2, done: false }
{ value: 3, done: false }
{ value: 4, done: false }
{ value: undefined, done: true }

可以看到，迭代器每次调用 next()方法，都会返回{value:xx,done:xx}结构的对象，这个就是迭代器协议中 next()方法需要遵循的规则，前面说过 generator 函数也是遵循迭代器协议的，下面用 generator 实现此功能。

generator 的使用

// generator
function* generator(items) {
  let index = 0;
  let max = items.length;

  while (index < max) {
    yield items[index++];
  }
}

let gene = generator([1, 2, 3, 4]);
result = null;
console.log("--------generator----------");
do {
  result = gene.next();
  console.log(result);
} while (!result.done);

此时运行结果如下：

--------generator----------
{ value: 1, done: false }
{ value: 2, done: false }
{ value: 3, done: false }
{ value: 4, done: false }
{ value: undefined, done: true }

对比两次运行的结果，得出一个结论：生成器(function*)函数，运行时，返回的是一个生成器对象，这个生成器对象是可以迭代(gene.next())的，并且 next()的返回值包含 value，done 两个字段。

进化

生成器是可以迭代的，而且返回值也是符合一定结构的，我们每次再使用生成器的时候，都要用循环去执行，直到返回的 done 为 true，为了简化操作需要把这个循环操作进行封装，下面封装一个简单的 run 函数，run 可以执行迭代器，一直到完成任务。

let tick = (duration) => {
  return new Promise((resolve) => {
    setTimeout(function () {
      console.log(duration, new Date());
      resolve(duration);
    }, duration);
  });
};

function* generator() {
  var result = yield tick(2000);
  console.log("result = ", result);
  result = yield tick(4000);
  console.log("result = ", result);
  result = yield tick(3000);
  console.log("result = ", result);
}

let run = (generator, res) => {
  var result = generator.next(res);
  if (result.done) return;
  result.value.then((res) => {
    run(generator, res);
  });
};

run(generator());

以上的运行结果：

2000 2019-09-13T08:43:41.775Z
result =  2000
4000 2019-09-13T08:43:45.780Z
result =  4000
3000 2019-09-13T08:43:48.783Z
result =  3000

看一下 run 的实现，像极了前面的 do...while... 循环，只是做了一个简单的封装，以后就没用每次都手写循环来执行生成器函数了，实际上有一个封装好的库可以使用它叫co

co 库执行 generator

安装 co

npm install --save co

使用

import co from "co";
co(generator);

它的作用跟上面实现的 run 方法的作用是一样的，都是执行 generator，并返回结果。这样生成器大概就可以理解了，说白了生成器就是可以返回一个可迭代的对象，这个对象不是通过 return 返回的，而是通过 yield，并且可以实现异步函数的同步调用，我们看上图的时间，虽然 tick 是异步的，但是打印的结果却是顺序执行的。

async/await

generator 可以简化异步的编码，减少嵌套，而 async、await 组合起来使用，可以更进一步，类似以上的代码，使用 async、await 改写如下

let tick = (duration) => {
  return new Promise((resolve) => {
    setTimeout(function () {
      console.log(new Date());
      resolve(duration);
    }, duration);
  });
};

async function asyncFunc() {
  var result = await tick(1000);
  console.log(result);
  result = await tick(2000);
  console.log(result);
  result = await tick(3000);
  console.log(result);
}

asyncFunc();

执行结果

2019-09-13T08:48:23.449Z
1000
2019-09-13T08:48:25.454Z
2000
2019-09-13T08:48:28.457Z
3000

虽然实现的功能是一样的，但是从代码的结构上又简化了一层。本质上来说，async/await 使用 promise 来实现一个 generator 自执行器。在 babel 中，大体的原理也是类似的。

引用

koa-step-by-step
迭代协议