//Generator的简单语法
console.log("=========Generator的简单语法============")
//yield定义的表达式，只有next()函数才能执行直接调用 function* 的函数无法执行
function* helloWorldGenerator() {// 使用 function* 关键字定义Generator函数
yield 'hello'; // 使用yield关键字 定义不同的内部状态
yield 'world';
return 'end'; // 停止该状态
}
var hw = helloWorldGenerator();
console.log(hw.next());
console.log(hw.next());
console.log(hw.next());
console.log(hw.next());
/*
{ value: 'hello', done: false }
{ value: 'world', done: false }
{ value: 'end', done: true }
{ value: undefined, done: true }
*/
//Generator的应用==》遍历一维+二维数组
console.log("=========Generator的应用==》遍历一维+二维数组============")
let arrYield = [1, [[2, 3], 4], [5, 6]];
let flat = function* (arr) {
let length = arr.length;
for (let i = 0; i < length; i++) {
let item = arr[i];
if (typeof item !== 'number') {
yield* flat(item);
} else {
yield item;
}
}
}
for (let f of flat(arrYield)) {
console.log(f);//1,2,3,4,5,6
}
//简单的Iterator函数生成方式
console.log("=========简单的Iterator函数生成方式============")
let myIterable = {};
myIterable[Symbol.iterator] = function* () {
yield 1;
yield 2;
yield 3;
yield 4;
}
console.log([...myIterable]);//[1,2,3,4]
//Generator函数与Iterator接口的关系
console.log("=========Generator函数与Iterator接口的关系============")
function* gen() {}
let g = gen();
console.log(g[Symbol.iterator]() == g); //true
//next(true)返回上一个yield表达式的返回值
console.log("=========next(true)返回上一个yield表达式的返回值============")
function* previousYieldValue() {
for (let i = 0; true; i++) {
let reset = yield i;//reset 为next()函数传入的值
console.log("reset",reset);
if(reset) {i = i-2};
}
}
let previousValue = previousYieldValue();
console.log(previousValue.next());
console.log(previousValue.next());
console.log(previousValue.next());
console.log(previousValue.next(true));
console.log(previousValue.next());
/*
{ value: 0, done: false }
reset undefined
{ value: 1, done: false }
reset undefined
{ value: 2, done: false }
reset true
{ value: 1, done: false }
reset undefined
{ value: 2, done: false }
*/
// next()函数是用于向generator函数进行状态变化时的过程中
// next()方法的参数表示上一个yield表达式的返回值，所以第一次使用next方法时，传递参数是无效的
// yeild定义的表达式将在next()函数调用时，将结果返回给next()函数，但不会再generator中执行
console.log("=========next()函数是用于向generator函数进行状态变化时的过程中 改变yield表达式内部值得一种方式============");
function* nextFoo(x) {
let y = 2 * (yield(x + 1));
let z = yield (y / 3);
return (x + y + z);
}
let nextFA = nextFoo(5);
console.log(nextFA.next());
console.log(nextFA.next());
console.log(nextFA.next());
/*
{ value: 6, done: false }
{ value: NaN, done: false }
{ value: NaN, done: true }
*/
let nextFB = nextFoo(5);
console.log(nextFB.next());
console.log(nextFB.next(12));//设置上一个yield(x+1)的值为12 所以y为24 ->当前返回z = 8
console.log(nextFB.next(13));//设置上一个yield的值为13即z=13 x+y+z = 5+24+13 = 42
/*
{ value: 6, done: false }
{ value: 8, done: false }
{ value: 42, done: true }
*/
//使用next方法向函数内部输入值得例子
function* dataConsumer() {
console.log('Started');
console.log(`1.${yield 222}`);
console.log(`2.${yield}`);
}
let consumer = dataConsumer();
console.log(consumer.next());
console.log(consumer.next('a'));
console.log(consumer.next('b'));
/*
Started
{ value: 222, done: false }
1.a
{ value: undefined, done: false }
2.b
{ value: undefined, done: true }
*/
//要想第一个next()就可以传值的写法
function wrapper(generatorFunction) {
return function (...args) {
let generatorObject = generatorFunction(...args);
generatorObject.next();
return generatorObject;
};
}
const wrapped = wrapper(function* () {
console.log(`First input: ${yield}`);
return 'DONE';
})
console.log(wrapped().next('hello~'));
/*
First input: hello~
{ value: 'DONE', done: true }
*/
console.log("===========for...of循环自动遍历Generator函数，不需要使用next方法=============")
//for...of循环自动遍历Generator函数，不需要使用next方法
function* forOf() {
yield 1;
yield 2;
return 3;
}
for (let v of forOf()) {
console.log(v);//1,2
}
/*
只显示了2个yield表达式的值，一旦next方法返回对象done属性为true，for...of循环就会终止，且不会返回该对象，所以return不包括在for...of循环中
*/
//使Object能使用for...of进行遍历
console.log('=====================使Object能使用for...of进行遍历========================');
function* objectEntries(obj) {
let propKeys = Reflect.ownKeys(obj);
for (let propKey of propKeys) {
yield [propKey, obj[propKey]];
}
}
let jane = {first:'Jane', last: 'Doe'}
for (let [key, value] of objectEntries(jane)) {
console.log(`${key}:${value}`);/*first:Jane last:Doe*/
}
//Generator.prototype.throw()方法
console.log("==========Generator.prototype.throw()方法==================")
let throwFunction = function* () {
try {
yield 1;
}catch (e) {
console.log('内部捕获',e)
}
yield 2;
};
let i = throwFunction();
i.next();
try {
console.log(i.throw('a'));//执行generator的catch方法后 自动执行下一个yield
i.throw('b');//因为generator的catch方法已经执行过了，所以抛出异常
} catch (e) {
console.log("外部捕捉",e);
}
/*
内部捕获 a
外部捕捉 b
*/
let i2 = throwFunction();
try {
console.log(i2.throw('c'));//执行generator的catch方法后 自动执行下一个yield
}catch (e) {
console.log("外部捕获", e);//外部捕获 c，因为未执行next方法，仍未到Generator函数内部
}
let i3 = throwFunction();
console.log(i3.next());
console.log(i3.next());
try{
console.log(i3.throw('D'))//执行generator的catch方法后 自动执行下一个yield
}catch (e) {
console.log('外部捕获', e);//外部捕获 D 因为第2个next外部没有try...catch语句
}
/*
内部捕获 a
{ value: 2, done: false }
外部捕捉 b
外部捕获 c
{ value: 1, done: false }
{ value: 2, done: false }
外部捕获 D
*/
//Generator.prototype.return() 终结遍历Generator函数
function* returnFunction() {
yield 1;
yield 2;
yield 3;
}
let returnFun = returnFunction();
console.log(returnFun.next());
console.log(returnFun.return('foo'));
console.log(g.next());
//如果Generator函数内部哟try...finally代码块，且正在执行try代码块，那么return方法会推迟到finally代码块执行完在执行
function* numbers() {
yield 1;
try {
yield 2;
yield 3;
}finally {
yield 4;
yield 5;
}
yield 6;
}
let numb = numbers();
console.log(numb.next());
console.log(numb.next());
console.log(numb.return(7));
console.log(numb.next());
console.log(numb.next());
/*
{ value: 1, done: false }
{ value: 2, done: false }
{ value: 4, done: false }
{ value: 5, done: false }
{ value: 7, done: true }
*/
//yield* 表达式 如果在Generator函数内部，调用另一个Generator函数，需要在前者的函数体内部，自己手动完成遍历
console.log("================yield* 表达式===================")
function* iteratorFunction() {
yield 'a';
yield 'b';
}
function* barFunction() {
yield 'x';
for (let i of iteratorFunction()) {
console.log(i);//a,b
}
yield 'y';
}
for (let v of barFunction()) {
console.log(v);//x,a,b,y
}
let stringsBarFunction = barFunction();
console.log(stringsBarFunction.next());
console.log(stringsBarFunction.next());
console.log(stringsBarFunction.next());
console.log(stringsBarFunction.next());
/*
{ value: 'x', done: false }
a
b
{ value: 'y', done: false }
{ value: undefined, done: true }
{ value: undefined, done: true }
*/
//使用 yield* 只要有Iterator接口就能实现遍历
function* yieldFunction() {
yield 'x';
yield* iteratorFunction();
yield 'y';
}
//等同于
function* yieldBarFunction() {
yield 'x';
yield 'a';
yield 'b';
yield 'y';
}
//等同于
function* yieldBarForFunction() {
yield 'x';
for (let v of yieldFunction()) {
yield v;
}
yield 'y';
}
for (let v of yieldFunction()) {
console.log('yieldFunction', v);//x,a,b,y
}
let yieldFunction1 = yieldFunction();
console.log(yieldFunction1.next());
console.log(yieldFunction1.next());
console.log(yieldFunction1.next());
console.log(yieldFunction1.next());
/*
{ value: 'x', done: false }
{ value: 'a', done: false }
{ value: 'b', done: false }
{ value: 'y', done: false }
*/
//另一个例子
function* inner() {
yield 'hello!';
yield 'hello1!';
}
function* outer1() {
yield 'open';
yield inner();
yield 'close';
}
let genOuter = outer1();
console.log(genOuter.next().value);//open
console.log(genOuter.next().value);//Object [Generator] {}
console.log(genOuter.next().value);//close
function* outer2() {
yield 'open';
yield* inner();
yield 'close';
}
let genOuter2 = outer2();
console.log(genOuter2.next().value);//open
console.log(genOuter2.next().value);//hello!
console.log(genOuter2.next().value);//hello1!
console.log(genOuter2.next().value);//close
//如果被代理的Generator函数有return语句，那么久可以向代理它的Generator函数返回数据
function* fooReturn() {
yield 2;
yield 3;
return 'fooReturn';
}
function* barFunctionReturn() {
yield 1;
let v = yield* fooReturn();
console.log('v: ' + v);
yield 4;
}
let it = barFunctionReturn();
console.log(it.next());//{ value: 1, done: false }
console.log(it.next());//{ value: 2, done: false }
console.log(it.next());//{ value: 3, done: false }
//v: fooReturn
console.log(it.next());//{ value: 4, done: false }
console.log(it.next());//{ value: undefined, done: true }
//作为对象属性的Generator函数简写成以下形式
let objGenerator = {
* myGeneratorMetod() {
},
myGeneratorMetod2:function* () {
}
}
//9.generator函数的this
//10.generator函数的含义
//11.Generator与上下文
//12应用
网友评论