generator基础
generator的结构和函数的构成相同，只不过声明格式不同，如：function *foo(){}或function*foo(){}（有无空格）。
我们先看一个generator简单的例子：
let a=1function *foo(){
a++ yield
console.log(`a:${a}`)
}function bar(){
a++
}// 构造迭代期it控制generatorconst it=foo()// 启动foo()it.next() // a->2bar() // a->3it.next() // 打印： a:3记住！第一个next()是初始化启动generator
输入输出
1.迭代消息传递
function *foo(x){ const y=x*(yield) return y
}const it=foo(2)// 初始化启动*foo()，此时暂停在赋值语句中间it.next() // ->{value: undefined, done: false}// 把3传回被暂停的yield表达式，此时赋值语句为const y=2*3const res=it.next(3) // ->{value: 6, done: true}res.value // 6因为第一个next()总要启动generator，所以next()和yield并不是一一匹配的吗？
2.双向消息传递
我们从迭代器角度来看next()和yield的关系：yield ...作为一个表达式可以发出消息响应next(..)调用，next(..)也可以向暂停的yield表达式发送值————消息是双向传递的。
改一下上面的例子：
function *foo(x){ const y=x*(yield 'hello') return y
}const it=foo(2)
it.next() //-> {value: "hello", done: false}it.next(3) // ->{value: 6, done: true}在generator起始处，我们调用第一个next()时，还没有暂停的yield来接受这样一个值。第一个next()的调用，基本上在提出一个问题：generator *foo要给我的下一个值是什么，由第一个yield 'hello'来回答这个问题。
多个迭代器
在普通的函数中，想要两个函数交替执行是不可能的！要么A函数先运行完毕，要么B函数先运行完毕。
然而，使用generator交替执行显然是又肯能的！
let a=1let b=2function *foo(){
a++ yield
b=b*a
a=(yield b)+3}function *bar(){
b-- yield
a=(yield 8)+b
b=a*(yield 2)
}上面两个generator在共享的相同变量上迭代交替执行，根据迭代器的控制，前面的程序可以产生多种不同的结果。
我们创建一个辅助函数来控制迭代器：
function step(gen){ let it=gen() let last; return function(){ // 不管yield的是啥，下一次都把他传回去
last=it.next(last).value
}
}我们来试验交替运行*foo()和*bar()。
const s1=step(foo)const s2=step(bar) s2() // b-- b=1s2() // yield 8s1() // a++ a=2s2() // a=8+b a=9 // yield 2s1() // b=b*a b=9 // yield bs1() // a=b+3 12s2() // b=a*2 18 这里的a在第四步已经被赋值为9了console.log(a,b) // 12 18
generator的产生值
在上一节中主要介绍了generator产生值的方式，这一节将介绍一些更基础的东西。
iterator
假设你要生成一系列的值，每个值与前一个都有特定的关系，这就是一个迭代过程。iterator是一个定义良好的接口，用于从generator中一步步地得到一系列的值，每次想要从generator中得到下一个值的时候需要调用next()。
用函数闭包构成迭代器
我们可以用简单的函数闭包构造生成一组数字的迭代过程。
const gimmeSomething = (() => { let nextVal; return () => { if (nextVal === undefined) {
nextVal = 1
} else {
nextVal = (3 * nextVal) + 6
} return nextVal
}
})()
gimmeSomething() //1gimmeSomething() //9gimmeSomething() // 33...我们再构造一个next()接口：
const something=(()=>{ let nextVal return {
[Symbol.iterator]:function(){return this}, //
next:()=>{ if(nextVal===undefined){
nextVal=1
}else{
nextVal=nextVal*3+6
} return {done:false,value:nextVal}
}
}
})()自动迭代
es6中新增for...of循环，可以自动迭标准迭代器：
for (var v of something) { console.log(v) if (v > 300) break;
}// 1 9 33 105 321我们更改下上个例子：
const something = (() => { let nextVal return {
[Symbol.iterator]: function() { return this
}, next: () => { if (nextVal === undefined) {
nextVal = 1
} else {
nextVal = nextVal * 3 + 6
} return { done: nextVal>300, value: nextVal
}
}
}
})()for (var v of something) { console.log(v) // 1 9 33 105}for..of..循环在每次迭代中自动调用next()，它不会向next()传入任何值，并且会在接受到done:true时停止。
除了构造自定义的iterator，数组也有默认的迭代器：
const a=[1,5,15,25]for (var v of a) { console.log(v) // 1,5,15,25}一般的object是没有像array一样的默认迭代器，如果想要迭代一个对象的所有属性的话，通过Object.keys(..)返回一个array，之后用for..of..迭代这个键名数组（注意：Object.keys并不包含来自于原型链上的属性，而for..in..则包含）。
2.iterable
iterable指的是一个包含可以在其值上迭代的迭代器的对象，他的名称是符号值Symbol.iterator，调用这个函数时，他会返回一个迭代器。for..of循环自动调用Symbol.iterator函数来构建一个迭代器。
对于上一节使用for..of迭代数组的例子，就相当于
const a=[1,5,15,25]const it=a[Symbol.iterator]() it.next().value //1it.next().value //5it.next().value // 15
3.生成器迭代器
我们可以把genrator看作一个值的生产者，我们通过迭代器接口的next()调用一次提取出一个值。
当你执行一个generator时就得到了一个iterator。我们用generator实现上一节无限数字序列生产者something。
function *something(){ let nextVal while(true){ if(nextVal===undefined){
nextVal=1
}else{
nextVal=nextVal*3+6
} yield nextVal
}
}通常我们在编写js程序时，使用
while(true)且其中没有退出语句时是一个非常糟糕的设计，而如果在生成器中有yield的话，使用这样的循环完全没有问题！因为生成器会在每次迭代中暂停，通过yield返回到主程序或时间循环队列中。
使用for..of循环这个生成器：
for(let v of something()){ console.log(v) if(v>300) break; // 1 9 33 105 321}我们首先要将generator -> iterator才能使用for .. of迭代，所以先something()构造一个生产者来让for..of..循环迭代。generator的迭代器iterable也有一个Symbol.iterator函数，所以也是一个iterable。
停止生成器
在上面的例子中，generator *something()的迭代器实例在循环中break后就，似乎永远停留在挂起状态。
事实上，在for..of循环的“异常结束”（提前终止），通常由break、return或未捕获异常引起，会向generator的迭代器发送一个信号使其终止。
使用try..finally..语句构建generator，即使generator已经在外部结束了，但finally中的语句会被执行，可以在其中清理资源，如：
function *something(){ try{ let nextVal while(true){ if(nextVal===undefined){
nextVal=1
}else{
nextVal=nextVal*3+6
} yield nextVal
}
} finally{ console.log('clean up')
}
}for(let v of something()){ console.log(v) if(v>300) break; // 1 9 33 105 321 'clean up'}上面的例子中，break会触发finally语句；我们也可以用it.return()手动终止生成器的迭代器实例：
const it=something()for(let v of it){ console.log(v) if(v>300){ console.log(
it.return('end up!!').value
) // 无需break
}
}// 1 9 33 105 321// clean up!// end up!!调用it.return()后，他会立即终止生成器，触发finally中的语句，并且将返回的value设置为return()中传入的内容，done为true，也就是end up!被传出的过程，for..of循环终止。
作者：mytac
链接：https://www.jianshu.com/p/c8d98b098b81
随时随地看视频
