- 博客 github 地点： https://github.com/HCThink/h-blog/blob/master/js/syncAndAsync/generator/readme.md
- github 首页(star+watch，一手动态直达)： https://github.com/HCThink/h-blog
- 掘金 link , 掘金 专栏
- segmentfault 主页
原创制止擅自转载
Generator
能够为所欲为的交出和恢复函数的实行权，yield交出实行权，next()恢复实行权
Generator 函数是一个状况机，封装了多个内部状况，实行一个Generator函数会返回一个迭代器对象，能够顺次遍历 Generator 函数内部的每一个状况
挪用一个天生器函数并不会立时实行它内里的语句，而是返回一个这个 generator 的 迭代器 （iterator ）对象。当这个迭代器的 next() 要领被初次（后续）挪用时，其内的语句会实行到第一个（后续）涌现yield的位置为止，yield 后紧跟迭代器要返回的值。
或许假如用的是 yield*（多了个星号），则示意将实行权移交给另一个天生器函数（当前天生器停息实行）。
next()要领返回一个对象，这个对象包括两个属性：value 和 done，value 属性示意本次 yield 表达式的返回值，done 属性为布尔范例，示意天生器后续是不是另有 yield 语句，即天生器函数是不是已实行终了并返回。
典范场景
依靠 async 的上层库和运用屈指可数，比方 koa
koa 等依靠其上层语法糖封装： koa
基本运用
code
function* 这类声明体式格局(function关键字后跟一个星号）会定义一个天生器函数 (generator function)，它返回一个 Generator 对象。
// 斐波那契竖列天生器
function* fib() {
let [x, y]: [number, number] = [0, 1];
while (true) {
[x, y] = [y, x + y];
yield x;
}
}
const generator: Generator = fib();
// 阶乘
function* factorial() {
let x: number = 1;
let fac: number = 1;
while (true) {
yield fac;
fac = fac * ++x;
}
}Generator 对象
挪用一个天生器函数并不会立时实行它内里的语句，而是返回这个天生器的 迭代器 （完成 iterator ）的对象 Generator, 所以它相符可迭代协定和迭代器协定。如上述代码中 const generator: Generator = fib(); 接收 fib() 的范例即： Generator
Generator 对象
- Generator.prototype.next()
返回一个由 yield表达式天生的值。
- Generator.prototype.return()
返回给定的值并完毕天生器。
- Generator.prototype.throw()
向天生器抛出一个毛病。
yield 优先级
yield 仅仅比 睁开运算符: ..., 逗号： , 的优先级高，所以注重辨别 yield fn() + 10 中 fn() + 10 才是 yield 表达式。
generator 中缀 的入参和返回
注重，不是要说全部 generator 的相差参，而是 yield 和 next，这个题目，实在搅扰我蛮久的，缘由是 generator 和传统 js 的函数挪用区分很大， 假如你很熟悉平常函数挪用的相差参,在这里每每转不过弯。
- 返回: next() 返回类
{ done: boolean, value: any }对象， 个中 value 则是 yield 表达式的值。
现实上返回会好明白一些，当我们实行 generator 函数以后取得一个 Generator 对象当我们第一次挪用 GeneratorObj.next() 时，函数才会最先实行，直到第一个 yield 表达式实行完成， 并将 yield 表达式结果供应给 next 举行返回。【注重 yield 表达式此时最先实行】，然后进入中缀。
function pi(n: number): number {
return Math.PI * n;
}
function* fn(n: number) {
// 第一个 next 挪用后 yield 表达式【pi(n) + 10， 注重优先级】实行并将结果： 13.1415... 举行包装
// { value： 13.14..., done: false }
let g1 = yield pi(n) + 10;
// 同理这里就是： { value: 3.141592653589793, done: false }
g1 = (yield pi(n)) + 10;
// return 等价一末了一个 yield。
return 100;
}
const fnGenx: Generator = fn(1);
Log(fnGenx.next()); // { value: 13.141592653589793, done: false }
Log(fnGenx.next()); // { value: 3.141592653589793, done: false }
Log(fnGenx.next()); // { value: 100, done: true }当在天生器函数中显式 return 时，会致使天生器马上变成完成状况，即挪用 next() 要领返回的对象的 done 为 true。假如 return 背面跟了一个值，那末这个值会作为当前挪用 next() 要领返回的 value 值。
挪用 next 时会马上取得 yield 表达式的实行结果。也就是说 yield 不能零丁处置惩罚异步，因为 yield 实在不在意厥后的表达式一切代码实行完毕的时候点。因而也没法肯定下次 next 的挪用时候点。
- 入参: next 要领也能够经由过程接收一个参数用以向天生器传值。请注重，初次挪用 next 要领时参数会被抛弃。next 入参划定规矩以下：
挪用 next()要领时，假如传入了参数，那末这个参数会作为上一条实行的 yield 语句的返回值
现实上每每会误以为 let g1 = （yield x10(n)） + 10; 中 yield 表达式的值就会直接赋值给 g1 实在并非如许的，yield 表达式的值是 next 的返回值，当下次 next（100） 传入的值会替换上一个 yield 表达式的值。也就等价于 g1 = （100） + 10
function x10(n: number): number {
return 10 * n;
}
function* fn(n: number) {
// yield x10(n) + 10 结果为：30， 下次 next 时传入的值做了 +10， 则 g1 值为： 40
let g1 = yield x10(n) + 10;
Log(g1); // 40
// 同理： (yield x10(g1)) 结果为： 40 * 10 = 400， 下次 next 时传入的值： 400 + 10 = 410
// 代入中缀的点： g1 = 410（yield x10(g1)） + 10 = 420
g1 = (yield x10(g1)) + 10;
Log(g1); // 420
}
// 第一个参数由天生器供应
const fnGenx: Generator = fn(2);
let genObj = fnGenx.next(100); // 第一次入参会被抛弃， 因为他没有上一个 yield
while (!genObj.done) {
Log("outer: ", genObj.value);
genObj = fnGenx.next(genObj.value + 10);
}
// outer: 30
// 40
// outer: 400
// 420一个官方 demo
/** gen函数运转剖析：
* i=0 时传入参数(0)，并将参数0赋给上一句yield的返回赋值，因为没有上一句yield语句，这步被疏忽
* 实行var val =100，然后实行yield val，此时g.next(i)返回{ value: 100, done: false }
* 然后console.log(i,g.next(i).value)，打印出0 100
*
* i=1 时传入参数(1)，并将参数1赋给上一句yield的返回赋值,即(val = 1)
* 然后实行console.log(val)，打印出1。
* 接着进入第二次while轮回，挪用yield val，此时g.next(i)返回{ value: 1, done: false }
* 然后console.log(i,g.next(i).value)，打印出1 1
*
* i=2 ....(省略)
*/
function* gen() {
var val =100;
while(true) {
val = yield val;
console.log(val);
}
}
var g = gen();
for(let i =0;i<5;i++){
console.log(i,g.next(i).value);
}
// 返回：
// 0 100
// 1
// 1 1
// 2
// 2 2
// 3
// 3 3
// 4
// 4 4
yield*
假如 yield* Generator， 能够等价以为将 这个 Generator 的一切 yield 插进去到 当前位置
function* anotherGenerator(i) {
yield i + 1;
yield i + 2;
yield i + 3;
}
function* generator(i){
yield i;
yield* anotherGenerator(i);// 移交实行权
yield i + 10;
}
// 等价于
function* generator(i){
yield i;
// yield* anotherGenerator(i);// 移交实行权
yield i + 1;
yield i + 2;
yield i + 3;
yield i + 10;
}注重点
- next 的参数会作为上一条实行的 yield 语句的返回值:
let first = yield 1;中 first 不是直接赋值为 yield 表达式的值， 而是 下次 next 传入的值。 - 天生器函数不能当作组织器运用。
function* f() {}
var obj = new f; // throws "TypeError: f is not a constructor"- yield 表达式是马上实行的，而且返回表达式值， 假如 yield 表达式是异步的，你须要在恰当的机遇触发 next 才到达 async 的实行递次。在『主要题目 generator & 异步』中有细致解说
- generator 和异步机制差异，只是合营 generator + 实行器能够 ‘同步化’ 处置惩罚异步, Generator 函数是ES6供应的一种异步编程处理计划
- “中缀”是 Generator 的主要特性 ———— Generator 能让一段顺序实行到指定的位置先中缀，启动。
babel 转译
function *gen(p) {
console.log(p)
const de1 = yield fn(p);
console.log(de1)
const de2 = yield fn(de1);
console.log(de2)
}
function fn(p) {
return Math.random() * p;
}经由过程 babel 编译为
"use strict";
var _marked = /*#__PURE__*/regeneratorRuntime.mark(gen);
function gen(p) {
var de1, de2;
return regeneratorRuntime.wrap(function gen$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
console.log(p);
_context.next = 3;
return fn(p);
case 3:
de1 = _context.sent;
console.log(de1);
_context.next = 7;
return fn(de1);
case 7:
de2 = _context.sent;
console.log(de2);
case 9:
case "end":
return _context.stop();
}
}
}, _marked, this);
}
function fn(p) {
return Math.random() * p;
}能够看到 babel 运用了一个诸如的对象： regeneratorRuntime 在不支持的环境 polyfill，这个对象剖析涌现在 babel 的 babel-plugin-transform-runtime 插件中.
const moduleName = injectCoreJS2
? "@babel/runtime-corejs2"
: "@babel/runtime";
let modulePath = moduleName;
if (node.name === "regeneratorRuntime" && useRuntimeRegenerator) {
path.replaceWith(
this.addDefaultImport(
`${modulePath}/regenerator`,
"regeneratorRuntime",
),
);
return;
}继承跟进到 babel-runtime-corejs2/regenerator/index.js, babel-runtime/regenerator/index.js 文件中, 两个文件均只要一行代码： module.exports = require("regenerator-runtime"); 都运用了 fackbook 的 regenerator
支持头脑： 协程
协程，又称微线程，纤程. 是一种非抢占式资本调理单位, 是一个无优先级的轻量级的用户态线程
前期学问预备
当代操纵体系是分时操纵体系，资本分派的基本单位是历程，CPU调理的基本单位是线程。
简朴来说，历程(Process), 线程(Thread)的调理是由操纵体系担任，线程的就寝、守候、叫醒的机遇是由操纵体系掌握，开发者没法准确的掌握它们。运用协程，开发者能够自行掌握顺序切换的机遇，能够在一个函数实行到一半的时候中缀实行，让出CPU，在须要的时候再回到中缀点继承实行。
- 上下文: 指的是顺序在实行中的一个状况。平常我们会用挪用栈来示意这个状况——栈记载了每一个挪用层级实行到哪里，另有实行时的环境状况等一切有关的信息。
- 调理: 指的是决议哪一个上下文能够取得接下去的CPU时候的要领。
- 历程: 是一种陈旧而典范的上下文体系，每一个历程有自力的地点空间，资本句柄，他们相互之间不发生滋扰。
- 线程: 是一种轻量历程，现实上在linux内核中，两者几乎没有差异，除了线程并不发生新的地点空间和资本描述符表，而是复用父历程的。 然则不管如何，线程的调理和历程一样，必需堕入内核态。
协程
传统的编程言语，早有多使命的处理计划，个中有一种叫做”协程”（coroutine），意义是多个线程相互合作，完成异步使命， 这和平常的抢占式线程有所差异。
JS 中 generator 就相似一个言语层面完成的非抢占式的轻量级”线程”。 线程包括于历程，而协程包括于线程
- 所以协程具有极高的实行效力。因为子顺序切换不是线程切换，而是由顺序本身掌握，因而，没有线程切换的开支，和多线程比，线程数目越多，协程的机能上风就越显著。
- 不须要多线程的锁机制
- 线程由体系掌握切换，协程是由用户掌握切换。
从更高的层面来说，协程和多线程是两种处理“多使命”编程的手艺。多线程使得 ‘统一时候貌似’ 有多个线程在并发实行，不过须要在多个线程间谐和资本，因为多个线程的实行进度是“不可控”的。而协程则避免了多线程的题目，统一时候实质上只要一个“线程”在实行，所以不会存在资本“抢占”的题目。
不过在 JS 范畴，貌似不存在手艺挑选的难题，因为 JS 现在照样“单线程”的，所以引入协程也是很天然的挑选吧。
协程 & 函数栈
大多言语都是层级挪用，比方A挪用B，B在实行过程当中又挪用了C，C实行终了返回，B实行终了返回，末了是A实行终了。所以子顺序挪用是经由过程栈完成的，一个线程就是实行一个子顺序。子顺序挪用老是一个进口，一次返回，挪用递次是明白的。
而协程的挪用和子顺序差异。协程看上去也是子顺序，但实行过程当中，在子顺序内部可中缀，然后转而实行别的子顺序，在恰当的时候再返回来接着实行。
协程的中缀: 现实上是挂起的观点
协程提议异步操纵意味着该协程将会被挂起，为了保证叫醒时能平常运转，须要准确保留并恢复其运转时的上下文。纪录步骤为：
- 保留当前协程的上下文（运转栈，返回地点，寄存器状况）
- 设置将要叫醒的协程的进口指令地点到IP寄存器
- 恢复将要叫醒的协程的上下文
能够参考 libco 腾讯开源的一个C++协程库，作为微信背景的基本库，禁受住了现实的磨练: libco
JS 协程： generator
js 的天生器也是一种迥殊的协程，它具有 yield 原语，然则却不能指定妥协的协程，只能妥协给天生器的挪用者或恢复者。因为不能多个协程跳来跳去，天生器相对主实行线程来说只是一个可停息的玩具，它甚至都不须要另开新的实行栈，只须要在妥协的时候保留一下上下文就好。因而我们以为天生器与主掌握流的关联是不对等的，也称之为非对称协程（semi-coroutine）。
因而平常的协程完成都邑供应两个主要的操纵 Yield 和 Resume（next）。
Generator 完成协程的题目
- 在协程实行中不能有壅塞操纵，不然全部线程被壅塞(协程是言语级别的，线程，历程属于操纵体系级别)
- 须要迥殊关注全局变量、对象援用的运用
- yield 仅能存在于 天生器内部[对照 node-fibers]
真.协程
所谓的真协程是相对 generator 而言的， node-fibers 库供应了对应的完成，我们用一个例子部份代码申明两者区分
import Fiber from 'fibers'
function fibersCo () { /* 基于 fibers 的实行器 ..... */ }
fibersCo(() => {
let foo1 = a => {
console.log('read from file1');
let ret = Fiber.yield(a);
return ret;
};
let foo2 = b => {
console.log('read from file2');
let ret = Fiber.yield(b);
return ret;
};
let getSum = () => {
let f1 = foo1(readFile('/etc/fstab'));
let f2 = foo2(readFile('/etc/shells'));
return f1.toString().length + f2.toString().length;
};
let sum = getSum();
});经由过程这个代码能够发明，在第一次中缀被恢复的时候，恢复的是一系列的实行栈！从栈顶到栈底顺次为：foo1 => getSum => fibersCo 里的匿名函数；而运用天生器，我们就没法写出如许的顺序，因为 yield 原语只能在临盆器内部运用, SO
不管什么时候被恢复，都是简朴的恢复在天生器内部，所以说天生器的中缀是不开挪用栈滴。
主要题目
generator & 异步
- generator 处置惩罚异步
generator 机制和异步有所差异， Generator 和平常函数本质区分在于 Generator 能让一段顺序实行到指定的位置,然后交出实行栈，挪用下次 next 的时候又会从之前中缀的位置继承最先实行，合营这类机制处置惩罚异步，则会发生同步化异步处置惩罚的结果。
- generator 的题目
但实在很快发明 generator 不能零丁处置惩罚异步题目，缘由在于
- generator 没法猎取下次 next 的机遇。
- generator 没法自实行
- generator 处置惩罚异步的思绪 + 实践
运用 Generator 函数来处置惩罚异步操纵的基本头脑就是在实行异步操纵时停息天生器函数的实行，然后在阶段性异步操纵完成的状况中经由过程天生器对象的next要领让Generator函数从停息的位置恢复实行，云云来去直到天生器函数实行完毕。简朴来说实在就是将异步串行化了。
也恰是基于这类头脑，Generator函数内部才得以将一系列异步操纵写成相似同步操纵的情势，情势上越发简洁明了。
而要让Generator函数按递次自动完成内部定义好的一系列异步操纵，还须要配套的实行器。与之配套的有两种思绪
实在在 async/await 之前就已有了 co 库运用此两种计划完成相似 async 的机制。参考 co 源码剖析
- 上风： 非常捕捉。 generator 的非常捕捉模子，优于 promise。
function* gen(x){
try {
var y = yield x + 2;
} catch (e){
console.log(e);
}
return y;
}generator 的 yield 会发生挪用函数栈么？
因为 yield 原语只能在临盆器内部运用, 所以不管什么时候被恢复，都是简朴的恢复在天生器内部。所以说天生器的中缀是不开挪用栈滴。
参考上述章节
上层运用
async / await
并发通信: 多个generator函数连系在一起，让他们自力平行的运转，而且在它们实行的过程当中来来回回得传递信息
