附錄 Node.js 與 JavaScript
JavaScript 有以下幾種基本型態。
變數宣告的方式，就是使用 var，結尾使用『;』，如果需要連續宣告變數，可以使用 『,』 做為連結符號。
::
// 宣告 x 為 123, 數字型態
var x=123;
// 宣告 a 為456, b 為 'abc' 字串型態
var a=456,
b='abc';
布林，就只有兩種數值, true, false
::
var a=true,
b=false;
Number 數字型別，可以分為整數，浮點數兩種，
::
var a=123,
b=123.456;
字串，可以是一個字，或者是一連串的字，可以使用 '' 或 "" 做為字串的值。 (盡量使用雙引號來表達字串，因為在node裡不會把單引號框住的文字當作字串解讀)
::
var a="a",
a='abc';
基本介紹就是 +, -, *, / 邏輯運算就是 && (and), || (or), ^ (xor), 比較式就是 >, <, !=, !==, ==, ===, >=, <=
這邊突然離題，加入判斷式來插花，判斷就是 if，整個架構就是，
::
if (判斷a) {
// 判斷a 成立的話，執行此區域指令
} else if (判斷b) {
// 判斷a 不成立，但是 判斷b 成立，執行此區域指令
} else {
// 其餘的事情在這邊處理
}
整體架構就如上面描述，非 a 即 b的狀態，會掉進去任何一個區域裡面。整體的判斷能夠成立，只要判斷轉型成 Boolean 之後為 true，就會成立。大家可以這樣子測試，
Boolean(判斷);
會突然講 if 判斷式，因為，前面有提到 Number, String 兩種型態，但是如果我們測試一下，新增一個 test.js
::
var a=123,
b='123';
if (a == b) {
console.log('ok');
}
編輯 test.js 完成之後，執行底下指令
::
node test.js
// print: ok
輸出結果為 ok。
這個結果是有點迥異， a 為 Number, b 為 String 型態，兩者相比較，應該是為 false 才對，到底發生什麼事情？ 這其中原因是，在判斷式中使用了 == ， JavaScript 編譯器，會自動去轉換變數型態，再進行比對，因此 a == b 就會成立，如果不希望轉型產生，就必須要使用 === 做為判斷。
:: if (a === b) { console.log('ok); } else { console.log('not ok'); } // print: not ok
如果今天需要將字串，轉換成 Number 的時候，可以使用 parseInt, parseFloat 的方法來進行轉換，
::
var a='123';
console.log(typeof parseInt(a, 10));
使用 typeof 方法取得資料經過轉換後的結果，會取得，
::
number
要注意的是，記得 parseInt 後面要加上進位符號，以免造成遺憾，在這邊使用的是 10 進位。
空無是一種很奇妙的狀態，在 JavaScript 裡面，null, undefined 是一種奇妙的東西。今天來探討什麼是 null ，什麼是 undefined.
變數要經過宣告，賦予 null ，才會形成 null 型態。
::
var a=null;
null 在 JavaScript 中表示一個空值。
從字面上就表示目前未定義，只要一個變數在初始的時候未給予任何值的時候，就會產生 undefined
::
var a;
console.log(a);
// print : undefined
這個時候 a 就是屬於 undefined 的狀態。另外一種狀況就是當 Object 被刪除的時候。
::
var a = {};
delete a;
console.log(a);
//print: undefined.
Object 在之後會介紹，先記住有這個東西。而使用 delete 的時候，就可以讓這個 Object 被刪除，就會得到結果為 undefined.
null, undefined 在本質上差異並不大，不過實質上兩者並不同，如果硬是要比較，建議使用 === 來做為判斷標準，避免 null, undefined 這兩者被強制轉型。
::
var a=null,
b;
if (a === b) {
console.log('same');
} else {
console.log('different');
}
//print: different
從 typeof 也可以看到兩者本質上的差異，
::
typeof null;
//print: 'object'
typeof undefined;
//print: 'undefined'
null 本質上是屬於 object, 而 undefined 本質上屬於 undefined ，意味著在 undefined 的狀態下，都是屬於未定義。
如果用判斷式來決定，會發現另外一種狀態
::
Boolean(null);
// false
Boolean(undefined);
// false
可以觀察到，如果一個變數值為 null, undefined 的狀態下，都是屬於 false。
這樣說明應該幫助到大家了解，其實要判斷一個物件、屬性是否存在，只需要使用 if
::
var a;
if (!a) {
console.log('a is not existed');
}
//print: a is not existed
a 為 undefined 由判斷式來決定，是屬於 False 的狀態。
陣列也是屬於 JavaScript 的原生物件之一，在實際開發會有許多時候需要使用 Array 的方法，先來介紹一下陣列要怎麼宣告。
宣告方式，
.. code-block:: js
var a=['a', 'b', 'c'];
var a=new Array('a', 'b', 'c');
以上這兩種方式都可以宣告成陣列，接著我們將 a 這個變數印出來看一下，
.. code-block:: js
console.log(a);
//print: [0, 1, 2]
Array 的排列指標從 0 開始，像上面的例子來說， a 的指標就有三個，0, 1, 2，如果要印出特定的某個陣列數值，使用方法，
.. code-block:: js
console.log(a[1]);
//print: b
如果要判斷一個變數是不是 Array 最簡單的方式就是直接使用 Array 的原生方法，
.. code-block:: js
var a=['a', 'b', 'c'];
console.log(Array.isArray(a));
//print: true
var b='a';
console.log(Array.isArray(b));
//print: false
如果要取得陣列變數的長度可以直接使用，
.. code-block:: js
console.log(a.length);
length 為一個常數，型態為 Number，會列出目前陣列的長度。
以前面所宣告的陣列為範例，
.. code-block:: js
var a=['a', 'b', 'c'];
使用 pop 可以從最後面取出陣列的最後一個值。
.. code-block:: js
console.log(a.pop());
//print: c
console.log(a.length);
//print: 2
同時也可以注意到，使用 pop 這個方法之後，陣列的長度內容也會被輸出。另外一個跟 pop 很像的方式就是 shift，
.. code-block:: js
console.log(a.shift());
//print: a
console.log(a.length);
//print: 1
shift 跟 pop 最大的差異，就是從最前面將數值取出，同時也會讓呼叫的陣列少一個數組。
前面提到 pop, shift 就不得不說一下 slice，使用方式，
.. code-block:: js
console.log(a.slice(1,3));
//print: 'b', 'c'
第一個參數為起始指標，第二個參數為結束指標，會將這個陣列進行切割，變成一個新的陣列型態。 如果需要給予新的變數，就可以這樣子做，完整的範例。
.. code-block:: js
var a=['a', 'b', 'c'];
var b=a.slice(1,3);
console.log(b);
//print: 'b', 'c'
concat 這個方法，可以將兩個 Array 組合起來，
.. code-block:: js
var a=['a'];
var b=['b', 'c'];
console.log(a.concat(b));
//print: 'a', 'b', 'c'
concat 會將陣列組合，之後變成全新的數組，如果以例子來說，a 陣列希望變成 ['a', 'b', 'c']，可以重新將數值分配給 a，範例來說
.. code-block:: js
a = a.concat(b);
陣列資料，必須要有 Iterator，將資料巡迴一次，通常是使用迴圈的方式，
.. code-block:: js
var a=['a', 'b', 'c'];
for(var i=0; i < a.length; i++) {
console.log(a[i]);
}
//print: a
// b
// c
事實上可以用更簡單的方式進行，
.. code-block:: js
var a=['a', 'b', 'c'];
a.forEach(function (val, idx) {
console.log(val, idx);
});
/*
print:
a, 0
b, 1
c, 2
*/
在 Array 裡面可以使用 foreach 的方式進行 iterator， 裡面給予的 function (匿名函式)，第一個變數為 Array 的 Value, 第二個變數為 Array 的指標。
其實使用 JavaScript 在網頁端與伺服器端的差距並不大，但是為了使 NodeJS 可以發揮他最強大的能力，有一些知識還是必要的，所以還是針對這些主題介紹一下。
其中 Event Loop、Scope 以及 Callback 其實是比較需要了解的基本知識， cps、currying、flow control是更進階的技巧與應用。
可能很多人在寫Javascript時，並不知道他是怎麼被執行的。這個時候可以參考一下jQuery作者John Resig一篇好文章，介紹事件及timer怎麼在瀏覽器中執行：How JavaScript Timers Work。通常在網頁中，所有的Javascript執行完畢後（這部份全部都在global scope跑，除非執行函數），接下來就是如John Resig解釋的這樣，所有的事件處理函數，以及timer執行的函數，會排在一個queue結構中，利用一個無窮迴圈，不斷從queue中取出函數來執行。這個就是event loop。
（除了John Resig的那篇文章，Nicholas C. Zakas的 "Professional Javascript for Web Developer 2nd edition" 有一個試閱本：http://yuiblog.com/assets/pdf/zakas-projs-2ed-ch18.pdf，598頁剛好也有簡短的說明）
所以在Javascript中，雖然有非同步，但是他並不是使用執行緒。所有的事件或是非同步執行的函數，都是在同一個執行緒中，利用event loop的方式在執行。至於一些比較慢的動作例如I/O、網頁render, reflow等，實際動作會在其他執行緒跑，等到有結果時才利用事件來觸發處理函數來處理。這樣的模型有幾個好處： 沒有執行緒的額外成本，所以反應速度很快 不會有任何程式同時用到同一個變數，不必考慮lock，也不會產生dead lock 所以程式撰寫很簡單 但是也有一些潛在問題： 任一個函數執行時間較長，都會讓其他函數更慢執行（因為一個跑完才會跑另一個） 在多核心硬體普遍的現在，無法用單一的應用程式instance發揮所有的硬體能力 用NodeJS撰寫伺服器程式，碰到的也是一樣的狀況。要讓系統發揮event loop的效能，就要盡量利用事件的方式來組織程式架構。另外，對於一些有可能較為耗時的操作，可以考慮使用 process.nextTick 函數來讓他以非同步的方式執行，避免在同一個函數中執行太久，擋住所有函數的執行。
如果想要測試event loop怎樣在「瀏覽器」中運行，可以在函數中呼叫alert()，這樣會讓所有Javascript的執行停下來，尤其會干擾所有使用timer的函數執行。有一個簡單的例子，這是一個會依照設定的時間間隔嚴格執行動作的動畫，如果時間過了就會跳過要執行的動作。點按圖片以後，人物會快速旋轉，但是在旋轉執行完畢前按下「delay」按鈕，讓alert訊息等久一點，接下來的動畫就完全不會出現了。
要快速理解 JavaScript 的 Scope（變數作用範圍）原理，只要記住他是Lexical Scope就差不多了。簡單地說，變數作用範圍是依照程式定義時（或者叫做程式文本？）的上下文決定，而不是執行時的上下文決定。
為了維護程式執行時所依賴的變數，即使執行時程式運行在原本的scope之外，他的變數作用範圍仍然維持不變。這時程式依賴的自由變數（定義時不是local的，而是在上一層scope定義的變數）一樣可以使用，就好像被關閉起來，所以叫做Closure。用程式看比較好懂：
.. code-block:: js
function outter(arg1) {
//arg1及free_variable1對inner函數來說，都是自由變數
var free_variable1 = 3;
return function inner(arg2) {
var local_variable1 =2;//arg2及local_variable1對inner函數來說，都是本地變數
return arg1 + arg2 + free_variable1 + local_variable1;
};
}
var a = outter(1);//變數a 就是outter函數執行後返回的inner函數
var b = a(4);//執行inner函數，執行時上下文已經在outter函數之外，但是仍然能正常執行，而且可以使用定義在outter函數裡面的arg1及free_variable1變數
console.log(b);//結果10
在Javascript中，scope最主要的單位是函數（另外有global及eval），所以有可能製造出closure的狀況，通常在形式上都是有巢狀的函數定義，而且內側的函數使用到定義在外側函數裡面的變數。
Closure有可能會造成記憶體洩漏，主要是因為被參考的變數無法被垃圾收集機制處理，造成佔用的資源無法釋放，所以使用上必須考慮清楚，不要造成意外的記憶體洩漏。（在上面的例子中，如果a一直未執行，使用到的記憶體就不會被釋放）
跟透過函數的參數把變數傳給函數比較起來，Javascript Engine會比較難對Closure進行最佳化。如果有效能上的考量，這一點也需要注意。
要介紹 Callback 之前， 要先提到 JavaScript 的特色。
JavaScript 是一種函數式語言（functional language），所有Javascript語言內的函數，都是高階函數(higher order function，這是數學名詞，計算機用語好像是first class function，意指函數使用沒有任何限制，與其他物件一樣)。也就是說，函數可以作為函數的參數傳給函數，也可以當作函數的返回值。這個特性，讓Javascript的函數，使用上非常有彈性，而且功能強大。
callback在形式上，其實就是把函數傳給函數，然後在適當的時機呼叫傳入的函數。Javascript使用的事件系統，通常就是使用這種形式。NodeJS中，有一個物件叫做EventEmitter，這是NodeJS事件處理的核心物件，所有會使用事件處理的函數，都會「繼承」這個物件。（這裡說的繼承，實作上應該像是mixin）他的使用很簡單： 可以使用 物件.on(事件名稱, callback函數) 或是 物件.addListener(事件名稱, callback函數) 把你想要處理事件的函數傳入 在 物件 中，可以使用 物件.emit(事件名稱, 參數...) 呼叫傳入的callback函數 這是Observer Pattern的簡單實作，而且跟在網頁中使用DOM的addEventListener使用上很類似，也很容易上手。不過NodeJS是大量使用非同步方式執行的應用，所以程式邏輯幾乎都是寫在callback函數中，當邏輯比較複雜時，大量的callback會讓程式看起來很複雜，也比較難單元測試。舉例來說：
.. code-block:: js
var p_client = new Db('integration_tests_20', new Server("127.0.0.1", 27017, {}), {'pk':CustomPKFactory});
p_client.open(function(err, p_client) {
p_client.dropDatabase(function(err, done) {
p_client.createCollection('test_custom_key', function(err, collection) {
collection.insert({'a':1}, function(err, docs) {
collection.find({'_id':new ObjectID("aaaaaaaaaaaa")}, function(err, cursor) {
cursor.toArray(function(err, items) {
test.assertEquals(1, items.length);
p_client.close();
});
});
});
});
});
});
這是在網路上看到的一段操作mongodb的程式碼，為了循序操作，所以必須在一個callback裡面呼叫下一個動作要使用的函數，這個函數裡面還是會使用callback，最後就形成一個非常深的巢狀。
這樣的程式碼，會比較難進行單元測試。有一個簡單的解決方式，是盡量不要使用匿名函數來當作callback或是event handler。透過這樣的方式，就可以對各個handler做單元測試了。例如：
.. code-block:: js
var http = require('http');
var tools = {
cookieParser: function(request, response) {
if(request.headers['Cookie']) {
//do parsing
}
}
};
var server = http.createServer(function(request, response) {
this.emit('init', request, response);
//...
});
server.on('init', tools.cookieParser);
server.listen(8080, '127.0.0.1');
更進一步，可以把tools改成外部module，例如叫做tools.js：
.. code-block:: js
module.exports = {
cookieParser: function(request, response) {
if(request.headers['Cookie']) {
//do parsing
}
}
};
然後把程式改成：
.. code-block:: js
var http = require('http');
var server = http.createServer(function(request, response) {
this.emit('init', request, response);
//...
});
server.on('init', require('./tools').cookieParser);
server.listen(8080, '127.0.0.1');
這樣就可以單元測試cookieParser了。例如使用nodeunit時，可以這樣寫：
.. code-block:: js
var testCase = require('nodeunit').testCase;
module.exports = testCase({
"setUp": function(cb) {
this.request = {
headers: {
Cookie: 'name1:val1; name2:val2'
}
};
this.response = {};
this.result = {name1:'val1',name2:'val2'};
cb();
},
"tearDown": function(cb) {
cb();
},
"normal_case": function(test) {
test.expect(1);
var obj = require('./tools').cookieParser(this.request, this.response);
test.deepEqual(obj, this.result);
test.done();
}
});
善於利用模組，可以讓程式更好維護與測試。
cps是callback使用上的特例，形式上就是在函數最後呼叫callback，這樣就好像把函數執行後把結果交給callback繼續運行，所以稱作continuation-passing style。利用cps，可以在非同步執行的情況下，透過傳給callback的這個cps callback來獲知callback執行完畢，或是取得執行結果。例如：
.. code-block:: html
<html>
<body>
<div id="panel" style="visibility:hidden"></div>
</body>
</html>
<script>
var request = new XMLHttpRequest();
request.open('GET', 'test749.txt?timestamp='+new Date().getTime(), true);
request.addEventListener('readystatechange', function(next){
return function() {
if(this.readyState===4&&this.status===200) {
next(this.responseText);//<==傳入的cps callback在動作完成時執行並取得結果進一步處理
}
};
}(function(str){//<==這個匿名函數就是cps callback
document.getElementById('panel').innerHTML=str;
document.getElementById('panel').style.visibility = 'visible';
}), false);
request.send();
</script>
進一步的應用，也可以參考2-6 流程控制。
前面的cps範例裡面，使用了函數返回函數，這是為了把cps callback傳遞給onreadystatechange事件處理函數的方法。（因為這個事件處理函數並沒有設計好會傳送/接收這樣的參數）實際會執行的事件處理函數其實是內層返回的那個函數，之外包覆的這個函數，主要是為了利用Closure，把next傳給內層的事件處理函數。這個方法更常使用的地方，是為了解決一些scope問題。例如：
.. code-block:: js
<script>
var accu=0,count=10;
for(var i=0; i<count; i++) {
setTimeout(
function(){
count--;
accu+=i;
if(count<=0)
console.log(accu)
}
, 50)
}
</script>
最後得出的結果會是100，而不是想像中的45，這是因為等到setTimeout指定的函數執行時，變數i已經變成10而離開迴圈了。要解決這個問題，就需要透過Closure來保存變數i：
.. code-block:: js
<script>
var accu=0,count=10;
for(var i=0; i<count; i++) {
setTimeout(
function(i) {
return function(){
count--;
accu+=i;
if(count<=0)
console.log(accu)
};
}(i)
, 50)
}
//淺藍色底色的部份，是跟上面例子不一樣的地方
</script>
函數返回函數的另外一個用途，是可以暫緩函數執行。例如：
.. code-block:: js
function add(m, n) {
return m+n;
}
var a = add(20, 10);
console.log(a);
add這個函數，必須同時輸入兩個參數，才有辦法執行。如果我希望這個函數可以先給它一個參數，等一些處理過後再給一個參數，然後得到結果，就必須用函數返回函數的方式做修改：
.. code-block:: js
function add(m) {
return function(n) {
return m+n;
};
}
var wait_another_arg = add(20);//先給一個參數
var a = function(arr) {
var ret=0;
for(var i=0;i<arr.length;i++) ret+=arr[i];
return ret;
}([1,2,3,4]);//計算一下另一個參數
var b = wait_another_arg(a);//然後再繼續執行
console.log(b);
像這樣利用函數返回函數，使得原本接受多個參數的函數，可以一次接受一個參數，直到參數接收完成才執行得到結果的方式，有一個學名就叫做...Currying
綜合以上許多奇技淫巧，就可以透過用函數來處理函數的方式，調整程式流程。接下來看看...
（以sync方式使用async函數、避開巢狀callback循序呼叫async callback等奇技淫巧）
建議參考：
這幾篇都是非常經典的NodeJS/Javascript流程控制好文章（阿，mixu是在介紹一些pattern時提到這方面的主題）。不過我還是用幾個簡單的程式介紹一下做法跟概念：
下面的程式參考了mixu文章中的做法：
.. code-block:: js
var wait = function(callbacks, done) {
console.log('wait start');
var counter = callbacks.length;
var results = [];
var next = function(result) {//接收函數執行結果，並判斷是否結束執行
results.push(result);
if(--counter == 0) {
done(results);//如果結束執行，就把所有執行結果傳給指定的callback處理
}
};
for(var i = 0; i < callbacks.length; i++) {//依次呼叫所有要執行的函數
callbacks[i](next);
}
console.log('wait end');
}
wait(
[
function(next){
setTimeout(function(){
console.log('done a');
var result = 500;
next(result)
},500);
},
function(next){
setTimeout(function(){
console.log('done b');
var result = 1000;
next(result)
},1000);
},
function(next){
setTimeout(function(){
console.log('done c');
var result = 1500;
next(1500)
},1500);
}
],
function(results){
var ret = 0, i=0;
for(; i<results.length; i++) {
ret += results[i];
}
console.log('done all. result: '+ret);
}
);
執行結果： wait start wait end done a done b done c done all. result: 3000
可以看出來，其實wait並不是真的等到所有函數執行完才結束執行，而是在所有傳給他的函數執行完畢後（不論同步、非同步），才執行處理結果的函數（也就是done()）
不過這樣的寫法，還不夠實用，因為沒辦法實際讓函數可以等待執行完畢，又能當作事件處理函數來實際使用。上面參考到的Tim Caswell的文章，裡面有一種解法，不過還需要額外包裝（在他的例子中）NodeJS核心的fs物件，把一些函數（例如readFile）用Currying處理。類似像這樣：
.. code-block:: js
var fs = require('fs');
var readFile = function(path) {
return function(callback, errback) {
fs.readFile(path, function(err, data) {
if(err) {
errback();
} else {
callback(data);
}
});
};
}
其他部份可以參考Tim Caswell的文章，他的Do.parallel跟上面的wait差不多意思，這裡只提示一下他沒說到的地方。
另外一種做法是去修飾一下callback，當他作為事件處理函數執行後，再用cps的方式取得結果：
.. code-block:: js
<script>
function Wait(fns, done) {
var count = 0;
var results = [];
this.getCallback = function(index) {
count++;
return (function(waitback) {
return function() {
var i=0,args=[];
for(;i<arguments.length;i++) {
args.push(arguments[i]);
}
args.push(waitback);
fns[index].apply(this, args);
};
})(function(result) {
results.push(result);
if(--count == 0) {
done(results);
}
});
}
}
var a = new Wait(
[
function(waitback){
console.log('done a');
var result = 500;
waitback(result)
},
function(waitback){
console.log('done b');
var result = 1000;
waitback(result)
},
function(waitback){
console.log('done c');
var result = 1500;
waitback(result)
}
],
function(results){
var ret = 0, i=0;
for(; i<results.length; i++) {
ret += results[i];
}
console.log('done all. result: '+ret);
}
);
var callbacks = [a.getCallback(0),a.getCallback(1),a.getCallback(0),a.getCallback(2)];
//一次取出要使用的callbacks，避免結果提早送出
setTimeout(callbacks[0], 500);
setTimeout(callbacks[1], 1000);
setTimeout(callbacks[2], 1500);
setTimeout(callbacks[3], 2000);
//當所有取出的callbacks執行完畢，就呼叫done()來處理結果
</script>
執行結果：
done a done b done a done c done all. result: 3500
上面只是一些小實驗，更成熟的作品是Tim Caswell的step：https://github.com/creationix/step
如果希望真正使用同步的方式寫非同步，則需要使用Promise.js這一類的library來轉換非同步函數，不過他結構比較複雜XD（見仁見智，不過有些人認為Promise有點過頭了）：http://blogs.msdn.com/b/rbuckton/archive/2011/08/15/promise-js-2-0-promise-framework-for-javascript.aspx
如果想不透過其他Library做轉換，又能直接用同步方式執行非同步函數，大概就要使用一些需要額外compile原始程式碼的方法了。例如Bruno Jouhier的streamline.js：https://github.com/Sage/streamlinejs
循序執行可以協助把非常深的巢狀callback結構攤平，例如用這樣的簡單模組來做（serial.js）：
.. code-block:: js
module.exports = function(funs) {
var c = 0;
if(!isArrayOfFunctions(funs)) {
throw('Argument type was not matched. Should be array of functions.');
}
return function() {
var args = Array.prototype.slice.call(arguments, 0);
if(!(c>=funs.length)) {
c++;
return funs[c-1].apply(this, args);
}
};
}
function isArrayOfFunctions(f) {
if(typeof f !== 'object') return false;
if(!f.length) return false;
if(!f.concat) return false;
if(!f.splice) return false;
var i = 0;
for(; i<f.length; i++) {
if(typeof f[i] !== 'function') return false;
}
return true;
}
簡單的測試範例（testSerial.js），使用fs模組，確定某個path是檔案，然後讀取印出檔案內容。這樣會用到兩層的callback，所以測試中有使用serial的版本與nested callbacks的版本做對照：
.. code-block:: js
var serial = require('./serial'),
fs = require('fs'),
path = './dclient.js',
cb = serial([
function(err, data) {
if(!err) {
if(data.isFile) {
fs.readFile(path, cb);
}
} else {
console.log(err);
}
},
function(err, data) {
if(!err) {
console.log('[flattened by searial:]');
console.log(data.toString('utf8'));
} else {
console.log(err);
}
}
]);
fs.stat(path, cb);
fs.stat(path, function(err, data) {
//第一層callback
if(!err) {
if(data.isFile) {
fs.readFile(path, function(err, data) {
//第二層callback
if(!err) {
console.log('[nested callbacks:]');
console.log(data.toString('utf8'));
} else {
console.log(err);
}
});
} else {
console.log(err);
}
}
});
關鍵在於，這些callback的執行是有順序性的，所以利用serial返回的一個函數cb來取代這些callback，然後在cb中控制每次會循序呼叫的函數，就可以把巢狀的callback攤平成循序的function陣列（就是傳給serial函數的參數）。
測試中的./dclient.js是一個簡單的dnode測試程式，放在跟testSerial.js同一個目錄：
.. code-block:: js
var dnode = require('dnode');
dnode.connect(8000, 'localhost', function(remote) {
remote.restart(function(str) {
console.log(str);
process.exit();
});
});
執行測試程式後，出現結果：
[flattened by searial:]
.. code-block:: js
var dnode = require('dnode');
dnode.connect(8000, 'localhost', function(remote) {
remote.restart(function(str) {
console.log(str);
process.exit();
});
});
[nested callbacks:]
.. code-block:: js
var dnode = require('dnode');
dnode.connect(8000, 'localhost', function(remote) {
remote.restart(function(str) {
console.log(str);
process.exit();
});
});
對照起來看，兩種寫法的結果其實是一樣的，但是利用serial.js，巢狀的callback結構就會消失。
不過這樣也只限於順序單純的狀況，如果函數執行的順序比較複雜（不只是一直線），還是需要用功能更完整的流程控制模組比較好，例如 https://github.com/caolan/async 。