NodeJS 最大的賣點(diǎn)——事件機(jī)制和異步 IO，對(duì)開發(fā)者并不是透明的。開發(fā)者需要按異步方式編寫代碼才用得上這個(gè)賣點(diǎn)，而這一點(diǎn)也遭到了一些 NodeJS 反對(duì)者的抨擊。但不管怎樣，異步編程確實(shí)是 NodeJS 最大的特點(diǎn)，沒有掌握異步編程就不能說是真正學(xué)會(huì)了 NodeJS。本章將介紹與異步編程相關(guān)的各種知識(shí)。

在代碼中，異步編程的直接體現(xiàn)就是回調(diào)。異步編程依托于回調(diào)來實(shí)現(xiàn)，但不能說使用了回調(diào)后程序就異步化了。我們首先可以看看以下代碼。

function heavyCompute(n, callback) { var count = 0,  i, j; for (i = n; i > 0; --i) {  for (j = n; j > 0; --j) {   count += 1;  } } callback(count);}heavyCompute(10000, function (count) { console.log(count);});console.log('hello');

100000000hello

可以看到，以上代碼中的回調(diào)函數(shù)仍然先于后續(xù)代碼執(zhí)行。JS 本身是單線程運(yùn)行的，不可能在一段代碼還未結(jié)束運(yùn)行時(shí)去運(yùn)行別的代碼，因此也就不存在異步執(zhí)行的概念。

但是，如果某個(gè)函數(shù)做的事情是創(chuàng)建一個(gè)別的線程或進(jìn)程，并與JS主線程并行地做一些事情，并在事情做完后通知 JS 主線程，那情況又不一樣了。我們接著看看以下代碼。

setTimeout(function () { console.log('world');}, 1000);console.log('hello');

helloworld

這次可以看到，回調(diào)函數(shù)后于后續(xù)代碼執(zhí)行了。如同上邊所說，JS 本身是單線程的，無法異步執(zhí)行，因此我們可以認(rèn)為 setTimeout 這類 JS 規(guī)范之外的由運(yùn)行環(huán)境提供的特殊函數(shù)做的事情是創(chuàng)建一個(gè)平行線程后立即返回，讓 JS 主進(jìn)程可以接著執(zhí)行后續(xù)代碼，并在收到平行進(jìn)程的通知后再執(zhí)行回調(diào)函數(shù)。除了 setTimeout、setInterval 這些常見的，這類函數(shù)還包括 NodeJS 提供的諸如 fs.readFile 之類的異步 API。

另外，我們?nèi)匀换氐?JS 是單線程運(yùn)行的這個(gè)事實(shí)上，這決定了 JS 在執(zhí)行完一段代碼之前無法執(zhí)行包括回調(diào)函數(shù)在內(nèi)的別的代碼。也就是說，即使平行線程完成工作了，通知 JS 主線程執(zhí)行回調(diào)函數(shù)了，回調(diào)函數(shù)也要等到 JS 主線程空閑時(shí)才能開始執(zhí)行。以下就是這么一個(gè)例子。

function heavyCompute(n) { var count = 0,  i, j; for (i = n; i > 0; --i) {  for (j = n; j > 0; --j) {   count += 1;  } }}var t = new Date();setTimeout(function () { console.log(new Date() - t);}, 1000);heavyCompute(50000);

8520

可以看到，本來應(yīng)該在1秒后被調(diào)用的回調(diào)函數(shù)因?yàn)?JS 主線程忙于運(yùn)行其它代碼，實(shí)際執(zhí)行時(shí)間被大幅延遲。

代碼設(shè)計(jì)模式
異步編程有很多特有的代碼設(shè)計(jì)模式，為了實(shí)現(xiàn)同樣的功能，使用同步方式和異步方式編寫的代碼會(huì)有很大差異。以下分別介紹一些常見的模式。

函數(shù)返回值
使用一個(gè)函數(shù)的輸出作為另一個(gè)函數(shù)的輸入是很常見的需求，在同步方式下一般按以下方式編寫代碼：

var output = fn1(fn2('input'));// Do something.

而在異步方式下，由于函數(shù)執(zhí)行結(jié)果不是通過返回值，而是通過回調(diào)函數(shù)傳遞，因此一般按以下方式編寫代碼：

fn2('input', function (output2) { fn1(output2, function (output1) {  // Do something. });});

可以看到，這種方式就是一個(gè)回調(diào)函數(shù)套一個(gè)回調(diào)函多，套得太多了很容易寫出>形狀的代碼。

遍歷數(shù)組
在遍歷數(shù)組時(shí)，使用某個(gè)函數(shù)依次對(duì)數(shù)據(jù)成員做一些處理也是常見的需求。如果函數(shù)是同步執(zhí)行的，一般就會(huì)寫出以下代碼：

var len = arr.length, i = 0;for (; i < len; ++i) { arr[i] = sync(arr[i]);}// All array items have processed.

如果函數(shù)是異步執(zhí)行的，以上代碼就無法保證循環(huán)結(jié)束后所有數(shù)組成員都處理完畢了。如果數(shù)組成員必須一個(gè)接一個(gè)串行處理，則一般按照以下方式編寫異步代碼：

(function next(i, len, callback) { if (i < len) {  async(arr[i], function (value) {   arr[i] = value;   next(i + 1, len, callback);  }); } else {  callback(); }}(0, arr.length, function () { // All array items have processed.}));

可以看到，以上代碼在異步函數(shù)執(zhí)行一次并返回執(zhí)行結(jié)果后才傳入下一個(gè)數(shù)組成員并開始下一輪執(zhí)行，直到所有數(shù)組成員處理完畢后，通過回調(diào)的方式觸發(fā)后續(xù)代碼的執(zhí)行。

如果數(shù)組成員可以并行處理，但后續(xù)代碼仍然需要所有數(shù)組成員處理完畢后才能執(zhí)行的話，則異步代碼會(huì)調(diào)整成以下形式：

(function (i, len, count, callback) { for (; i < len; ++i) {  (function (i) {   async(arr[i], function (value) {    arr[i] = value;    if (++count === len) {     callback();    }   });  }(i)); }}(0, arr.length, 0, function () { // All array items have processed.}));

可以看到，與異步串行遍歷的版本相比，以上代碼并行處理所有數(shù)組成員，并通過計(jì)數(shù)器變量來判斷什么時(shí)候所有數(shù)組成員都處理完畢了。

異常處理
JS 自身提供的異常捕獲和處理機(jī)制——try..catch..，只能用于同步執(zhí)行的代碼。以下是一個(gè)例子。

function sync(fn) { return fn();}try { sync(null); // Do something.} catch (err) { console.log('Error: %s', err.message);}

Error: object is not a function

可以看到，異常會(huì)沿著代碼執(zhí)行路徑一直冒泡，直到遇到第一個(gè) try 語句時(shí)被捕獲住。但由于異步函數(shù)會(huì)打斷代碼執(zhí)行路徑，異步函數(shù)執(zhí)行過程中以及執(zhí)行之后產(chǎn)生的異常冒泡到執(zhí)行路徑被打斷的位置時(shí)，如果一直沒有遇到 try 語句，就作為一個(gè)全局異常拋出。以下是一個(gè)例子。

function async(fn, callback) { // Code execution path breaks here. setTimeout(function ()　{  callback(fn()); }, 0);}try { async(null, function (data) {  // Do something. });} catch (err) { console.log('Error: %s', err.message);}

/home/user/test.js:4  callback(fn());     ^TypeError: object is not a function at null._onTimeout (/home/user/test.js:4:13) at Timer.listOnTimeout [as ontimeout] (timers.js:110:15)

因?yàn)榇a執(zhí)行路徑被打斷了，我們就需要在異常冒泡到斷點(diǎn)之前用 try 語句把異常捕獲住，并通過回調(diào)函數(shù)傳遞被捕獲的異常。于是我們可以像下邊這樣改造上邊的例子。

function async(fn, callback) { // Code execution path breaks here. setTimeout(function ()　{  try {   callback(null, fn());  } catch (err) {   callback(err);  } }, 0);}async(null, function (err, data) { if (err) {  console.log('Error: %s', err.message); } else {  // Do something. }});

Error: object is not a function

可以看到，異常再次被捕獲住了。在 NodeJS 中，幾乎所有異步 API 都按照以上方式設(shè)計(jì)，回調(diào)函數(shù)中第一個(gè)參數(shù)都是 err。因此我們?cè)诰帉懽约旱漠惒胶瘮?shù)時(shí)，也可以按照這種方式來處理異常，與 NodeJS 的設(shè)計(jì)風(fēng)格保持一致。

有了異常處理方式后，我們接著可以想一想一般我們是怎么寫代碼的。基本上，我們的代碼都是做一些事情，然后調(diào)用一個(gè)函數(shù)，然后再做一些事情，然后再調(diào)用一個(gè)函數(shù)，如此循環(huán)。如果我們寫的是同步代碼，只需要在代碼入口點(diǎn)寫一個(gè) try 語句就能捕獲所有冒泡上來的異常，示例如下。

function main() { // Do something. syncA(); // Do something. syncB(); // Do something. syncC();}try { main();} catch (err) { // Deal with exception.}

但是，如果我們寫的是異步代碼，就只有呵呵了。由于每次異步函數(shù)調(diào)用都會(huì)打斷代碼執(zhí)行路徑，只能通過回調(diào)函數(shù)來傳遞異常，于是我們就需要在每個(gè)回調(diào)函數(shù)里判斷是否有異常發(fā)生，于是只用三次異步函數(shù)調(diào)用，就會(huì)產(chǎn)生下邊這種代碼。

function main(callback) { // Do something. asyncA(function (err, data) {  if (err) {   callback(err);  } else {   // Do something   asyncB(function (err, data) {    if (err) {     callback(err);    } else {     // Do something     asyncC(function (err, data) {      if (err) {       callback(err);      } else {       // Do something       callback(null);      }     });    }   });  } });}main(function (err) { if (err) {  // Deal with exception. }});

可以看到，回調(diào)函數(shù)已經(jīng)讓代碼變得復(fù)雜了，而異步方式下對(duì)異常的處理更加劇了代碼的復(fù)雜度。