DIV CSS 佈局教程網

Node.js 入門完整教學:從 Hello World 到可用的檔案上傳應用
編輯:JavaScript基礎知識     

這是一份完整的 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,最後逐步剖析一個完整應用需要哪些模組、以及如何把它們乾淨地剝離開來。

JavaScript 與 Node.js

如果你和我一樣,是很早就開始寫 HTML、順便接觸到 JavaScript 這個有趣東西的人,最初只會用它做一些頁面互動。後來為了寫「真正的後端」,去學了 PHP、Ruby 或 Java。同時也一路關注著 JavaScript,透過 jQuery、Prototype 這些技術慢慢發現它遠比 window.open() 複雜。

但那些畢竟是前端技術。你可能很享受用 jQuery 增強頁面的感覺,但到最後,你頂多是個 JavaScript 使用者,而不是開發者。

然後 Node.js 出現了——伺服器端的 JavaScript。於是你想重新拾起這個既熟悉又陌生的語言。但這裡有個關鍵區別:寫得出 Node.js 程式是一回事,理解「為什麼要這樣寫」是另一回事,後者需要你真正懂 JavaScript。

問題在於,JavaScript 存在好幾種形態——從 90 年代用來增強 DHTML 的小玩具,到 jQuery 那樣嚴謹的前端工具,再到現在的伺服器技術。要找到一條正確的學習路徑並不容易。市面上不乏優秀的文章,但有時候光靠文章遠遠不夠,你需要的是一條完整的路線。

Node.js 到底是什麼

JavaScript 最早跑在瀏覽器裡,但瀏覽器只是一個上下文,它定義了「用 JavaScript 可以做什麼」,並沒有說明語言本身的能力邊界。事實上 JavaScript 是一門完整的語言,可以運行於不同環境,能力與同類語言相比毫不遜色。

Node.js 就是另一個上下文,讓 JavaScript 可以在後端(脫離瀏覽器)運行。它使用 Google 的 V8 引擎來解釋執行 JavaScript 程式碼,並附帶大量實用模組,簡化許多重複工作。

所以 Node.js 既是執行環境,同時也是一個函式庫。

Hello World

建立 helloworld.js:

console.log("Hello World");

執行:

node helloworld.js

終端機上出現 Hello World,就成了。

要做的應用:用例

目標設定得簡單實際一點:

  1. 使用者可以透過瀏覽器使用我們的應用。
  2. 請求 /start 時看到一個歡迎頁面,上面有檔案上傳表單。
  3. 使用者選擇圖片並送出,檔案上傳到 /upload,該頁顯示上傳後的圖片。

更重要的是,我們不只寫出能跑的程式碼,還要對它做抽象,找出適合建構更複雜應用的組織方式。

拆解應用需要哪些部分

  1. 提供網頁,需要一個 HTTP 伺服器。
  2. 依請求的 URL 給不同回應,需要一個路由。
  3. 請求被路由之後要能被處理,需要請求處理函式。
  4. 路由要能處理 POST 資料並整理成友善的格式,需要請求資料處理。
  5. 要把內容顯示出來,需要視圖邏輯。
  6. 要能上傳圖片,需要上傳處理功能。

用 PHP 的話,我們會用 Apache 搭配 mod_php,「接收請求並提供網頁」這件事根本不需要 PHP 參與。Node.js 的概念完全不同:我們不只實作一個應用,同時也實作了整個 HTTP 伺服器。應用與伺服器基本上是同一樣東西。聽起來工作量很大,但對 Node.js 來說並不麻煩。

一個基礎的 HTTP 伺服器

寫第一個真正的 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");

這樣甚至不需要替函式命名,這就是所謂的匿名函式。

回呼:Node.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);

我們向 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 有不同反應

我們要提供請求的 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 傳進去

與其把內容傳給伺服器,不如把伺服器「傳給」內容。具體說,就是把 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 還在處理中。

處理 POST 請求

先做個簡單例子:顯示一個文字輸入區,使用者填完送出,伺服器把內容顯示回來。

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 的核心設計。理解原理之後再看框架,會發現它並不神秘——它只是把這些模式做得更完整、更好用。

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