前兩年大量的在寫Generator+co,用它來寫一些類似同步的代碼但實際上,Generator並不是被造出來乾這個使的,不然也就不會有後來的async、await了Generator是一個可以被暫停的函數,並且何時恢復,由調用方決定希望本文可以幫助你理解Generator究竟是什麼,以及怎麼用 放 ...
前兩年大量的在寫
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的語法
聲明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
函數通過調用兩次方法,將會生成兩個完全獨立的狀態機
所以,保存當前的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}
Method: next()
最常用的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
對象將不會再返回任何有效的值
Method: return()
我們可以在迭代器對象上直接調用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}
Method: throw()
在調用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的語法
yield
的語法有點像return
,但是,return
是在函數調用結束後返回結果的
並且在調用return
之後不會執行其他任何的操作
function method (a) { let b = 5 return a + b // 下邊的兩句代碼永遠不會執行 b = 6 return a * b } method(6) // 11 method(6) // 11
而yield的表現則不一樣
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*
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的返回值
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的結合
再次重申,我個人不認為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