如果再寫一行代碼，還是gen.next();，這時候返回的就是{value: "b", done: false}，說明g函數運行到了第二個yield語句，返回的是該yield語句的返回值’b’。返回之後依然是暫停。

再寫一行gen.next();返回{value: "c", done: false}，再寫一行gen.next();，返回{value: "ending", done: true}，這樣，整個g函數就運行完畢了。

注意：

1、就算再寫一行gen.next()，會返回{value: undefined, done: true}，這樣沒意義。

2、如果沒有go函數沒有return，第三次.next()之後就返回{value: undefined, done: true}，這個第三次的next()唯一意義就是證明g函數全部執行完了。

3、如果go函書return還帶有yied，白寫，是不會有反應的

4、如果g函數沒有yield和return語句，第一次調用next就返回{value: undefined, done: true}，之後也是{value: undefined, done: true}

5、如果只有return語句，第一次調用就返回{value: xxx, done: true}，其中xxx是return語句的返回值。之後永遠是{value: undefined, done: true}

提問：下面代碼會有什麼結果？

function* g() {
    var o = 1;
    yield o++;
    yield o++;
    yield o++;

}
var gen = g();

console.log(gen.next()); // 1

var xxx = g();

console.log(gen.next()); // 2
console.log(xxx.next()); // 1
console.log(gen.next()); // 3

見上面注釋。每個迭代器之間互不干擾，作用域獨立。

迭代器對象的next方法的運行邏輯如下。

（1）遇到yield語句，就暫停執行後面的操作，並將緊跟在yield後面的那個表達式的值，作為返回的對象的value屬性值。

（2）下一次調用next方法時，再繼續往下執行，直到遇到下一個yield語句。

（3）如果沒有再遇到新的yield語句，就一直運行到函數結束，直到return語句為止，並將return語句後面的表達式的值，作為返回的對象的value屬性值。

（4）如果該函數沒有return語句，則返回的對象的value屬性值為undefined。

yield語句與return語句既有相似之處，也有區別。

相似之處在於，都能返回緊跟在語句後面的那個表達式的值。

區別在於每次遇到yield，函數暫停執行，下一次再從該位置繼續向後執行，而return語句不具備位置記憶的功能。一個函數裏面，只能執行一次（或者說一個）return語句，但是可以執行多次（或者說多個）yield語句。正常函數只能返回一個值，因為只能執行一次return；Generator函數可以返回一系列的值，因為可以有任意多個yield。從另一個角度看，也可以說Generator生成了一系列的值，這也就是它的名稱的來歷（在英語中，generator這個詞是「生成器」的意思）。

注意：yield語句只能用於function*的作用域，如果function*的內部還定義了其他的普通函數，則函數內部不允許使用yield語句。

注意：yield語句如果參與運算，必須用括號括起來。

Generator.prototype.throw()

Generator函數返回的迭代器對象，都有一個throw方法，可以在函數體外拋出錯誤，然後在Generator函數體內捕獲。

既然我的文章是簡單理解Generator函數，所以錯誤捕獲直接跳過。

Generator.prototype.return()

Generator函數返回的迭代器對象，還有一個return方法，可以返回給定的值，並且終結遍歷Generator函數。

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

var g = gen();

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

function* foo() {
  yield 'a';
  yield 'b';
}

function* bar() {
  yield 'x';
  foo();
  yield 'y';
}

for (let v of bar()){
  console.log(v);
}
// "x"
// "y"

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"

function *foo() {
  yield 2;
  yield 3;
  return "foo";
}

function *bar() {
  yield 1;
  var v = yield *foo();
  console.log( "v: " + v );
  yield 4;
}

var it = bar();

it.next()
// {value: 1, done: false}
it.next()
// {value: 2, done: false}
it.next()
// {value: 3, done: false}
it.next();
// "v: foo"
// {value: 4, done: false}
it.next()
// {value: undefined, done: true}

function* gen(){
  yield* ["a", "b", "c"];
}

gen().next() // { value:"a", done:false }

$.get('a.html',function(dataa) {
    console.log(dataa);
    $.get('b.html',function(datab) {
        console.log(datab);
        $.get('c.html',function(datac) {
            console.log(datac);
        });
    });
});

// a.html
// b.html
// c.html

new Promise(function(resolve) {
    $.get('a.html',function(dataa) {
        console.log(dataa);
        resolve();
    });
}).then(function(resolve) {
    return new Promise(function(resolve) {
        $.get('b.html',function(datab) {
            console.log(datab);
            resolve();
        });
    });
}).then(function(resolve) {
    $.get('c.html',function(datac) {
        console.log(datac);
    });
});

function request(url) {
  $.get(url, function(response){
    it.next(response);
  });
}

function sleep(time) {
  setTimeout(function() {
    console.log('I\'m awake.');
    it.next();
  }, time);
}

function* ajaxs(ur) {
    console.log(yield request(ur));
    yield sleep(3000);
    console.log(yield request('b.html'));
    yield sleep(3000);
    console.log(yield request('c.html'));
}

var it = ajaxs('a.html');

it.next();