The yield
keyword is used to pause and resume a generator function (function* or legacy generator function).
[rv] = yield [expression];
expression
undefined
is returned instead.rv
expression
for use the next time it resumes execution.The yield
keyword causes generator function execution to pause and the value of the expression following the yield
keyword is returned to the generator's caller. It can be thought of as a generator-based version of the return
keyword.
The yield
keyword actually returns an IteratorResult
object with two properties, value
and done
. The value
property is the result of evaluating the yield
expression, and done
is a Boolean indicating whether or not the generator function has fully completed.
Once paused on a yield
expression, the generator's code execution remains paused until the generator's next()
method is called. Each time the generator's next()
method is called, the generator resumes execution and runs until it reaches one of the following:
yield
, which causes the generator to once again pause and return the generator's new value. The next time next()
is called, execution resumes with the statement immediately after the yield
.IteratorResult
is returned to the caller in which the value
is undefined and done
is true
.IteratorResult
is returned to the caller in which the value
is the value specified by the return
statement and done
is true
.If an optional value is passed to the generator's next()
method, that value becomes the value returned by the generator's next yield
operation.
Between the generator's code path, its yield
operators, and the ability to specify a new starting value by passing it to Generator.prototype.next(), generators offer enormous power and control.
The following code is the declaration of an example generator function, along with a helper function.
function* foo(){ var index = 0; while (index <= 2) // when index reaches 3, // yield's done will be true // and its value will be undefined; yield index++; }
Once a generator function is defined, it can be used by constructing an iterator as shown.
var iterator = foo(); console.log(iterator.next()); // { value: 0, done: false } console.log(iterator.next()); // { value: 1, done: false } console.log(iterator.next()); // { value: 2, done: false } console.log(iterator.next()); // { value: undefined, done: true }
IteratorResult
object like { value: undefined, done: true }
().yield
expression has been updated to conform with the latest ES6 specification ():
yield
keyword is optional and omitting it no longer throws a SyntaxError: function* foo() { yield; }
Created by Mozilla Contributors, license: CC-BY-SA 2.5