JS generator

Basic use

Generator The function is ES6 An asynchronous programming solution provided by . Generator functions can pause while executing , After that, it can continue from the pause .

Generator function function There is an asterisk between the keyword and the function name ; Function body internal use yield expression , Define different internal states （yield In English, it means “ Produce ”）
function* name([param[, param[, ... param]]]) { statements }

Calling a generator function does not immediately execute the statements in it , Instead, it returns a iterator （ iterator ） object .
When this iterator's next() The method was first （ follow-up ） Invocation time , The statements in it are executed to the first （ follow-up ） appear yield Up to ,yield Followed by the value to be returned by the iterator .
Or if you use yield*（ There's an extra asterisk ）, It means to transfer the execution right to another generator function （ The current generator is paused ）.
next() Method returns an object , This object contains two properties ：value and done,value Property indicates this time yield Return value of expression ,done Property is boolean type , Indicates whether the generator will have any follow-up information yield sentence , That is, whether the generator function has been executed and returned .

function * gen () {
    
  let val
  val = yield 1
  console.log(`1:${
      val}`)
  val = yield 2
  console.log(`2:${
      val}`)
  val = yield 3
  console.log(`3:${
      val}`)
}

var g = gen()

console.log(g.next()) // {value: 1, done: false}
console.log(g.next()) // {value: 2, done: false}
console.log(g.next()) // {value: 3, done: false}
console.log(g.next()) // {value: undefined, done: true}

yield The ginseng

call next() When the method is used , If parameters are passed in , Then this parameter will be passed to the previous execution yield Variables to the left of the statement , For example, in the following example x ：

function *gen(){
    
    yield 10;
    x=yield 'foo';
    yield x;
}

var gen_obj=gen();
console.log(gen_obj.next());//  perform  yield 10, return  10
console.log(gen_obj.next());//  perform  yield 'foo', return  'foo'
console.log(gen_obj.next(100));//  take  100  To the previous one  yield 'foo'  Left value of , The perform  x=100, return  100
console.log(gen_obj.next());//  completion of enforcement ,value  by  undefined,done  by  true

Generator Object method ：next、return、throw.

Generator.prototype.next()
//  Returns a  yield The value generated by the expression .

Generator.prototype.return()
//  Returns the given value and ends the generator .

Generator.prototype.throw()
//  Throw an error to the generator .

among ,next() See above for the method , Don't go into details . Let's take a brief look return and throw.

// return() 
function* gen() {
    
  yield 1;
  yield 2;
  yield 3;
}

var g = gen();

g.next();        // { value: 1, done: false }
g.return("foo"); // { value: "foo", done: true }
g.next();        // { value: undefined, done: true }

//  If the pair is already in “ complete ” State generator calls return(value), Then the generator will remain in “ complete ” state .
//  If no parameters are provided , Returns the value Properties and the last of the example .next() In the same way .
//  If parameters are provided , The parameter will be set to return the of the object value The value of the property .

// throw()
function* gen() {
    
  while(true) {
    
    try {
    
       yield 42;
    } catch(e) {
    
      console.log("Error caught!");
    }
  }
}

var g = gen();
g.next(); // { value: 42, done: false }
//  Use  throw Method throws an exception to the generator , This exception can usually be passed through  try...catch  Block to capture .
g.throw(new Error("Something went wrong")); // "Error caught!"

A generator function cannot be used as a constructor

function* f() {
    }
var obj = new f; // throws "TypeError: f is not a constructor"

Examples of application scenarios

Luck draw ： Return the result of a single execution each time