* () {}
//生成器函数表达式
let = * () {};
//作为对象字面量方法的生成器函数
let foo = {
*() {},
};
//作为类实例方法的生成器函数
class Foo {
*() {}
//作为类静态方法的生成器函数
class Bar {
*() {}
//等价的生成器函数
* () {}
* () {}
* () {}
//等价的生成器方法
class Foo {
*() {}
*() {}
注：箭头函数无法用来定义生成器函数
生成器对象
调用生成器函数会产生一个生成器对象。生成器对象一开始处于暂停执行（）的状态。与迭代器相似生成器和迭代器的区别，生成器对象也实现了接口，因此具有next（）方法。调用这个方法会让生成器开始或恢复执行。
* () {}
const gen = ();
.log(gen); // {}
.log(gen.next); // f next() {[ code]}
next()方法的返回值类似于迭代器，有一个done属性和一个value属性。函数体为空的生成器函数中间不会停留，调用一次next（）就会让生成器到达done：true状态。
* () {}
const gen = ();
.log(gen); // {}
.log(gen.next()); //{value: , done: true}
生成器函数只会在初次调用next（）方法后开始执行，如下所示：
* () {
.log("我执行了");
//初次调用生成器函数并不会打印日志
let gen = ();
gen.next(); // 我执行了
生成器对象实现了接口，它们默认的迭代器是自引用的：
* () {}
.log(); // f*(){}
.log(()[.]);
// f[.](){ code}
.log(());
// {}
.log(()[.]());
// {}
const g = ();
.log(g === g[.]()); // true
二、yield关键字
生成器会在每个yield 语句后停止执行，在函数中停止执行的能力是极其强大的，yield 关键字指定了迭代器在被调用next的方法是应当按顺序返回的值，在没有调用next() 方法的时候，生成器函数里的的代码并不会执行，同时也可用通过 返回生成器函数的返回值
* () {
.log("start");
yield 1;
yield;
yield 2;
3;
let = ();
.log(.next());
//start { value: 1, done: false}
.log(.next());
// { value: , done: false }
.log(.next());
// { value: 2, done: false }
.log(.next());
// { value: 3, done: true }
此时的yield关键字有点像函数的中间返回语句，它生成的值会出现在next（）方法返回的对象里。通过yield关键字退出的生成器函数会处在done：false状态；通过关键字退出的生成器函数会处于done：true状态。
yield关键字详解
yield 关键字可以和值或者是表达式在一起使用，因此可以通过生成器给迭代器添加项目，而不是机械化地将项目一个个列出：
// for循环内部使用yield关键字
* (items) {
//let 块级作用域
for (let i = 0; i < items.; i++) {
yield items[i];
let = ([1, 2, 3]);
.log(.next());
//{value:1, done:false}
.log(.next());
//{value:2, done:false}
.log(.next());
//{value:3, done:false}
.log(.next());
//{value:, done:true}
注：yield 关键字只能用于生成器内部，用于其他位置会出现语法错误，即使在生成器内部的函数中也不行，下面的代码报错。
//有效
* (){
yield;
//报错
* (){
a(){
yield;
//报错
* (){
const b=()=>{
yield;
//报错
* (){
(()=>{
yield;})();
yield作为函数中间参数使用
使用 yield 实现输入和输出, yield 关键字还可以作为函数的中间参数使用,上一次让生成器函数暂停的 yield 关键字会接收到传给 next() 方法的第一个值。第一次调用 next() 传入的值不会被使用，因为这一次调用是为了开始执行生成器函数
* () {
.log();
.log(yield);
.log(yield);
let = (1);
.next(2); // 1
.next(3); // 3
.next(4); // 4
yield关键字同时用于输入输出
// yield 关键字可以同时用于输入和输出，如下
* () {
yield 1;
let = ();
.log(.next());
// { done: false, value: 1 }
.log(.next(2));
// { done: true, value: 2 }
因为函数必须对整个表达式求值才能确定要返回的值，所以它在遇到yield关键字时暂停执行并计算出要产生的值：1 。下一个调用next（）传入了 2 ，作为交给了同一个yield的值。然后这个值被确定为本次生成器函数要返回的值
使用yield实现递归算法
yield*最有用的地方是实现递归操作，此时生成器可以产生自身。看下面的例子：
* Fn(n) {
if (n > 0) {
yield* (n - 1);
yield n - 1;
for (const x of Fn(3)) {
.log(x);
// 0
// 1
// 2
在这个例子中，每个生成器首先都会从新创建的生成器对象产出每个值，然后再产出一个整数。结果就是生成器函数会递归地减少计数器值，并实例化另一个生成器对象。从最顶层来看，这就相当于创建一个可迭代对象并返回递增的整数
三、提前终止生成器
与迭代器类似，生成器也支持“可关闭”的概念。一个实现接口的对象一定有next（）方法，还有一个可选的（）方法用于提前终止迭代器。生成器对象除了有这两个方法，还有第三个方法：thorw（）。
通过和 throw两种方法，提前终止生成器，都会强制生成器进入关闭状态( {})。
()
一旦进入关闭状态，之后再调用next()都会显示 done: true状态。
* gFn() {
yield 1;
yield 2;
yield 3;
const g = gFn();
.log(g.next());
// {value: 1, done: false}
.log(g.("----"));
// {value: "----", done: true}
.log(g);
// gFn {}
.log(g.next(11));
// {value: , done: true}
.log(g.(33));
// {value; 33, done; true}
当我们调用生成器的 方法时，生成器会进入关闭状态，后续再调用 next方法，都会显示 done: true状态，且 value也只有在再次调用 的时候才能得到不是 的值。
for-of循环等内置语言结构会忽略状态为done:true的内部返回的值。
* () {
for (const x of [1, 2, 3]) {
yield x;
const g = ();
for (const x of g) {
.log(x); // 1 2 3
for (const x of g) {
if (x > 1) {
g.(4);
.log(x); // 1 2
throw()
throw()方法会在暂停的时候将一个提供的错误注入到生成器对象中。如果错误未被处理，生成器就会关闭。
* () {
for (const x of [1, 2, 3]) {
yield x;
const g = ();
.log(g); //{}
try {
g.throw("throw");
} catch (e) {
.log(e); // throw
.log(g); //{}
不过，假如生成器函数内部处理了这个错误，那么生成器就不会关闭，而且还可以恢复执行。错误处理会跳过对应的yield，因此在这个例子中会跳过一个值，比如：
* () {
for (const x of [1, 2, 3]) {
try {
yield x;
} catch (e) {
.log(e); // throw
const g = ();
.log(g.next()); //{ value:1, done:false }
g.throw("throw");
.log(g); // {}
.log(g.next()); //{value:3, done:false}
在这个例子中，生成器在try/catch块中的yield关键字处暂停执行。在暂停期间，throw（）方法向生成器对象内部注入了一个错误：字符串‘throw'。这个错误会被yield关键字抛出。因为错误是在生成器的try/catch块中抛出的，所以仍然在生成器内部被捕获。可是，由于yield抛出了那个错误，生成器就不会再产出值2。此时，生成器函数继续执行，在下一次迭代再次遇到yield关键字时产出了值3。
四、自定义迭代器
上篇说过对象是没有实现迭代器，也就是说对象没有@@，无法通过.访问，所以不能遍历对象，为了可以实现对象的遍历，我们需要在对象上实现上面说的迭代器。通常有两种写法，一种是传统的写法，这种需要自己去控制内部的状态，另外一种是利用生成器函数返回的的迭代器来实现生成器和迭代器的区别，代码如下：
传统写法
let obj = {
name: "张三",
age: 18,
[.]: () => {
// 这里不要用this， 因为是 fn, this 会丢失
let index = -1,
= .keys(obj);
const = {
next: () => {
let = "";
index++;
if (index < .) {
= {
value: [index],
done: false,
};
} else {
= {
done: true,
};
;
},
};
;
},
};
for (const of obj) {
.log("atrrs:" + + ",value:" + obj[]);
生成器函数写法
// 为不可迭代的对象添加迭代器
let obj = {
a: 1,
b: 2
obj[.] = * () {
let keys = .keys(obj);
//取到key值的长度
let len = keys.;
//定义循环变量
let n = 0;
//条件判断
while (n