一、Generator 函數的語法
1.Generator
Generator 函數有多種理解角度。語法上，首先可以把它理解成，Generator 函數是一個狀態機，封裝了多個內部狀態。
執行 Generator 函數會返回一個遍歷器對象，也就是說，Generator 函數除了狀態機，還是一個遍歷器對象生成函數。返回的遍歷器對象，可以依次遍歷 Generator 函數內部的每一個狀態。
形式上，Generator 函數是一個普通函數，但是有兩個特徵。一是，function關鍵字與函數名之間有一個星號；二是，函數體內部使用yield表達式，定義不同的內部狀態（yield在英語裏的意思就是“產出”）。
function* helloWorldGenerator() {
yield 'hello';
yield 'world';
return 'ending';
}
var hw = helloWorldGenerator();
hw.next()
// { value: 'hello', done: false }
hw.next()
// { value: 'world', done: false }
hw.next()
// { value: 'ending', done: true }
hw.next()
// { value: undefined, done: true }
ES6 沒有規定，function關鍵字與函數名之間的星號，寫在哪個位置。這導致下面的寫法都能通過。
function * foo(x, y) { ··· }
function *foo(x, y) { ··· }
function* foo(x, y) { ··· }//常用寫法
function*foo(x, y) { ··· }
面代碼定義了一個 Generator 函數helloWorldGenerator，它內部有兩個yield表達式（hello和world），即該函數有三個狀態：hello，world 和 return 語句（結束執行）。
然後，Generator 函數的調用方法與普通函數一樣，也是在函數名後面加上一對圓括號。不同的是，調用 Generator 函數後，該函數並不執行，返回的也不是函數運行結果，而是一個指向內部狀態的指針對象，也就是上一章介紹的遍歷器對象（Iterator Object）。
下一步，必須調用遍歷器對象的next方法，使得指針移向下一個狀態。也就是說，每次調用next方法，內部指針就從函數頭部或上一次停下來的地方開始執行，直到遇到下一個yield表達式（或return語句）爲止。換言之，Generator 函數是分段執行的，yield表達式是暫停執行的標記，而next方法可以恢復執行。
總結一下，調用 Generator 函數，返回一個遍歷器對象，代表 Generator 函數的內部指針。以後，每次調用遍歷器對象的next方法，就會返回一個有着value和done兩個屬性的對象。value屬性表示當前的內部狀態的值，是yield表達式後面那個表達式的值；done屬性是一個布爾值，表示是否遍歷結束。
yield 表達式
由於 Generator 函數返回的遍歷器對象，只有調用next方法纔會遍歷下一個內部狀態，所以其實提供了一種可以暫停執行的函數。yield表達式就是暫停標誌。
function* gen() {
yield 123 + 456;
}
gen = gen ();
console.log(gen.next());
遍歷器對象的next方法的運行邏輯如下。
（1）遇到yield表達式，就暫停執行後面的操作，並將緊跟在yield後面的那個表達式的值，作爲返回的對象的value屬性值。
（2）下一次調用next方法時，再繼續往下執行，直到遇到下一個yield表達式。
（3）如果沒有再遇到新的yield表達式，就一直運行到函數結束，直到return語句爲止，並將return語句後面的表達式的值，作爲返回的對象的value屬性值。
（4）如果該函數沒有return語句，則返回的對象的value屬性值爲undefined。
需要注意的是，yield表達式後面的表達式，只有當調用next方法、內部指針指向該語句時纔會執行，因此等於爲 JavaScript 提供了手動的“惰性求值”（Lazy Evaluation）的語法功能。
yield與return的比較
yield表達式與return語句既有相似之處，也有區別。
相似之處在於，都能返回緊跟在語句後面的那個表達式的值。
區別在於每次遇到yield，函數暫停執行，下一次再從該位置繼續向後執行，而return語句不具備位置記憶的功能。一個函數裏面，只能執行一次（或者說一個）return語句，但是可以執行多次（或者說多個）yield表達式。正常函數只能返回一個值，因爲只能執行一次return；Generator 函數可以返回一系列的值，因爲可以有任意多個yield。從另一個角度看，也可以說 Generator 生成了一系列的值，這也就是它的名稱的來歷（英語中，generator 這個詞是“生成器”的意思）。
注意：
1.Generator 函數可以不用yield表達式，這時就變成了一個單純的暫緩執行函數。
2.yield表達式只能用在 Generator 函數裏面，用在其他地方都會報錯。
3.yield表達式如果用在另一個表達式之中，必須放在圓括號裏面。
4.yield表達式用作函數參數或放在賦值表達式的右邊，可以不加括號。
//yield表達式只能用在 Generator 函數裏面，用在其他地方都會報錯。
(function (){
yield 1;
})()
// SyntaxError: Unexpected number
另外，yield表達式如果用在另一個表達式之中，必須放在圓括號裏面。
function* demo() {
console.log('Hello' + yield); // SyntaxError
console.log('Hello' + yield 123); // SyntaxError
console.log('Hello' + (yield)); // OK
console.log('Hello' + (yield 123)); // OK
}
yield表達式用作函數參數或放在賦值表達式的右邊，可以不加括號。
function* demo() {
foo(yield 'a', yield 'b'); // OK
let input = yield; // OK
}
2.next 方法的參數
yield表達式本身沒有返回值，或者說總是返回undefined。next方法可以帶一個參數，該參數就會被當作上一個yield表達式的返回值。
function* 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) // { value: 0, done: false }
上面代碼先定義了一個可以無限運行的 Generator 函數f，如果next方法沒有參數，每次運行到yield表達式，變量reset的值總是undefined。當next方法帶一個參數true時，變量reset就被重置爲這個參數（即true），因此i會等於-1，下一輪循環就會從-1開始遞增。
這個功能有很重要的語法意義。Generator 函數從暫停狀態到恢復運行，它的上下文狀態（context）是不變的。通過next方法的參數，就有辦法在 Generator 函數開始運行之後，繼續向函數體內部注入值。也就是說，可以在 Generator 函數運行的不同階段，從外部向內部注入不同的值，從而調整函數行爲。
function* 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: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 }
如果向next方法提供參數，返回結果就完全不一樣了。上面代碼第一次調用b的next方法時，返回x+1的值6；第二
次調用next方法，將上一次yield表達式的值設爲12，因此y等於24，返回y / 3的值8；第三次調用next方法，將
上一次yield表達式的值設爲13，因此z等於13，這時x等於5，y等於24，所以return語句的值等於42。
注意，由於next方法的參數表示上一個yield表達式的返回值，所以在第一次使用next方法時，傳遞參數是無效
的。V8 引擎直接忽略第一次使用next方法時的參數，只有從第二次使用next方法開始，參數纔是有效的。從語義
上講，第一個next方法用來啓動遍歷器對象，所以不用帶有參數。
再看一個通過next方法的參數，向 Generator 函數內部輸入值的例子。
function* dataConsumer() {
console.log('Started');
console.log(`1. ${yield}`);
console.log(`2. ${yield}`);
return 'result';
}
let genObj = dataConsumer();
genObj.next();
// Started
genObj.next('a')
// 1. a
genObj.next('b')
// 2. b
3.for ... of 循環
for...of循環可以自動遍歷 Generator 函數時生成的Iterator對象，且此時不再需要調用next方法。
function* foo() {
yield 1;
yield 2;
yield 3;
yield 4;
yield 5;
return 6;
}
for (let v of foo()) {
console.log(v);
}
// 1 2 3 4 5
注意，一旦next方法的返回對象的done屬性爲true，for...of循環就會中止，且不包含該返回對象，所以上面代碼的return語句返回的6，不包括在for...of循環之中。
4.Generator.prototype.throw()
Generator 函數返回的遍歷器對象，都有一個throw方法，可以在函數體外拋出錯誤，然後在 Generator 函數體內捕獲。
var g = function* () {
try {
yield;
} catch (e) {
console.log('內部捕獲', e);
}
};
var i = g();
i.next();
try {
i.throw('a');
i.throw('b');
} catch (e) {
console.log('外部捕獲', e);
}
// 內部捕獲 a
// 外部捕獲 b
5.Generator.prototype.return()
Generator 函數返回的遍歷器對象，還有一個return方法，可以返回給定的值，並且終結遍歷 Generator 函數。
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 }
如果return方法調用時，不提供參數，則返回值的value屬性爲undefined。
function* gen() {
yield 1;
yield 2;
yield 3;
}
var g = gen();
g.next() // { value: 1, done: false }
g.return() // { value: undefined, done: true }
如果 Generator 函數內部有try...finally代碼塊，那麼return方法會推遲到finally代碼塊執行完再執行。
function* numbers () {
yield 1;
try {
yield 2;
yield 3;
} finally {
yield 4;
yield 5;
}
yield 6;
}
var g = numbers();
g.next() // { value: 1, done: false }
g.next() // { value: 2, done: false }
g.return(7) // { value: 4, done: false }
g.next() // { value: 5, done: false }
g.next() // { value: 7, done: true }
6.next()、throw()、return() 的共同點
next()、throw()、return()這三個方法本質上是同一件事，可以放在一起理解。它們的作用都是讓 Generator 函數恢復執行，並且使用不同的語句替換yield表達式。
next()是將yield表達式替換成一個值。第二個next(1)方法就相當於將yield表達式替換成一個值1。如果next方法沒有參數，就相當於替換成undefined。
throw()是將yield表達式替換成一個throw語句。
return()是將yield表達式替換成一個return語句。
gen.next(1); // Object {value: 1, done: true}
// 相當於將 let result = yield x + y
gen.throw(new Error('出錯了')); // Uncaught Error: 出錯了
// 相當於將 let result = yield x + y
// 替換成 let result = throw(new Error('出錯了'));
gen.return(2); // Object {value: 2, done: true}
// 相當於將 let result = yield x + y
// 替換成 let result = return 2;
7.yield* 表達式
yield*表達式，用來在一個 Generator 函數裏面執行另一個 Generator 函數。從語法角度看，如果yield表達式後面跟的是一個遍歷器對象，需要在yield表達式後面加上星號，表明它返回的是一個遍歷器對象。這被稱爲yield*表達式。
function* foo() {
yield 'a';
yield 'b';
}
function* bar() {
yield 'x';
yield* foo();
yield 'y';
}
// 等同於
function* bar() {
yield 'x';
yield 'a';
yield 'b';
yield 'y';
}
// 等同於
function* bar() {
yield 'x';
for (let v of foo()) {
yield v;
}
yield 'y';
}
for (let v of bar()){
console.log(v);
}
// "x"
// "a"
// "b"
// "y"
8.作爲對象屬性的Generator 函數
myGeneratorMethod屬性前面有一個星號，表示這個屬性是一個 Generator 函數。
let obj = {
* myGeneratorMethod() {
···
}
};
//等價
let obj = {
myGeneratorMethod: function* () {
// ···
}
};