DIV CSS 佈局教程網

Node.js 中的 JavaScript Generators 詳解
編輯:關於JavaScript     

Generator 是 JavaScript 的協程(coroutine)風格實作:一個可以在執行中途暫停、之後再由外部恢復的函式。語法上以 function* 宣告,函式體內使用 yield 與 yield*。

最基本的例子

function* generatorFn() {
    console.log('look ma I was suspended');
}
var generator = generatorFn();          // [1] 此時完全沒有輸出
setTimeout(function () {
    generator.next();                   // [2] 這裡才真正開始執行
}, 2000);

關鍵在於:單純呼叫 generator 函式不會執行任何程式碼,它只是回傳一個 generator 物件。必須呼叫 next() 才會從上次暫停處繼續,直到碰到下一個 yield 或 return。

帶 yield 的版本

function* generator() {
    console.log('Start!');
    var i = 0;
    while (true) {
        if (i < 3) yield i++;
    }
}
var gen = generator();                  // 仍不會印出 Start!
var ret = gen.next();
// 輸出 Start!
console.log(ret);   // {value: 0, done: false}

next() 的回傳值有兩個屬性:value 是該次 yield 出來的內容;done 表示 generator 是否已執行完畢。

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

兩個核心能力

一,能選擇跳出一個函式,讓外部決定何時再跳回來繼續執行。

二,具備進行非同步流程控制的能力。

var gen = generator();
console.log(gen.next().value);
setTimeout(function () {
    console.log(gen.next().value);
    console.log('第一步');
}, 1000);
console.log('第二步');

輸出順序是 0 → 第二步 → 1 → 第一步。也就是說 setTimeout 不會造成阻塞,程式直接往下跑,計時器到點才回來接續。

雙向通訊

function* channel() {
    var name = yield 'hello, what is your name?';   // [1]
    return 'well hi there ' + name;
}
var gen = channel();
console.log(gen.next().value);       // hello, what is your name?
console.log(gen.next('billy'));      // well hi there billy

next() 可以帶參數,該參數會成為上一個 yield 表達式的結果。這讓 generator 不只是「產生器」,而是能與外部雙向溝通的通道。

可迭代性

function* iter() {
    for (var i = 0; i < 10; i++) yield i;
}
for (var val of iter()) {
    console.log(val);   // 0 到 9
}

常見誤解:generator 不等於多執行緒

很多人以為暫停函式就能讓它們「並行」跑。並不會——JavaScript 是單執行緒,generator 只是把控制權交出去,隨時可以收回,本質上是合作式而非搶佔式。若你的目標是提升運算效能,generator 幫不上忙。

實測差距相當明顯,以計算費氏數列為例:

function fib(n) {
    var current = 0, next = 1, swap;
    for (var i = 0; i < n; i++) { swap = current; current = next; next = swap + next; }
    return current;
}
function* fibGen(n) {
    var current = 0, next = 1, swap;
    for (var i = 0; i < n; i++) {
        swap = current; current = next; next = swap + next;
        yield current;
    }
}

跑分結果(越高越好):regular 1263899、generator 37541。差距來自每次 yield 都要保存與恢復執行狀態的開銷。

真正閃亮的地方

1. 簡化函式複雜度

2. 惰性求值

用閉包也能做到,但 yield 讓語法乾淨很多:

var fibIter = fibGen(20);
console.log(fibIter.next().value);
setTimeout(function () {
    console.log(fibIter.next().value);
}, 2000);

3. 無限序列

因為可以惰性求值,我們能寫出「實際上無限長」的序列:

function* fibGen() {
    var current = 0, next = 1, swap;
    while (true) {
        swap = current; current = next; next = swap + next;
        yield current;
    }
}

於是「求 5000 之後的第一個費氏數」可以寫得非常直白:

for (var num of fibGen()) { if (num > 5000) break; }
console.log(num);   // 6765

4. 非同步流程控制

Node 世界裡處處是回呼。generator 讓我們能用同步風格寫非同步邏輯:

run(function* () {
    console.log("Starting");
    var file = yield readFile("./async.js");   // 等到讀檔回來才繼續
    console.log(file.toString());
});

genify 是一個把 generator 帶進日常開發的框架:

npm install genify
var Q = require('q');
var fs = require('fs');
var genify = require('genify');

// 把物件包成 genify 函式
var object = genify({
    concatFiles: function* (file1, file2, outFile) {
        file1 = yield Q.nfcall(fs.readFile, file1);
        file2 = yield Q.nfcall(fs.readFile, file2);
        var concated = file1 + file2;
        yield Q.nfcall(fs.writeFile, outFile, concated);
        return concated;
    }
});

// concatFiles 已成為回傳 promise 的函式
object.concatFiles('./somefile1.txt', './somefile2.txt', './concated.txt')
    .then(function (res) {
        // 處理結果
    }, function (err) {
        // 處理錯誤
    });

今日觀點

ES2015 的 generator 打開了非同步編程的一條路,後來的 async/await 基本上就是建立在同樣的思路上——只是語法糖更厚、不需要手動 next()。理解 generator 的暫停/恢復模型,再看 async 函式會通透很多。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved