ES6---Generator函数

ES6 新引入了 Generator 函数，可以通过 yield 关键字，把函数的执行流挂起，为改变执行流程提供了可能，从而为异步编程提供解决方案。

Generator 由两个区分于普通函数的部分

• 一是在 function 后面，函数名之前有个 *
• 函数内部有 yield 表达式

其中 * 用来表示函数为 Generator 函数，yield 用来定义函数内部的状态

//普通的Generator函数
function* func(){
	 console.log("one");
	 yield '1';
	 console.log("two");
	 yield '2'; 
	 console.log("three");
	 yield '3';
}

要执行Generator函数则需要特殊的执行方法
Generator 函数不会像普通函数一样立即执行，而是返回一个指向内部状态对象的指针，所以要调用遍历器对象Iterator 的 next 方法，指针就会从函数头部或者上一次停下来的地方开始执行

//每次用next()调用都会返回上一次执行的地方
//所以函数func中有三个yield，要调用四次 done才会返回true
f.next();
// one
// {value: "1", done: false}
 
f.next();
// two
// {value: "2", done: false}
 
f.next();
// three
// {value: "3", done: false}
 
f.next();
// {value: undefined, done: true}

函数返回的遍历器对象的方法
上述方法是next()不传参的情况
下面时传参的情况

function* func(){
    console.log("start");
    var x = yield '2';
    console.log("one:" + x);
    var y = yield '3';
    console.log("two:" + y);
    console.log("total:" + (x + y));
}
let f = func()
console.log(f.next(10));
console.log(f.next(20));
console.log(f.next(30));

return 方法
return 方法返回给定值，并结束遍历 Generator 函数
return 方法提供参数时，返回该参数；不提供参数时，返回 undefined

function* foo(){
    yield 1;
    yield 2;
    return 3;
}
var f = foo();
console.log(f.next());
console.log(f.next());
console.log(f.next());

可以看出第三次执行next()的时候就已经返回了true

throw 方法
throw 方法可以再 Generator 函数体外面抛出异常，再函数体内部捕获

function* g(){
    try {
        yield;
    } catch (e) {
        console.log('catch inner', e);
    }
};
var i = g();
// 此处必须使用next()调用一次,一次
console.log(i.next());
try {
    i.throw('a');
    i.throw('b');
} catch (e) {
    console.log('catch outside', e);
}
console.log(i.next());

使用场景

实现 Iterator
为不具备 Iterator 接口的对象提供遍历方法

function* objectEntries(obj) {
    const propKeys = Reflect.ownKeys(obj);
    for (const propKey of propKeys) {
        yield [propKey, obj[propKey]];
    }
}
 
const jane = { first: 'Jane', last: 'Doe' };
for (const [key,value] of objectEntries(jane)) {
    console.log(`${key}: ${value}`);
}
// first: Jane
// last: Doe