非同步JavaScript的發展歷程

對大部分的JavaScript開發者而言，async函式是個新鮮事物，它的發展經歷了一個漫長的旅程。因此本文試圖梳理總結JavaScript非同步函式的發展歷程：在不久之前，我們還只能寫回撥函式來實現非同步，然後Promise/A+ 標準出來了，這之後又出現了生成器函式，而未來顯然是async函式的。

現在讓我們、一起來回顧這些年來JavaScript非同步函式的發展歷程吧。

回撥函式 Callbacks

似乎一切應該從回撥函式開始談起。

非同步JavaScript

正如我們所知道的那樣，在JavaScript中，非同步程式設計方式只能通過JavaScript語言中的一等公民函式才能完成：這種方式意味著我們可以將一個函式作為另一個函式的引數，在這個函式的內部可以呼叫被傳遞進來的函式（即回撥函式）。這也正是回撥函式誕生的原因：如果你將一個函式作為引數傳遞給另一個函式（此時它被稱為高階函式），那麼在函式內部，你可以呼叫這個函式來來完成相應的任務。回撥函式沒有返回值（不要試圖用return），僅僅被用來在函式內部執行某些動作。看一個例子：

Something.save(function(err) {  
    if (err)  {
        //error handling
        return; // 沒有返回值
    }
    console.log('success');
});

1

2

3

4

5

6

7

Something.save(function(err) {

if (err) {

//error handling

return; // 沒有返回值

}

console.log('success');

});

上面的例子中我們演示了一個錯誤優先的回撥函式（error-first callbacks），這也是Node.js本身的特點之一， Node.js中所有的核心模組和NPM倉庫中的大部分模組在編寫時都會遵循這個特點。

過度使用回撥函式所會遇到的挑戰：

如果不能合理的組織程式碼，非常容易造成回撥地獄（callback hell），這會使得你的程式碼很難被別人所理解。
很容易遺漏錯誤處理程式碼
無法使用return語句返回值，並且也不能使用throw關鍵字

也正是基於這些原因，在JavaScript世界中，一直都在尋找著能夠讓非同步JavaScript開發變得更簡單的可行的方案。

一個可行的解決方案之一是async模組。如果你和回撥函式打過很久的交道，你也許會深刻的感受到，在JavaScript中如果想要讓某些事並行執行，或是序列執行，甚至是使用非同步函式來對映（mapping）陣列中的元素使用非同步函式有多複雜。所以，感謝Caolan McMahon寫了async模組來解決這些問題。

使用async模組，你可以輕鬆像下面這樣的方式編寫程式碼：

async.map([1, 2, 3], AsyncSquaringLibrary.square,  
    function(err, result){
        // result will be [1, 4, 9]
});

1

2

3

4

async.map([1, 2, 3], AsyncSquaringLibrary.square,

function(err, result){

// result will be [1, 4, 9]

});

async模組雖然一定程度上帶來了便利，但仍然不夠簡單，程式碼也不容易閱讀，因此Promise出現了。

Promise

當前的JavaScript非同步標準可以追溯到2012年，並且直到ES6才變得可用，然而，Promise這個術語卻並不是JavaScript 社群所發明的。這個術語來來自於Daniel P.friedman 在1976年的發表的一篇文章。

一個Promise代表的是一個非同步操作的最終結果。

現在我們使用Promise來完成上面程式碼所完成的任務，Promise風格的程式碼如下：

Something.save()  
    .then(function() {
        console.log('success');
    })
    .catch(function() {
        //error handling
    })

1

2

3

4

5

6

7

Something.save()

.then(function() {

console.log('success');

})

.catch(function() {

//error handling

})

你會發現，Promise中也利用了回撥函式。在then和catch方法中都傳入了一個回撥函式，分別在Promise被滿足和被拒絕時執行。Promise函式的另一個優點是它能夠被連結起來完成一系列任務。例如，你可以這樣寫程式碼：

saveSomething()  
    .then(updateOtherthing)
    .then(deleteStuff)  
    .then(logResults);

1

2

3

4

saveSomething()

.then(updateOtherthing)

.then(deleteStuff)

.then(logResults);

當你沒有現成的Promise時，你可能需要藉助一些Promise庫，一個流行的選擇是使用bluebird。這些庫可能會提供比原生方案更多的功能，並且不侷限於Promise/A+標準所規定的特性。

但是你為什麼不用糖方法（sugar methods）呢？建議你首先閱讀Promise: The Extension Problem 這篇文章。更多關於Promise的資訊，可以參考Promise/A+標準。

你可能會問：如果大部分的庫只暴露了回撥的介面的話，那麼我該如何使用Promise？嗯，這個很簡單，此時你唯一需要做的就是使用Promise來包裹含有回撥的那個函式呼叫體。舉例說明：

回撥風格的程式碼可能是這樣的：

function saveToTheDb(value) {
    db.values.insert(value, function (err, user) {
        if (err) throw err;

        // todo: insert user to db
    });
}

1

2

3

4

5

6

7

function saveToTheDb(value) {

db.values.insert(value, function (err, user) {

if (err) throw err;

// todo: insert user to db

});

}

現在我們來將其改成支援Promise風格呼叫的程式碼：

function saveToTheDb(value) {  
    return new Promise(function(resolve, reject) {
        db.values.insert(value, function(err, user) { // remember error first ;)
            if (err) {
                return reject(err); // don't forget to return here
            }
            resolve(user);
        })
    }
}

1

2

3

4

5

6

7

8

9

10

function saveToTheDb(value) {

return new Promise(function(resolve, reject) {

db.values.insert(value, function(err, user) { // remember error first ;)

if (err) {

return reject(err); // don't forget to return here

}

resolve(user);

})

}

已經有相當一部分的庫或框架同時支持者兩種方式了，即同時提供了回撥風格和Promise風格的API介面。那麼現在，如果你也想對外提供一個庫，最佳實踐也是同時提供兩種方式的介面。你可以輕鬆的使用如下方式來達到這個目的：

function foo(cb) {  
    if (cb) {
        return cb();
    }

    return new Promise(function (resolve, reject) {

    });
}

1

2

3

4

5

6

7

8

9

function foo(cb) {

if (cb) {

return cb();

}

return new Promise(function (resolve, reject) {

});

}

或者更簡單些，你可以從只提供Promise風格的介面開始後，並使用諸如callbackify 這樣的工具來達到向後相容的目的。其實Callbackify所做的工作和上面的程式碼片段類似，但在實現上使用了一個更通用的方法，我建議你可以去閱讀Callbackify的原始碼。

生成器Generators/ yield

JavaScript生成器是個相對較新的概念，它是ES6（也被稱為ES2015）的新特性。想象下面這樣的一個場景：

當你在執行一個函式的時候，你可以在某個點暫停函式的執行，並且做一些其他工作，然後再返回這個函式繼續執行，甚至是攜帶一些新的值，然後繼續執行。

上面描述的場景正是JavaScript生成器函式所致力於解決的問題。當我們呼叫一個生成器函式的時候，它並不會立即執行，而是需要我們手動的去執行迭代操作（next方法）。也就是說，你呼叫生成器函式，它會返回給你一個迭代器。迭代器會遍歷每個中斷點。

function* foo () {  
    var index = 0;
    while (index < 2) {
        yield index++; //暫停函式執行，並執行yield後的操作
    }
}
var bar =  foo(); // 返回的其實是一個迭代器

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

1

2

3

4

5

6

7

8

9

10

11

function* foo () {

var index = 0;

while (index < 2) {

yield index++; //暫停函式執行，並執行yield後的操作

}

var bar = foo(); // 返回的其實是一個迭代器

console.log(bar.next()); // { value: 0, done: false }

console.log(bar.next()); // { value: 1, done: false }

console.log(bar.next()); // { value: undefined, done: true }

更進一步的，如果你想更輕鬆的使用生成器函式來編寫非同步JavaScript程式碼，我們可以使用co 這個庫，co是著名的tj大神寫的。

Co是一個為Node.js和瀏覽器打造的基於生成器的流程控制工具，藉助於Promise，你可以使用更加優雅的方式編寫非阻塞程式碼。

使用co，前面的示例程式碼，我們可以使用下面的程式碼來改寫：

co(function* (){  
    yield Something.save();
}).then(function() {
    // success
})
  .catch(function(err) {
    //error handling
});

1

2

3

4

5

6

7

8

co(function* (){

yield Something.save();

}).then(function() {

// success

})

.catch(function(err) {

//error handling

});

你可能會問：如何實現並行操作呢？答案可能比你想象的簡單，如下（其實它就是Promise.all而已）：

yield [Something.save(), Otherthing.save()];

1	yield [Something.save(), Otherthing.save()];

Async/ await

在ES7（還未正式標準化）中引入了Async函式的概念，目前如果你想要使用的話，只能藉助於babel 這樣的語法轉換器將其轉為ES5程式碼。(提醒一點：我們現在討論的是async關鍵字，而不是NPM中的async包)。

簡而言之，使用async關鍵字，你可以輕鬆的達成之前使用生成器和co函式所做到的工作。當然，除了hack之外。

也許你會問，是否在ES7中有了async關鍵字，yield就變得不是那麼重要了？

實際上，使用yield實現非同步也不過是一種hack罷了，yield意味著懶次序(lazy sequences)和迭代器。而await能夠完美的分離這兩點，首先讓yield用於其最初的目的，其次使用await來執行非同步操作。

在這背後，async函式實際使用的是Promise，也就是為什麼async函式會返回一個Promise的原因。

因此，我們使用async函式來完成類似於前面程式碼所完成的工作，可以使用下面這樣的方式來重新編寫程式碼：

async function save(Something) {  
    try {
        await Something.save(); // 等待await後面的程式碼執行完，類似於yield
    } catch (ex) {
        //error handling
    }
    console.log('success');
}

1

2

3

4

5

6

7

8

async function save(Something) {

try {

await Something.save(); // 等待await後面的程式碼執行完，類似於yield

} catch (ex) {

//error handling

}

console.log('success');

}

正如你看到的那樣，使用async函式，你需要在函式宣告的最前面加上async關鍵字。這之後，你可以在函式內部使用await關鍵字了，作用和之前的yield作用是類似的。

使用async函式完成並行任務與yiled的方式非常的相似，唯一不同的是，此時Promise.all不再是隱式的，你需要顯示的呼叫它：

async function save(Something) {  
    await Promise.all[Something.save(), Otherthing.save()]
}

1

2

3

async function save(Something) {

await Promise.all[Something.save(), Otherthing.save()]

}

Koa也支援async函式，如果你也在使用koa，那麼你現在就可以藉助babel使用這一特性了。

import koa from koa;  
let app = koa();

app.experimental = true;

app.use(async function (){  
    this.body = await Promise.resolve('Hello Reader!')
})

app.listen(3000);

1

2

3

4

5

6

7

8

9

10

import koa from koa;

let app = koa();

app.experimental = true;

app.use(async function (){

this.body = await Promise.resolve('Hello Reader!')

})

app.listen(3000);

非同步JavaScript的發展歷程

回撥函式 Callbacks

非同步JavaScript

Promise

生成器Generators/ yield

Async/ await

擴充閱讀

相關文章