這是一份完整的 Node.js 入門教程。我們會從最簡單的一行程式開始,最後完成一個能讓使用者上傳圖片並在瀏覽器中檢視的小型 Web 應用。應用本身沒什麼了不起,真正的收穫是過程中學到的那些 JavaScript 概念。
目標讀者是這樣的人:對 Ruby、Python、PHP 或 Java 這類語言有一定經驗,JavaScript 還在初學階段,而且完全沒碰過 Node.js。
因此本文不會解釋資料型別、變數、控制結構這些基礎概念,這些預設你已經會了。但 JavaScript 的函式與物件會講得比較仔細,因為它們與其他語言的對應概念差異相當大。
程式碼範例均在 Node.js 0.6.x 版本測試通過。較新版本的 Node.js 在部分 API 上已有變動(例如 sys.inspect 已改為 util.inspect),概念不變,套用的時候替換掉即可。
完成後你會得到一個能瀏覽頁面、能上傳檔案的 Web 應用。我們會先談 Node.js 與瀏覽器環境的差異,接著做一個最傳統的 Hello World,最後逐步剖析一個完整應用需要哪些模組、以及如何把它們乾淨地剝離開來。
如果你和我一樣,是很早就開始寫 HTML、順便接觸到 JavaScript 這個有趣東西的人,最初只會用它做一些頁面互動。後來為了寫「真正的後端」,去學了 PHP、Ruby 或 Java。同時也一路關注著 JavaScript,透過 jQuery、Prototype 這些技術慢慢發現它遠比 window.open() 複雜。
但那些畢竟是前端技術。你可能很享受用 jQuery 增強頁面的感覺,但到最後,你頂多是個 JavaScript 使用者,而不是開發者。
然後 Node.js 出現了——伺服器端的 JavaScript。於是你想重新拾起這個既熟悉又陌生的語言。但這裡有個關鍵區別:寫得出 Node.js 程式是一回事,理解「為什麼要這樣寫」是另一回事,後者需要你真正懂 JavaScript。
問題在於,JavaScript 存在好幾種形態——從 90 年代用來增強 DHTML 的小玩具,到 jQuery 那樣嚴謹的前端工具,再到現在的伺服器技術。要找到一條正確的學習路徑並不容易。市面上不乏優秀的文章,但有時候光靠文章遠遠不夠,你需要的是一條完整的路線。
JavaScript 最早跑在瀏覽器裡,但瀏覽器只是一個上下文,它定義了「用 JavaScript 可以做什麼」,並沒有說明語言本身的能力邊界。事實上 JavaScript 是一門完整的語言,可以運行於不同環境,能力與同類語言相比毫不遜色。
Node.js 就是另一個上下文,讓 JavaScript 可以在後端(脫離瀏覽器)運行。它使用 Google 的 V8 引擎來解釋執行 JavaScript 程式碼,並附帶大量實用模組,簡化許多重複工作。
所以 Node.js 既是執行環境,同時也是一個函式庫。
建立 helloworld.js:
console.log("Hello World");
執行:
node helloworld.js
終端機上出現 Hello World,就成了。
目標設定得簡單實際一點:
/start 時看到一個歡迎頁面,上面有檔案上傳表單。/upload,該頁顯示上傳後的圖片。更重要的是,我們不只寫出能跑的程式碼,還要對它做抽象,找出適合建構更複雜應用的組織方式。
用 PHP 的話,我們會用 Apache 搭配 mod_php,「接收請求並提供網頁」這件事根本不需要 PHP 參與。Node.js 的概念完全不同:我們不只實作一個應用,同時也實作了整個 HTTP 伺服器。應用與伺服器基本上是同一樣東西。聽起來工作量很大,但對 Node.js 來說並不麻煩。
寫第一個真正的 Node.js 應用時,我完全不知道該把程式碼放哪。網上多數教程把全部邏輯塞進一個檔案,但若想加入更多內容又保持可讀性呢?
實際上,只要把不同功能的程式碼放進不同模組,保持分離相當容易。這樣你會有一個乾淨的主檔案,以及一組可被主檔案或其他模組呼叫的模組。
慣例上主檔案叫 index.js,伺服器模組叫 server.js。
// server.js
var http = require("http");
http.createServer(function(request, response) {
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}).listen(8888);
執行 node server.js,打開瀏覽器拜訪 https://localhost:8888/,會看到寫著 Hello World 的網頁。
第一行請求 Node.js 內建的 http 模組,指派給 http 變數。接著呼叫 http.createServer(),它回傳一個物件,該物件有個 listen 方法,參數是監聽的連接埠。
我們也可以寫成這樣,效果相同:
var http = require("http");
var server = http.createServer();
server.listen(8888);
這段程式只會啟動一個監聽 8888 的伺服器,收到請求也不會回應任何東西。
最有趣的部分是 createServer() 的那個參數——一個函式定義。
function say(word) {
console.log(word);
}
function execute(someFunction, value) {
someFunction(value);
}
execute(say, "Hello");
請仔細看:我們把 say 本身當作參數傳給 execute,傳的不是它的回傳值。於是 say 在 execute 內部成了區域變數 someFunction,可以用 someFunction() 呼叫。
我們也可以不繞「先定義、再傳遞」的圈子,直接在呼叫處定義:
execute(function(word) { console.log(word) }, "Hello");
這樣甚至不需要替函式命名,這就是所謂的匿名函式。
帶著這個知識回頭看:
var http = require("http");
http.createServer(function(request, response) {
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}).listen(8888);
我們向 createServer 傳了一個匿名函式。等價寫法:
function onRequest(request, response) {
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}
http.createServer(onRequest).listen(8888);
為什麼要這樣寫?因為 Node.js 是事件驅動的,這也是它快的原因。
我們不只要一個監聽連接埠的伺服器,還要它在收到請求時做點事。而請求隨時可能到達,伺服器卻跑在單一執行緒裡。
寫 PHP 時不必擔心這個:請求進來時,網頁伺服器(通常是 Apache)就開一個行程,從頭到尾跑完對應的 PHP 腳本。
那在 Node.js 中怎麼控制流程?答案就是事件驅動設計。我們建立伺服器時傳了一個函式進去,每當伺服器收到請求,這個函式就會被呼叫。我們不知道它何時被呼叫,但我們有了一個處理請求的地方。這就是回呼:把函式傳給某個方法,該方法在對應事件發生時呼叫它。
怎麼證明「建立伺服器後,即使沒有請求進來,程式仍然繼續執行」?試試這個:
var http = require("http");
function onRequest(request, response) {
console.log("Request received.");
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
執行 node server.js,命令列立刻顯示「Server has started.」。而在瀏覽器拜訪 https://localhost:8888/ 時,「Request received.」才會出現。
這就是事件驅動的異步伺服器端 JavaScript。(順帶一提,你可能會看到「Request received.」出現兩次,那是因為瀏覽器會順便索取 favicon.ico。)
回呼觸發時,onRequest 收到兩個參數:request 與 response。它們都是物件,可以用其方法處理請求細節並回應。
我們的程式碼用 response.writeHead() 送出狀態碼 200 與 Content-Type 標頭,用 response.write() 在回應主體中送出文字,最後用 response.end() 收尾。目前我們不在意請求細節,所以沒用到 request。
我們已經在用模組了:require("http") 把 http 模組的所有公開方法綁到一個區域變數上。變數名稱跟模組同名只是慣例,叫 foo 也完全可以。
要讓 server.js 成為真正的模組,只需把要對外提供的部分匯出:
// server.js
var http = require("http");
function start() {
function onRequest(request, response) {
console.log("Request received.");
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
}
exports.start = start;
建立 index.js:
var server = require("./server");
server.start();
執行 node index.js,效果與之前相同,但我們現在可以把不同部分放進不同檔案了。
我們要提供請求的 URL 與 GET/POST 參數給路由,路由再據此執行對應程式碼。解析 URL 需要 url 與 querystring 兩個模組:
var http = require("http");
var url = require("url");
function start(route) {
function onRequest(request, response) {
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");
route(pathname);
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
}
exports.start = start;
建立 router.js:
function route(pathname) {
console.log("About to route a request for " + pathname);
}
exports.route = route;
這段程式什麼也沒做,但現在這樣是應該的。
伺服器要知道路由的存在。我們可以硬編碼,但過往經驗告訴我那是件痛苦的事,所以改用依賴注入,鬆散地把路由模組加進來。
// server.js 中的 start 接受 route 參數
function start(route) {
function onRequest(request, response) {
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");
route(pathname);
// ...
}
// ...
}
// index.js
var server = require("./server");
var router = require("./router");
server.start(router.route);
執行後請求一個 URL,會看到類似輸出:
Request for /foo received.
About to route a request for /foo
把函式當參數傳遞不只是技術考量,也是設計哲學。想想這個場景:我們可以把 router 物件傳進去,讓伺服器呼叫它的 route 方法。「嘿那個叫路由的東西,能幫我把這個路由一下嗎?」
但伺服器其實不需要這樣的東西,它只需要把事情做完。而為了把事情做完,你需要的往往不是名詞,是動詞。理解這個轉換之後,我自然理解了函式編程。有興趣可以讀讀 Steve Yegge 的〈名詞王國中的死刑〉。
路由顧名思義要針對不同 URL 有不同處理方式。處理 /start 的邏輯應該與 /upload 不同。若路由在自己這裡就「結束」,應用變複雜時將無法擴展。我們把路由的目標函式稱為請求處理函式。
建立 requestHandlers.js:
function start() {
console.log("Request handler 'start' was called.");
}
function upload() {
console.log("Request handler 'upload' was called.");
}
exports.start = start;
exports.upload = upload;
我們需要把處理函式從路由傳進去。真實應用中處理函式會不斷增加,我們不想每加一個 URL 就改一次路由,也不想在路由裡堆一大堆 if。
仔細想:有一堆東西,每個要對應到一個字串(請求的 URL)——關聯陣列似乎完美勝任。JavaScript 沒有關聯陣列,但它有物件,而物件就是鍵/值對的集合。而且值可以是函式。
// index.js
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");
var handle = {};
handle["/"] = requestHandlers.start;
handle["/start"] = requestHandlers.start;
handle["/upload"] = requestHandlers.upload;
server.start(router.route, handle);
這樣把多個 URL 對應到同一個處理函式非常容易——只要多加一個鍵。
// server.js
function start(route, handle) {
function onRequest(request, response) {
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");
route(handle, pathname);
// ...
}
// ...
}
// router.js
function route(handle, pathname) {
console.log("About to route a request for " + pathname);
if (typeof handle[pathname] === 'function') {
handle[pathname]();
} else {
console.log("No request handler found for " + pathname);
}
}
exports.route = route;
handle[pathname]() 這個寫法乾淨又流暢,讀起來就像在說:「嘿,請幫我處理這個路徑」。
拜訪 /start 時的日誌:
Server has started.
Request for /start received.
About to route a request for /start
Request handler 'start' was called.
目前畫面上的「Hello World」仍來自 server.js 的 onRequest。「處理請求」說穿了就是「對請求做出回應」,所以處理函式需要能跟瀏覽器對話。
對有 PHP 或 Ruby 背景的人來說,最直覺的做法是讓處理函式用 return 回傳要顯示的內容:
// requestHandlers.js
function start() {
console.log("Request handler 'start' was called.");
return "Hello Start";
}
function upload() {
console.log("Request handler 'upload' was called.");
return "Hello Upload";
}
// router.js 也把結果往上傳
function route(handle, pathname) {
if (typeof handle[pathname] === 'function') {
return handle[pathname]();
} else {
return "404 Not found";
}
}
// server.js 把結果寫進回應
var content = route(handle, pathname);
response.write(content);
response.end();
跑起來完全正常:/start 顯示 Hello Start,/upload 顯示 Hello Upload,其他路徑顯示 404。
問題在哪?當未來有處理函式需要執行非阻塞操作時,整個應用就掛了。
我們在 start 處理函式中加入一個模擬的長時間操作:
function start() {
console.log("Request handler 'start' was called.");
function sleep(milliSeconds) {
var startTime = new Date().getTime();
while (new Date().getTime() < startTime + milliSeconds);
}
sleep(10000);
return "Hello Start";
}
現在做個實驗:開兩個分頁,先在第一个輸入 /start 但不按 Enter,第二個輸入 /upload 也不按。然後在第一个分頁按 Enter,立刻切到第二個按 Enter。
結果:兩個 URL 都花了 10 秒。而 upload 的處理函式裡根本沒有 sleep。
原因很簡單:start 裡的阻塞操作把其他所有工作都擋住了。
這是個大問題,因為 Node 向來標榜「除了你的程式碼,一切都是並行執行的」。這句話的意思是:Node.js 可以在不新增額外執行緒的情況下並行處理任務——它是單執行緒的,靠事件輪詢(event loop)實現並行。所以我們應該盡量避免阻塞操作,多用非阻塞操作。
而非阻塞操作要用回呼:把函式當參數傳給那些需要時間的函式(休眠、查資料庫、大量計算)。Node.js 的態度是:「嘿,expensiveFunction(),你繼續做你的事,我先不等你了,我去處理後面的程式碼,請給我一個回呼函式,你做完我再呼叫它。」
var exec = require("child_process").exec;
function start() {
console.log("Request handler 'start' was called.");
var content = "empty";
exec("ls -lah", function (error, stdout, stderr) {
content = stdout;
});
return content;
}
exec() 從 Node.js 執行一個 shell 命令。這裡我們用它列出當前目錄的檔案。
執行後拜訪 /start,頁面顯示的是「empty」。
原因在於:我們的程式碼是同步執行的。呼叫 exec 之後,Node.js 立刻執行 return content,此時回呼還沒跑,content 仍是 "empty"。如果把 ls -lah 換成 find / 這種更耗時的命令,你會看到回應依然立刻返回——Node.js 在背景執行 exec 的同時繼續往下跑了。
與其把內容傳給伺服器,不如把伺服器「傳給」內容。具體說,就是把 response 物件透過路由傳給請求處理函式,讓它自己呼叫該物件上的方法來回應。
// server.js
function start(route, handle) {
function onRequest(request, response) {
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");
route(handle, pathname, response);
}
// ...
}
// router.js
function route(handle, pathname, response) {
console.log("About to route a request for " + pathname);
if (typeof handle[pathname] === 'function') {
handle[pathname](response);
} else {
response.writeHead(404, {"Content-Type": "text/plain"});
response.write("404 Not found");
response.end();
}
}
// requestHandlers.js
var exec = require("child_process").exec;
function start(response) {
console.log("Request handler 'start' was called.");
exec("ls -lah", function (error, stdout, stderr) {
response.writeHead(200, {"Content-Type": "text/plain"});
response.write(stdout);
response.end();
});
}
function upload(response) {
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello Upload");
response.end();
}
關鍵在於:start 把回應動作放進 exec 的回呼裡,而不是試圖在函式返回時就拿到結果。
如果把命令換成 find / 並加上逾時設定,你會看到 /start 要等十秒,而 /upload 立刻回應,即使此時 /start 還在處理中。
先做個簡單例子:顯示一個文字輸入區,使用者填完送出,伺服器把內容顯示回來。
function start(response) {
var body = '<html>' +
'<head>' +
'<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />' +
'</head>' +
'<body>' +
'<form action="/upload" method="post">' +
'<textarea name="text" rows="20" cols="60"></textarea>' +
'<input type="submit" value="Submit text" />' +
'</form>' +
'</body>' +
'</html>';
response.writeHead(200, {"Content-Type": "text/html"});
response.write(body);
response.end();
}
把視覺元素直接寫在處理函式裡確實不漂亮,但本文重點是理解 JavaScript 與 Node.js,不打算引入 MVC 這類模式。
接下來處理使用者送出的 POST 資料。這裡必須用非阻塞方式,因為 POST 內容通常不小,阻塞處理會讓使用者卡住。
Node.js 會把 POST 資料拆成小區塊,透過事件交給回呼:data 事件代表新區塊到達,end 事件代表全部收完。我們在 request 物件上註冊監聽器:
request.addListener("data", function(chunk) {
// 收到新的資料區塊
});
request.addListener("end", function() {
// 所有資料都收完了
});
這些邏輯放哪裡?我認為「收集請求中的所有資料,再交給應用層」應該是 HTTP 伺服器的職責。因此直接在伺服器中處理,最後把完整資料傳給路由與處理函式:
// server.js
var http = require("http");
var url = require("url");
function start(route, handle) {
function onRequest(request, response) {
var postData = "";
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");
request.setEncoding("utf8");
request.addListener("data", function(postDataChunk) {
postData += postDataChunk;
console.log("Received POST data chunk '" + postDataChunk + "'.");
});
request.addListener("end", function() {
route(handle, pathname, response, postData);
});
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
}
exports.start = start;
這段程式做了三件事:設定編碼為 UTF-8;註冊 data 監聽器收集每個區塊;把路由呼叫移到 end 處理函式中,確保資料收完才觸發、且只觸發一次。
每個區塊都印日誌在正式環境很不妥(資料量可能極大),但開發階段很有用。試著輸入一小段文字和大段文字,你會發現後者觸發了多次 data 事件。
// router.js
function route(handle, pathname, response, postData) {
if (typeof handle[pathname] === 'function') {
handle[pathname](response, postData);
} else {
response.writeHead(404, {"Content-Type": "text/plain"});
response.write("404 Not found");
response.end();
}
}
// requestHandlers.js
function upload(response, postData) {
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("You've sent: " + postData);
response.end();
}
最後,我們其實只想要 text 這個欄位,用 querystring 模組解析:
var querystring = require("querystring");
function upload(response, postData) {
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("You've sent the text: " + querystring.parse(postData).text);
response.end();
}
最終用例:允許使用者上傳圖片並顯示出來。透過它我們能學到兩件事:如何安裝外部模組,以及如何把它套進應用裡。
我們用 Felix Geisendörfer 開發的 node-formidable 模組,它把解析上傳檔案的細節做了很好的抽象。說到底,「處理檔案上傳」就是處理 POST 資料,只是細節繁瑣,用現成方案更合適。
Node.js 有自己的套件管理器 NPM:
npm install formidable
看到類似下面的輸出就代表安裝成功:
npm info build Success: formidable@1.0.9
npm ok
使用外部模組與內部模組一樣,用 require 引入:
var formidable = require("formidable");
它的用法是建立一個 IncomingForm 實例(對提交表單的抽象表示),再解析 request 物件取得欄位與檔案:
var formidable = require('formidable'),
http = require('http'),
util = require('util');
http.createServer(function(req, res) {
if (req.url == '/upload' && req.method.toLowerCase() == 'post') {
var form = new formidable.IncomingForm();
form.parse(req, function(err, fields, files) {
res.writeHead(200, {'content-type': 'text/plain'});
res.write('received upload:\n\n');
res.end(util.inspect({fields: fields, files: files}));
});
return;
}
// 顯示上傳表單
res.writeHead(200, {'content-type': 'text/html'});
res.end(
'<form action="/upload" enctype="multipart/form-data" ' +
'method="post">' +
'<input type="text" name="title"><br>' +
'<input type="file" name="upload" multiple="multiple"><br>' +
'<input type="submit" value="Upload">' +
'</form>'
);
}).listen(8888);
回呼收到的 files 物件大致如下:
{ fields: { title: 'Hello World' },
files:
{ upload:
{ size: 1558,
path: '/tmp/1c747974a27a6292743669e91f29350b',
name: 'us-flag.png',
type: 'image/png',
lastModifiedDate: ...,
_writeStream: [Object],
length: [Getter],
filename: [Getter],
mime: [Getter] } } }
接下來要解決的是:檔案存在 /tmp,怎麼在瀏覽器中看到它?答案是把檔案讀進伺服器,用 fs 模組。
先加一個 /show 處理函式,直接顯示 /tmp/test.png:
var querystring = require("querystring"),
fs = require("fs");
function show(response) {
console.log("Request handler 'show' was called.");
fs.readFile("/tmp/test.png", "binary", function(error, file) {
if (error) {
response.writeHead(500, {"Content-Type": "text/plain"});
response.write(error + "\n");
response.end();
} else {
response.writeHead(200, {"Content-Type": "image/png"});
response.write(file, "binary");
response.end();
}
});
}
exports.show = show;
別忘了在 index.js 的路由表補上:
handle["/show"] = requestHandlers.show;
重啟伺服器後拜訪 /show,就能看到該圖片。
要做的三件事:在 /start 表單中加上檔案上傳元件;在 upload 處理函式中用 node-formidable 把圖片存成 /tmp/test.png;在 /upload 的回應中內嵌該圖片。
第一件事很簡單——加上 enctype="multipart/form-data",移除文字輸入區,換成檔案元件:
'<form action="/upload" enctype="multipart/form-data" ' +
'method="post">' +
'<input type="file" name="upload" multiple="multiple">' +
'<input type="submit" value="Upload file" />' +
'</form>'
第二件事有個障礙:form.parse 需要 request 物件,但我們手上只有 response 與 postData。看來只能把 request 從伺服器一路傳到處理函式。順帶的好處是,我們可以把 postData 整個移除——不但上傳用不到它,而且它已經被「消耗」掉了,Node.js 不會緩存請求資料,form.parse 屆時什么也拿不到。
// server.js:移除 postData 與 setEncoding,改傳 request
function start(route, handle) {
function onRequest(request, response) {
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");
route(handle, pathname, response, request);
}
// ...
}
// router.js
function route(handle, pathname, response, request) {
if (typeof handle[pathname] === 'function') {
handle[pathname](response, request);
} else {
response.writeHead(404, {"Content-Type": "text/html"});
response.write("404 Not found");
response.end();
}
}
然後在 upload 中使用 node-formidable。它會把上傳檔案存到暫存目錄,我們用 fs.renameSync() 改名成 /tmp/test.png。要注意這個方法是同步的,若操作耗時就會阻塞,這裡先不深究。
var querystring = require("querystring"),
fs = require("fs"),
formidable = require("formidable");
function start(response) {
var body = '<html>' +
'<head>' +
'<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />' +
'</head>' +
'<body>' +
'<form action="/upload" enctype="multipart/form-data" method="post">' +
'<input type="file" name="upload" multiple="multiple">' +
'<input type="submit" value="Upload file" />' +
'</form>' +
'</body>' +
'</html>';
response.writeHead(200, {"Content-Type": "text/html"});
response.write(body);
response.end();
}
function upload(response, request) {
console.log("Request handler 'upload' was called.");
var form = new formidable.IncomingForm();
console.log("about to parse");
form.parse(request, function(error, fields, files) {
console.log("parsing done");
fs.renameSync(files.upload.path, "/tmp/test.png");
response.writeHead(200, {"Content-Type": "text/html"});
response.write("received image:<br/>");
response.write("<img src='/show' />");
response.end();
});
}
function show(response) {
fs.readFile("/tmp/test.png", "binary", function(error, file) {
if (error) {
response.writeHead(500, {"Content-Type": "text/plain"});
response.write(error + "\n");
response.end();
} else {
response.writeHead(200, {"Content-Type": "image/png"});
response.write(file, "binary");
response.end();
}
});
}
exports.start = start;
exports.upload = upload;
exports.show = show;
重啟伺服器,選一張本機圖片上傳,瀏覽器就會把它顯示出來。
恭喜,我們完成了一個雖小但五臟俱全的 Node.js Web 應用。過程中我們談到了:伺服器端 JavaScript、函式式編程、阻塞與非阻塞、回呼、事件、內部與外部模組、依賴注入。
本文沒涵蓋的還有很多:資料庫操作、單元測試、撰寫自己的外部模組、取得 GET 參數的方法等等。入門教程不可能涵蓋一切。
幸好 Node.js 社群非常活躍,遇到問題幾乎都能找到答案。官方 wiki 與 NodeCloud 都是不錯的起點。
回頭看這份程式碼,有幾處在正式專案中一定要改:
檔案上傳沒有任何驗證。範例直接信任上傳的內容,這是嚴重的安全問題。實務上至少要檢查檔案實際型別、限制大小、使用隨機檔名,並在上傳目錄停用程式碼執行。
fs.renameSync 會阻塞。雖然檔案小看不出來,但同步 API 在事件迴圈中是禁忌,改用 fs.rename 的非同步版本。
路徑寫死。/tmp/test.png 在多使用者環境下會互相覆蓋,應該用工作階段或隨機識別碼區分。
手寫 HTML 字串。規模一大就難以維護,此時該引入模板引擎。
Express 之類的框架。本文手寫的伺服器、路由、請求處理分層,正是 Express 的核心設計。理解原理之後再看框架,會發現它並不神秘——它只是把這些模式做得更完整、更好用。