摘要：不參與迭代迭代會執行所有的，也就是說，在迭代后的對象將不會再返回任何有效的值我們可以在迭代器對象上直接調用，來終止后續的代碼執行。

前兩年大量的在寫Generator+co，用它來寫一些類似同步的代碼  
但實際上，Generator并不是被造出來干這個使的，不然也就不會有后來的async、await了  
Generator是一個可以被暫停的函數，并且何時恢復，由調用方決定  
希望本文可以幫助你理解Generator究竟是什么，以及怎么用

放一張圖來表示我對Generator的理解：

一個咖啡機，雖說我并不喝咖啡，可惜找不到造王老吉的機器-.-

我所理解的Generator咖啡機大概就是這么的一個樣子的：

首先，我們往機器里邊放一些咖啡豆

等我們想喝咖啡的時候，就可以按開關(gen.next())，機器開始磨咖啡豆、煮咖啡、接下來就得到咖啡了

等接滿了一杯咖啡后，閥門就會自動關閉(yield)

如果你一開始往機器里邊放的咖啡豆很多的話，此時，機器里邊還是會有一些剩余的，下次再想喝還可以繼續按開關，執行（磨豆、煮咖啡、接咖啡）這一套操作

拿Generator將上述咖啡機實現一下：

function * coffeeMachineGenerator (beans) {
  do {
    yield cookCoffee()
  } while (--beans)

  // 煮咖啡
  function cookCoffee () {
    console.log("cooking")

    return "Here you are"
  }
}

// 往咖啡機放咖啡豆
let coffeeMachine = coffeeMachineGenerator(10)

// 我想喝咖啡了
coffeeMachine.next()

// 我在3秒后還會喝咖啡
setTimeout(() => {
  coffeeMachine.next()
}, 3 * 1e3)

代碼運行后，我們首先會得到一條cooking的log，
然后在3s后會再次得到一條log。

這就解釋了Generator是什么：
一個可以暫停的迭代器
調用next來獲取數據（我們自己來決定是否何時煮咖啡）
在遇到yield以后函數的執行就會停止（接滿了一杯，閥門關閉）
我們來決定何時運行剩余的代碼next（什么時候想喝了再去煮）

這是Generator中最重要的特性，我們只有在真正需要的時候才獲取下一個值，而不是一次性獲取所有的值

聲明Generator函數有很多種途徑，最重要的一點就是，在function關鍵字后添加一個*

function * generator () {}
function* generator () {}
function *generator () {}

let generator = function * () {}
let generator = function*  () {}
let generator = function  *() {}

// 錯誤的示例
let generator = *() => {}
let generator = ()* => {}
let generator = (*) => {}

或者，因為是一個函數，也可以作為一個對象的屬性來存在：

class MyClass {
  * generator() {}
  *generator2() {}
}

const obj = {
  *generator() {}
  * generator() {}
}

一個Generator函數通過調用兩次方法，將會生成兩個完全獨立的狀態機
所以，保存當前的Generator對象很重要：

function * generator (name = "unknown") {
  yield `Your name: ${name}`
}

const gen1 = generator()
const gen2 = generator("Niko Bellic")

gen1.next() // { value: Your name: unknown    , done: false}
gen2.next() // { value: Your name: Niko Bellic, done: false}

最常用的next()方法，無論何時調用它，都會得到下一次輸出的返回對象（在代碼執行完后的調用將會始終返回{value: undefined, done: true}）。

next總會返回一個對象，包含兩個屬性值：
value：yield關鍵字后邊表達式的值
done ：如果已經沒有yield關鍵字了，則會返回true .

function * generator () {
  yield 5
  return 6
}

const gen = generator()

console.log(gen.next()) // {value: 5, done: false}
console.log(gen.next()) // {value: 6, done: true}
console.log(gen.next()) // {value: undefined, done: true}
console.log(gen.next()) // {value: undefined, done: true} -- 后續再調用也都會是這個結果

Generator函數是一個可迭代的，所以，我們可以直接通過for of來使用它。

function * generator () {
  yield 1
  yield 2
  return 3
}

for (let item of generator()) {
  item
}

// 1
// 2

return不參與迭代
迭代會執行所有的yield，也就是說，在迭代后的Generator對象將不會再返回任何有效的值

我們可以在迭代器對象上直接調用return()，來終止后續的代碼執行。
在return后的所有next()調用都將返回{value: undefined, done: true}

function * generator () {
  yield 1
  yield 2
  yield 3
}

const gen = generator()

gen.return()     // {value: undefined, done: true}
gen.return("hi") // {value: "hi", done: true}
gen.next()       // {value: undefined, done: true}

在調用throw()后同樣會終止所有的yield執行，同時會拋出一個異常，需要通過try-catch來接收：

function * generator () {
  yield 1
  yield 2
  yield 3
}

const gen = generator()

gen.throw("error text") // Error: error text
gen.next()              // {value: undefined, done: true}

yield的語法有點像return，但是，return是在函數調用結束后返回結果的
并且在調用return之后不會執行其他任何的操作

function method (a) {
  let b = 5
  return a + b
  // 下邊的兩句代碼永遠不會執行
  b = 6
  return a * b
}

method(6) // 11
method(6) // 11

function * yieldMethod(a) {
  let b = 5
  yield a + b
  // 在執行第二次`next`時，下邊兩行則會執行
  b = 6
  return a * b
}

const gen = yieldMethod(6)
gen.next().value // 11
gen.next().value // 36

yield*用來將一個Generator放到另一個Generator函數中執行。
有點像[...]的功能：

function * gen1 () {
  yield 2
  yield 3
}

function * gen2 () {
  yield 1
  yield * gen1()
  yield 4
}

let gen = gen2()

gen.next().value // 1
gen.next().value // 2
gen.next().value // 3
gen.next().value // 4

yield是可以接收返回值的，返回值可以在后續的代碼被使用
一個詭異的寫法

function * generator (num) {
  return yield yield num
}

let gen = generator(1)

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

我們在調用第一次next時候，代碼執行到了yield num，此時返回num
然后我們再調用next(2)，代碼執行的是yield (yield num)，而其中返回的值就是我們在next中傳入的參數了，作為yield num的返回值存在。
以及最后的next(3)，執行的是這部分代碼return (yield (yield num))，第二次yield表達式的返回值。

上邊的所有示例都是建立在已知次數的Generator函數上的，但如果你需要一個未知次數的Generator，僅需要創建一個無限循環就夠了。

比如我們將實現一個隨機數的獲取：

function * randomGenerator (...randoms) {
  let len = randoms.length
  while (true) {
    yield randoms[Math.floor(Math.random() * len)]
  }
}

const randomeGen = randomGenerator(1, 2, 3, 4)

randomeGen.next().value // 返回一個隨機數

那個最著名的斐波那契數，基本上都會選擇使用遞歸來實現
但是再結合著Generator以后，就可以使用一個無限循環來實現了：

function * fibonacci(seed1, seed2) {
  while (true) {
    yield (() => {
      seed2 = seed2 + seed1;
      seed1 = seed2 - seed1;
      return seed2;
    })();
  }
}

const fib = fibonacci(0, 1);
fib.next(); // {value: 1, done: false}
fib.next(); // {value: 2, done: false}
fib.next(); // {value: 3, done: false}
fib.next(); // {value: 5, done: false}
fib.next(); // {value: 8, done: false}

再次重申，我個人不認為async/await是Generator的語法糖。。

如果是寫前端的童鞋，基本上都會遇到處理分頁加載數據的時候
如果結合著Generator+async、await，我們可以這樣實現：

async function * loadDataGenerator (url) {
  let page = 1

  while (true) {
    page = (yield await ajax(url, {
      data: page
    })) || ++page
  }
}

// 使用setTimeout模擬異步請求
function ajax (url, { data: page }) {
  return new Promise((resolve) => {
    setTimeout(_ => {
      console.log(`get page: ${page}`);
      resolve()
    }, 1000)
  })
}

let loadData = loadDataGenerator("get-data-url")

await loadData.next()
await loadData.next()

// force load page 1
await loadData.next(1)
await loadData.next()

// get page: 1
// get page: 2
// get page: 1
// get page: 2

這樣我們可以在簡單的幾行代碼中實現一個分頁控制函數了。
如果想要從加載特定的頁碼，直接將page傳入next即可。

Generator還有更多的使用方式，（實現異步流程控制、按需進行數據讀取）
個人認為，Generator的優勢在于代碼的惰性執行，Generator所實現的事情，我們不使用它也可以做到，只是使用Generator后，能夠讓代碼的可讀性變得更好、流程變得更清晰、更專注于邏輯的實現。

如果有什么不懂的地方 or 文章中一些的錯誤，歡迎指出

Javascript (ES6) Generators?—?Part I: Understanding Generators

What are JavaScript Generators and how to use them

文章示例代碼