Generator：JS执行权的真实操作者

摘要：执行权由此单向稳定的在不同函数中切换。调用函数后，引擎会为其开辟一个独立的函数执行栈以下简称栈。执行权再次回到外部。成功执行完函数，则改变的状态为成功。执行函数返回的遍历器对象会继承函数的原型对象。遇到下一个断点，交出执行权传出返回值。

ES6提供了一种新型的异步编程解决方案：Generator函数（以下简称G函数）。它不是使用JS现有能力按照一定标准制定出来的东西（Promise是如此出生的），而是具有新型底层操作能力，与传统编程完全不同，代表一种新编程逻辑的高大存在。简洁方便、受人喜爱的async函数就是以它为基础实现的。

JS引擎是单线程的，只有一个函数执行栈。
当当前函数执行完后，执行栈将其弹出，销毁包含其局部变量的栈空间，并开始执行前一个函数。执行权由此单向稳定的在不同函数中切换。虽然Web Worker的出现使我们能够自行创建多个线程，但这离灵活的控制：暂停执行、切换执行权和中间的数据交换等等，还是很有距离的。

G函数的意义在于，它可以在单线程的背景下，使执行权与数据自由的游走于多个执行栈之间，实现协程式编程。
调用G函数后，引擎会为其开辟一个独立的函数执行栈（以下简称G栈）。在执行它的过程中，可以控制暂停执行，并将执行权转出给主执行栈或另一个G栈（栈在这里可理解为函数）。而此G栈不会被销毁而是被冻结，当执行权再次回来时，会在与上次退出时完全相同的条件下继续执行。

下面是一个简单的交出和再次获得执行权的例子。

// 依次打印出：1 2 3 4 5。

let g = G();

console.log("1"); // 执行权在外部。
g.next(); // 开始执行G函数，遇到 yield 命令后停止执行返回执行权。
console.log("3"); // 执行权再次回到外部。
g.next(); // 再次进入到G函数中，从上次停止的地方开始执行，到最后自动返回执行权。
console.log("5");

function* G() {
  let n = 4;
  console.log("2");
  yield; // 遇到此命令，会暂停执行并返回执行权。
  console.log(n);
}

G函数也是函数，所以具有普通函数该有的性质，不过形式上有两点不同。一是在function关键字和函数名之间有一个*号，表示此为G函数。二是只有在G函数里才能使用yield命令（以及yield*命令），处于其内部的非G函数也不行。由于箭头函数不能使用yield命令，因此不能用作于Generator函数（可以用作于async函数）。

以下是它的几种定义方式。

// 声明式
function* G() {}

// 表达式
let G = function* () {};

// 作为对象属性
let o = {
  G: function* () {}
};

// 作为对象属性的简写式
let o = {
  * G() {}
};

// 箭头函数不能用作G函数，报错！
let o = {
  G: *() => {}
};

// 箭头函数可以用作 async 函数。
let o = {
  G: async () => {}
};

调用普通函数会直接执行函数体中的代码，之后返回函数的返回值。但G函数不同，执行它会返回一个遍历器对象（此对象与数组中的遍历器对象相同），不会执行函数体内的代码。只有当调用它的next方法（也可能是其它实例方法）时，才开始了真正执行。

在G函数的执行过程中，碰到yield或return命令时会停止执行并将执行权返回。当然，执行到此函数末尾时自然会返回执行权。每次返回执行权之后再次调用它的next方法（也可能是其它实例方法），会重新获得执行权，并从上次停止的地方继续执行，直到下一个停止点或结束。

// 示例一
let g = G();
g.next(); // 打印出 1
g.next(); // 打印出 2
g.next(); // 打印出 3

function* G() {
  console.log(1);
  yield;
  console.log(2);
  yield;
  console.log(3);
}

// 示例二
let gg = GG();

gg.next(); // 打印出 1
gg.next(); // 打印出 2
gg.next(); // 没有打印

function* GG() {
  console.log(1);
  yield;
  console.log(2);
  return;
  yield;
  console.log(3);
}

数据如果不能在执行权的更替中取得交互，其存在的意义就会大打折扣。

G函数的数据输出和输入是通过yield命令和next方法实现的。
yield和return一样，后面可以跟上任意数据，程序执行到此会交出控制权并返回其后的跟随值（没有则为undefined），作为数据的输出。每次调用next方法将控制权移交给G函数时，可以传入任意数据，该数据会等同替换G函数内部相应的yield xxx表达式，作为数据的输入。

执行G函数，返回的是一个遍历器对象。每次调用它的next方法，会得到一个具有value和done字段的对象。value存储了移出控制权时输出的数据（即yield或return后的跟随值），done为布尔值代表该G函数是否已经完成执行。作为遍历器对象的它具有和数组遍历器相同的其它性质。

// n1 的 value 为 10，a 和 n2 的 value 为 100。
let g = G(10);

let n1 = g.next(); // 得到 n 值。
let n2 = g.next(100); // 相当将 yield n 替换成 100。

function* G(n) {
  let a = yield n; // let a = 100;
  console.log(a); // 100
  return a;
}

实际上，G函数是实现遍历器接口最简单的途径，不过有两点需要注意。一是G函数中的return语句，虽然通过遍历器对象可以获得return后面的返回值，但此时done属性已为true，通过for of循环是遍历不到的。二是G函数可以写成为永动机的形式，类似服务器监听并执行请求，这时通过for of遍历是没有尽头的。

--- 示例一：return 返回值。
let g1 = G();
console.log( g1.next() ); // value: 1, done: false
console.log( g1.next() ); // value: 2, done: true
console.log( g1.next() ); // value: undefined, done: true

let g2 = G();
for (let v of g2) {
  console.log(v); // 只打印出 1。
}

function* G() {
  yield 1;
  return 2;
}

--- 示例二：作为遍历器接口。
let o = {
  id: 1,
  name: 2,
  ago: 3,
  *[Symbol.iterator]() {
    let arr = Object.keys(this);
    for (let v of arr) {
      yield this[v]; // 使用 yield 输出。
    }
  }
}

for (let v of o) {
  console.log(v); // 依次打印出：1 2 3。
}

--- 示例三：永动机。
let g = G();
g.next(); // 打印出： Do ... 。
g.next(); // 打印出： Do ... 。
// ... 可以无穷次调用。

// 可以尝试此例子，虽然页面会崩溃。
// 崩溃之后可以点击关闭页面，或终止浏览器进程，或辱骂作者。
for (let v of G()) {
  console.log(v);
}

function* G() {
  while (true) {
    console.log("Do ...");
    yield;
  }
}

yield*命令的基本原理是自动遍历并用yield命令输出拥有遍历器接口的对象，怪绕口的，直接看示例吧。

// G2 与 G22 函数等价。

for (let v of G1()) {
  console.log(v); // 打印出：1 [2, 3] 4。
}
for (let v of G2()) {
  console.log(v); // 打印出：1 2 3 4。
}
for (let v of G22()) {
  console.log(v); // 打印出：1 2 3 4。
}

function* G1() {
  yield 1;
  yield [2, 3];
  yield 4;
}

function* G2() {
  yield 1;
  yield* [2, 3]; // 使用 yield* 自动遍历。
  yield 4;
}

function* G22() {
  yield 1;
  for (let v of [2, 3]) { // 等价于 yield* 命令。
    yield v;
  }
  yield 4;
}

在G函数中直接调用另一个G函数，与在外部调用没什么区别，即便前面加上yield命令。但如果使用yield*命令就能直接整合子G函数到父函数中，十分方便。因为G函数返回的就是一个遍历器对象，而yield*可以自动展开持有遍历器接口的对象，并用yield输出。如此就等价于将子G函数的函数体原原本本的复制到父G函数中。

// G1 与 G2 等价。

for (let v of G1()) {
  console.log(v); // 依次打印出：1 2 "-" 3 4
}
for (let v of G2()) {
  console.log(v); // 依次打印出：1 2 "-" 3 4
}

function* G1() {
  yield 1;
  yield* GG();
  yield 4;
}

function* G2() {
  yield 1;
  yield 2;
  console.log("-");
  yield 3;
  yield 4;
}

function* GG() {
  yield 2;
  console.log("-");
  yield 3;
}

唯一需要注意的是子G函数中的return语句。yield*虽然与for of一样不会遍历到该值，但其能直接返回该值。

let g = G();

console.log( g.next().value ); // 1
console.log( g.next().value ); // undefined, 打印出 return 2。

function* G() {
  let n = yield* GG(); // 第二次执行 next 方法时，这里等价于 let n = 2; 。
  console.log("return", n);
}

function* GG() {
  yield 1;
  return 2;
}

历经了如此多的铺垫，是到将其应用到异步的时候了，来来来，喝了这坛酒咱就到马路上碰个瓷试试运气。
使用G函数处理异步的优势，相对于在这以前最优秀的Promise来说，在于形式上使主逻辑代码更为的精简和清晰，使其看起来与同步代码基本相同。虽然在日常生活中，我们说谁谁做事爱搞形式多少包含有贬低意味。但在这程序的世界，对于我们编写和他人阅读来说，这些改进的效益可是相当可观哦。

// 模拟请求数据。
// 依次打印出 get api1, Do ..., get api2, Do ..., 最终值：3000 。

// 请求数据的主逻辑块
function* G() {
  let api1 = yield createPromise(1000); // 发送第一个数据请求，返回的是该 Promise 。
  console.log("get api1", api1); // 得到数据。
  console.log("Do somethings with api1"); // 做些操作。
  
  let api2 = yield createPromise(2000); // 发送第二个数据请求，返回的是该 Promise 。
  console.log("get api2", api2); // 得到数据。
  console.log("Do somethings with api2"); // 做些操作。
  
  return api1 + api2;
}

// 开始执行G函数。
let g = G();
// 得到第一个 Promise 并等待其返回数据
g.next().value.then(res => {
  // 获取到第一个请求的数据。
  return g.next(res).value; // 将第一个数据传回，并获取到第二个 Promise 。
}).then(res => {
  // 获取到第二个请求的数据。
  return g.next(res).value; // 将第二个数据传回。
}).then(res => {
  console.log("最终值：", res);
});

// 模拟请求数据
function createPromise(time) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(time);
    }, time);
  });
}

上面的方式有很大的优化空间。我们执行函数时的逻辑是：先获取到异步请求并等待其返回结果，再将结果传递回G函数，之后重复操作。而按照此方式，意味着G函数中有多少异步请求，我们就应该重复多少次该操作。如果观众老爷们足够敏感，此时就能想到这些步奏是能抽象成一个函数的。而抽象出来的这个函数就是G函数的自执行器。

以下是一个简易的自执行器，它会返回一个Promise。再往内是通过递归一步步的执行G函数，对其返回的结果都统一使用resolve方法包装成Promise对象。

// 与上一个示例等价。
RunG(G).then(res => {
  console.log("G函数执行结束：", res); // 3000
});

function* G() {
  let api1 = yield createPromise(1000);
  console.log("get api1", api1);
  console.log("Do somethings with api1");
  
  let api2 = yield createPromise(2000);
  console.log("get api2", api2);
  console.log("Do somethings with api2");
  
  return api1 + api2;
}

function RunG(G) {
  // 返回 Promise 对象。
  return new Promise((resolve, reject) => {
    let g = G();

    next();

    function next(data) {
      let r = g.next(data);

      // 成功执行完G函数，则改变 Promise 的状态为成功。
      if (r.done) return resolve(r.value);

      // 将每次的返回值统一包装成 Promise 对象。
      // 成功则继续执行G函数，否则改变 Promise 的状态为失败。
      Promise.resolve(r.value).then(next).catch(reject);
    }
  });
}

function createPromise(time) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(time);
    }, time);
  });
}

自执行器可以自动执行任意的G函数，是应用于异步时必要的咖啡伴侣。上面是接地气的写法，我们来看看较为官方的版本。可以直观的感受到，两者主要的区别在对可能错误的捕获和处理上，这也是平常写的代码和构建底层库主要的区别之一。

function spawn(genF) {
  return new Promise(function(resolve, reject) {
    const gen = genF();
    function step(nextF) {
      let next;
      try {
        next = nextF();
      } catch(e) {
        return reject(e);
      }
      if(next.done) {
        return resolve(next.value);
      }
      Promise.resolve(next.value).then(function(v) {
        step(function() { return gen.next(v); });
      }, function(e) {
        step(function() { return gen.throw(e); });
      });
    }
    step(function() { return gen.next(undefined); });
  });
}

实例方法比如next以及接下来的throw和return，实际是存在G函数的原型对象中。执行G函数返回的遍历器对象会继承G函数的原型对象。在此添加自定义方法也可以被继承。这使得G函数看起来类似构造函数，但实际两者不相同。因为G函数本就不是构造函数，不能被new，内部的this也不能被继承。

function* G() {
  this.id = 123;
}
G.prototype.sayName = () => {
  console.log("Wmaker");
};

let g = G();
g.id; // undefined
g.sayName(); // "Wmaker"

实例方法throw和next方法的性质基本相同，区别在于其是向G函数体内传递错误而不是值。通俗的表达是将yield xxx表达式替换成throw 传入的参数。其它比如会接着执行到下一个断点，返回一个对象等等，和next方法一致。该方法使得异常处理更为简单，而且多个yield表达式可以只用一个try catch代码块捕获。

当通过throw方法或G函数在执行中自己抛出错误时。如果此代码正好被try catch块包裹，便会像公园里行完方便的宠物一样，没事的继续往下执行。遇到下一个断点，交出执行权传出返回值。如果没有错误捕获，JS会终止执行并认为函数已经结束运行，此后再调用next方法会一直返回value为undefined、done为true的对象。

// 依次打印出：1, Error: 2, 3。
let g = G();

console.log( g.next().value ); // 1
console.log( g.throw(2).value ); // 3，打印出 Error: 2。

function* G() {
  try {
    yield 1;
  } catch(e) {
    console.log("Error:", e);
  }
  yield 3;
}

// 使用了 throw(2) 等价于使用 next() 并将代码改写成如下所示。

function* G() {
  try {
    yield 1;
    throw 2; // 替换原来的 yield 表达式，相当在后面添加。
  } catch(e) {
    console.log("Error:", e);
  }
  yield 3;
}

实例方法return和throw的情况相同，与next具有相似的性质。区别在于其会直接终止G函数的执行并返回传入的参数。通俗的表达是将yield xxx表达式替换成return 传入的参数。值得注意的是，如果此时正好处于try代码块中，且其带有finally模块，那么return方法会推迟到finally代码块执行完后再执行。

let g = G();

console.log( g.next().value ); // 1
console.log( g.return(4).value ); // 2
console.log( g.next().value ); // 3
console.log( g.next().value ); // 4，G函数结束。
console.log( g.next().value ); // undefined

function* G() {
  try {
    yield 1;
  } finally {
    yield 2;
    yield 3;
  }
  yield 5;
}

// 使用了 return(4) 等价于使用 next() 并将代码改写成如下所示。

function* GG() {
  try {
    yield 1;
    return 4; // 替换原来的 yield 表达式，相当在后面添加。
  } finally {
    yield 2;
    yield 3;
  }
  
  yield 5;
}

ES6精华：Symbol
ES6精华：Promise
Iterator：访问数据集合的统一接口