es6学习笔记6--Generator 函数

前端开发作者： 2024-08-25 23:30:01

基本概念 Generator函数有多种理解角度。从语法上，首先可以把它理解成，Generator函数是一个状态机，封装了多个内部状态。执行Generator函数会返回一个遍历器对象，也就是说，Gen

基本概念

function关键字与函数名之间有一个星号；
函数体内部使用yield语句，定义不同的内部状态（yield语句在英语里的意思就是“产出”）。

function* helloWorldGenerator() {
  yield 'hello';
  yield 'world';
  return 'ending';
}

var hw = helloWorldGenerator();

hw.next()
// { value: 'hello',done: false }

hw.next()
 { value: 'world',1)"> { value: 'ending',done: true }
 { value: undefined,done: true }

function * foo(x,y) { ··· }

foo(x,1)">function*foo(x,y) { ··· }

yield语句

 gen() {
  yield  123 + 456;
}

 f() {
  console.log('执行了！')
}

var generator = f();

setTimeout(function () {
  generator.next()
},2000);

( (){
  yield 1;
})()
 SyntaxError: Unexpected number

console.log('Hello' + yield);  SyntaxError
console.log('Hello' + yield 123);  SyntaxError

console.log('Hello' + (yield));  OK
console.log('Hello' + (yield 123));  OK

foo(yield 'a',yield 'b');  OK
let input = yield;  OK

与Iterator接口的关系

var myIterable = {};
myIterable[Symbol.iterator] =  () {
  yield 1;
  yield 2;
  yield 3;
};

[...myIterable]  [1,2,3]

 f() {
  for(var i=0; true; i++) {
    var reset = yield i;
    if(reset) { i = -1; }
  }
}

var g = f();

g.next()  { value: 0,done: false }
g.next()  { value: 1,done: false }
g.next(true) 上面代码先定义了一个可以无限运行的Generator函数f，如果next方法没有参数，每次运行到yield语句，变量reset的值总是undefined。当next方法带一个参数true时，当前的变量reset就被重置为这个参数（即true），因此i会等于-1，下一轮循环就会从-1开始递增。



 foo(x) {
  var y = 2 * (yield (x + 1));
  var z = yield (y / 3);
  return (x + y + z);
}

var a = foo(5);
a.next()  Object{value:6,done:false}
a.next()  Object{value:NaN,done:true}

var b = foo(5);
b.next()  { value:6,done:false }
b.next(12)  { value:8,done:false }
b.next(13)  { value:42,done:true }






 wrapper(generatorFunction) {
  return  (...args) {
    let generatorObject = generatorFunction(...args);
    generatorObject.next();
    return generatorObject;
  };
}

const wrapped = wrapper( () {
  console.log(`First input: ${yield}`);
  return 'DONE';
});

wrapped().next('hello!')
 First input: hello!





foo() {
  yield 1;
  yield 4;
  yield 5return 6for (let v of foo()) {
  console.log(v);
}
 1 2 3 4 5




 objectEntries(obj) {
  let propKeys = Reflect.ownKeys(obj);

   (let propKey of propKeys) {
    yield [propKey,obj[propKey]];
  }
}

let jane = { first: 'Jane',last: 'Doe' };

 (let [key,value] of objectEntries(jane)) {
  console.log(`${key}: ${value}`);
}
 first: Jane
// last: Doe



 objectEntries() {
  let propKeys = Object.keys(this);

  [propKey]];
  }
}

let jane = { first: 'Jane',1)"> };

jane[Symbol.iterator] = objectEntries;

 last: Doe




var g =  () {
  try {
    yield;
  } catch (e) {
    console.log('内部捕获',e);
  }
};

var i = g();
i.next();

 {
  i.throw('a');
  i.throw('b');
}  (e) {
  console.log('外部捕获' 内部捕获 a 外部捕获 b




while (true) {
    yield;
    console.log('内部捕获' 外部捕获 a




var gen =  gen(){
   {
    yield console.log('hello');
  }  (e) {
     ...
  }
  yield console.log('world');
}

 gen();
g.next();
g.throw();
g.next();
 hello world



 gen(){
  yield console.log('hello');
  yield console.log('world' gen();
g.next();

 {
  throw new Error();
}  (e) {
  g.next();
}
 world





 numbers () {
  yield 1 {
    yield 2;
    yield 3;
  } finally {
    yield 4;
    yield 5;
  }
  yield 6;
}
 numbers()
g.next()  { done: false,value: 1 }
g.next() return(7) 
g.next()  { done: true,value: 7 }