generator基础

generator的结构和函数的构成相同，只不过声明格式不同，如：function *foo(){}或function*foo(){}（有无空格）。

我们先看一个generator简单的例子：

let a=1
function *foo(){
    a++
    yield
    console.log(`a:${a}`)
}

function bar(){
    a++
}

// 构造迭代期it控制generator
const it=foo()
// 启动foo()
it.next() // a->2
bar() // a->3
it.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*3
const 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=1
let b=2
function *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=1
s2() // yield 8
s1() // a++ a=2
s2() // a=8+b a=9
     // yield 2
s1() // b=b*a b=9
     // yield b
s1() // a=b+3 12
s2() // 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() //1
gimmeSomething() //9
gimmeSomething() // 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 //1
it.next().value //5
it.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循环终止。