Node.js

簡單的說 Node.js 就是運行在服務端的 JavaScript。
Node.js 是一個基於Chrome JavaScript 運行時創建的一個平臺。
Node.js是一個事件驅動I/O服務端JavaScript環境，基於Google的V8引擎，V8引擎執行Javascript的速度很是快，性能很是好。
。。。。。。
Node.js教程適用人羣
對於不會運用Python、PHP以及Java等動態編程語言的前端程序員來講，選擇Node.js做爲一個建立本身的服務的工具是很是明智的。
Node.js是運行在服務端的JavaScript，所以，熟悉Javascript的使用將有助於學習Node.js。
同時，學習該Node.js教程也能夠幫助後端程序員部署一些高性能的服務。
。。。。。。
安裝環境本身去配置，選擇本身須要的就能夠了， node.js下載地址：http://www.nodejs.org/en/download/
。。。。。。
咱們先了解下Node.js應用是由哪幾部分組成的：

1. 引入required模塊：咱們可使用require指令來載入Node.js模塊。
   http:/ /www.iis7.com/b/wzjk/
2. 建立服務器：服務器能夠監聽客戶端的請求，相似於Apache 、Nginx等HTTP服務器。
3. 接收請求與響應請求：服務器很容易建立，客戶端可使用瀏覽器或終端發送HTTP請求，服務器接收請求後返回響應數據。
   。。。。。。
   Node.js NPM(網絡性能監控器，node包管理器) 使用介紹
   NPM是隨同Node.js一塊兒安裝的包管理工具，能解決Node.js代碼部署上的不少問題，常見的使用場景有如下幾種：
   容許用戶從NPM服務器下載別人編寫的第三方包到本地使用。
   容許用戶從NPM服務器下載並安裝別人編寫的命令行程序到本地使用。
   容許用戶將本身編寫的包或命令行程序上傳到NPM服務器供別人使用。
   版本號：：
   使用NPM下載和發佈代碼時都會接觸到版本號。NPM使用語義版本號來管理代碼，這裏簡單介紹一下。
   語義版本號分爲X.Y.Z三位，分別表明主版本號、次版本號和補丁版本號。當代碼變動時，版本號按如下原則更新。
   若是隻是修復bug，須要更新Z位。
   若是是新增了功能，可是向下兼容，須要更新Y位。
   若是有大變更，向下不兼容，須要更新X位。
   版本號有了這個保證後，在申明第三方包依賴時，除了可依賴於一個固定版本號外，還可依賴於某個範圍的版本號。例如"argv": "0.0.x"表示依賴於0.0.x系列的最新版argv。
   NPM經常使用命令：：
   NPM還提供了不少功能，package.json裏也有不少其它有用的字段。
   除了能夠在npmjs.org/doc/查看官方文檔外，這裏再介紹一些NPM經常使用命令。
   NPM提供了不少命令，例如install和publish，使用npm help可查看全部命令。
   NPM提供了不少命令，例如install和publish，使用npm help可查看全部命令。
   使用npm help <command>可查看某條命令的詳細幫助，例如npm help install。
   在package.json所在目錄下使用npm install . -g可先在本地安裝當前命令行程序，可用於發佈前的本地測試。
   使用npm update <package>能夠把當前目錄下node_modules子目錄裏邊的對應模塊更新至最新版本。
   使用npm update <package> -g能夠把全局安裝的對應命令行程序更新至最新版。
   使用npm cache clear能夠清空NPM本地緩存，用於對付使用相同版本號發佈新版本代碼的人。
   使用npm unpublish <package>@<version>能夠撤銷發佈本身發佈過的某個版本代碼。
   ::::::::::::::::::::::::::::::::::::::::::::::::::::::
   Node.js REPL(交互式解釋器)
   Node.js REPL(Read Eval Print Loop:交互式解釋器) 表示一個電腦的環境，相似 Window 系統的終端或 Unix/Linux shell，咱們能夠在終端中輸入命令，並接收系統的響應。
   REPL 的交互式的編程環境能夠實時的驗證你所編寫的代碼，很是適合於驗證 Node.js 和 JavaScript 的相關 API。
   Node 自帶了交互式解釋器，能夠執行如下任務：
   讀取 - 讀取用戶輸入，解析輸入了Javascript 數據結構並存儲在內存中。
   執行 - 執行輸入的數據結構
   打印 - 輸出結果
   循環 - 循環操做以上步驟直到用戶兩次按下 ctrl-c 按鈕退出。
   Node 的交互式解釋器能夠很好的調試 Javascript 代碼。
   咱們能夠輸入如下命令來啓動 Node 的終端：
   $ node

   這時咱們就能夠在 > 後輸入簡單的表達式，並按下回車鍵來計算結果。
   。。。
   使用變量
   你能夠將數據存儲在變量中，並在你須要的使用它。
   變量聲明須要使用 var 關鍵字，若是沒有使用 var 關鍵字變量會直接打印出來。
   使用 var 關鍵字的變量可使用 console.log() 來輸出變量。
   。。。
   多行表達式
   Node REPL 支持輸入多行表達式，這就有點相似 JavaScript。接下來讓咱們來執行一個 do-while 循環：
   $ node
   var x = 0
   undefined
   do {
   ... x++;
   ... console.log("x: " + x);
   ... } while ( x < 5 );
   x: 1
   x: 2
   x: 3
   x: 4
   x: 5
   undefined

   ... 三個點的符號是系統自動生成的，你回車換行後便可。Node 會自動檢測是否爲連續的表達式。
   。。。
   下劃線()變量
   你可使用下劃線()獲取表達式的運算結果：
   $ node
   var x = 10
   undefined
   var y = 20
   undefined
   x + y
   30
   var sum = _
   undefined
   console.log(sum)
   30
   undefined

   。。。
   REPL 命令
   -ctrl + c - 退出當前終端。
   -ctrl + c 按下兩次 - 退出 Node REPL。
   -ctrl + d - 退出 Node REPL.
   -向上/向下 鍵 - 查看輸入的歷史命令
   -tab 鍵 - 列出當前命令
   -.help - 列出使用命令
   -.break - 退出多行表達式
   -.clear - 退出多行表達式
   -.save filename - 保存當前的 Node REPL 會話到指定文件
   -.load filename - 載入當前 Node REPL 會話的文件內容。
   。。。
   中止 REPL
   前面咱們已經提到按下兩次 ctrl + c 建就能退出 REPL:
   $ node

   (^C again to quit)

   :::::::::::::::::::::::::::::::::::::::
   Node.js 回調函數
   Node.js 異步編程的直接體現就是回調。
   異步編程依託於回調來實現，但不能說使用了回調後程序就異步化了。
   回調函數在完成任務後就會被調用，Node 使用了大量的回調函數，Node 全部 API 都支持回調函數。
   例如，咱們能夠一邊讀取文件，一邊執行其餘命令，在文件讀取完成後，咱們將文件內容做爲回調函數的參數返回。這樣在執行代碼時就沒有阻塞或等待文件 I/O 操做。這就大大提升了 Node.js 的性能，能夠處理大量的併發請求。
   。。。
   阻塞代碼實例
   建立一個文件 input.txt ，內容以下：
   wodema地址：www.wodema.cn
   建立 main.js 文件, 代碼以下：
   var fs = require("fs");

var data = fs.readFileSync('input.txt');

console.log(data.toString());
console.log("程序執行結束!");
以上代碼執行結果以下：
$ node main.js
個人媽地址：www.wodema.cn
程序執行結束!
。。。
非阻塞代碼實例
建立一個文件 input.txt ，內容以下：
wodema地址：www.wodema.cn
建立 main.js 文件, 代碼以下：
var fs = require("fs");

fs.readFile('input.txt', function (err, data) {
if (err) return console.error(err);
console.log(data.toString());
});

console.log("程序執行結束!");
以上代碼執行結果以下：
$ node main.js
程序執行結束!
wodema地址：www.wodema.cn
以上兩個實例咱們瞭解了阻塞與非阻塞調用的不一樣。第一個實例在文件讀取完後才執行完程序。 第二個實例咱們呢不須要等待文件讀取完，這樣就能夠在讀取文件時同時執行接下來的代碼，大大提升了程序的性能。
所以，阻塞按是按順序執行的，而非阻塞是不須要按順序的，因此若是須要處理回調函數的參數，咱們就須要寫在回調函數內。
:::::::::::::::::::::::::::::::::
Node.js 事件循環
Node.js 是單進程單線程應用程序，可是經過事件和回調支持併發，因此性能很是高。
Node.js 的每個 API 都是異步的，並做爲一個獨立線程運行，使用異步函數調用，並處理併發。
Node.js 基本上全部的事件機制都是用設計模式中觀察者模式實現。
Node.js 單線程相似進入一個while(true)的事件循環，直到沒有事件觀察者退出，每一個異步事件都生成一個事件觀察者，若是有事件發生就調用該回調函數.
。。。
事件驅動程序
Node.js 使用事件驅動模型，當web server接收到請求，就把它關閉而後進行處理，而後去服務下一個web請求。
當這個請求完成，它被放回處理隊列，當到達隊列開頭，這個結果被返回給用戶。
這個模型很是高效可擴展性很是強，由於webserver一直接受請求而不等待任何讀寫操做。（這也被稱之爲非阻塞式IO或者事件驅動IO）
在事件驅動模型中，會生成一個主循環來監聽事件，當檢測到事件時觸發回調函數。
整個事件驅動的流程就是這麼實現的，很是簡潔。有點相似於觀察者模式，事件至關於一個主題(Subject)，而全部註冊到這個事件上的處理函數至關於觀察者(Observer)。
Node.js 有多個內置的事件，咱們能夠經過引入 events 模塊，並經過實例化 EventEmitter 類來綁定和監聽事件，以下實例：
// 引入 events 模塊
var events = require('events');
// 建立 eventEmitter 對象
var eventEmitter = new events.EventEmitter();
如下程序綁定事件處理程序：
// 綁定事件及事件的處理程序
eventEmitter.on('eventName', eventHandler);
咱們能夠經過程序觸發事件：
// 觸發事件
eventEmitter.emit('eventName');
。。。
Node 應用程序是如何工做的？
在 Node 應用程序中，執行異步操做的函數將回調函數做爲最後一個參數， 回調函數接收錯誤對象做爲第一個參數。
接下來讓咱們來從新看下前面的實例，建立一個 input.txt ,文件內容以下：123456789地址：www.123456789.cn
::::::::::::::::::::::::::::::::
Node.js 事件
Node.js 全部的異步 I/O 操做在完成時都會發送一個事件到事件隊列。
Node.js 裏面的許多對象都會分發事件：一個net.Server對象會在每次有新鏈接時分發一個事件， 一個fs.readStream對象會在文件被打開的時候發出一個事件。 全部這些產生事件的對象都是 events.EventEmitter 的實例。 你能夠經過require("events");來訪問該模塊。
。。。
EventEmitter介紹
events 模塊只提供了一個對象： events.EventEmitter。EventEmitter 的核心就 是事件發射與事件監聽器功能的封裝。
EventEmitter 的每一個事件由一個事件名和若干個參 數組成，事件名是一個字符串，一般表達必定的語義。對於每一個事件，EventEmitter 支持 若干個事件監聽器。
當事件發射時，註冊到這個事件的事件監聽器被依次調用，事件參數做 爲回調函數參數傳遞。
。。。
EventEmitter經常使用的API
EventEmitter.on(event, listener)、emitter.addListener(event, listener) 爲指定事件註冊一個監聽器，接收一個字符串 event 和一個回調函數 listener。
server.on('connection', function (stream) {
console.log('someone connected!');
});
EventEmitter.emit(event, [arg1], [arg2], [...]) 發射 event 事件，傳 遞若干可選參數到事件監聽器的參數表。
EventEmitter.once(event, listener) 爲指定事件註冊一個單次監聽器，即 監聽器最多隻會觸發一次，觸發後馬上解除該監聽器。
server.once('connection', function (stream) {
console.log('Ah, we have our first user!');
});
EventEmitter.removeListener(event, listener) 移除指定事件的某個監聽 器，listener 必須是該事件已經註冊過的監聽器。
var callback = function(stream) {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
EventEmitter.removeAllListeners([event]) 移除全部事件的全部監聽器， 若是指定 event，則移除指定事件的全部監聽器。
。。。
error 事件
EventEmitter 定義了一個特殊的事件 error，它包含了"錯誤"的語義，咱們在遇到 異常的時候一般會發射 error 事件。
當 error 被髮射時，EventEmitter 規定若是沒有響 應的監聽器，Node.js 會把它看成異常，退出程序並打印調用棧。
咱們通常要爲會發射 error 事件的對象設置監聽器，避免遇到錯誤後整個程序崩潰。例如：
var events = require('events');
var emitter = new events.EventEmitter();
emitter.emit('error');
。。。
繼承 EventEmitter
大多數時候咱們不會直接使用 EventEmitter，而是在對象中繼承它。包括 fs、net、 http 在內的，只要是支持事件響應的核心模塊都是 EventEmitter 的子類。
爲何要這樣作呢？緣由有兩點：
首先，具備某個實體功能的對象實現事件符合語義， 事件的監聽和發射應該是一個對象的方法。
其次JavaScript 的對象機制是基於原型的，支持 部分多重繼承，繼承 EventEmitter 不會打亂對象原有的繼承關係。
::::::::::::::::::::::::::::::::::::::::
Node.js Buffer(緩衝區)
JavaScript 語言自身只有字符串數據類型，沒有二進制數據類型。
但在處理像TCP流或文件流時，必須使用到二進制數據。所以在 Node.js中，定義了一個 Buffer 類，該類用來建立一個專門存放二進制數據的緩存區。
在 Node.js 中，Buffer 類是隨 Node 內核一塊兒發佈的核心庫。Buffer 庫爲 Node.js 帶來了一種存儲原始數據的方法，可讓 Node.js 處理二進制數據，每當須要在 Node.js 中處理I/O操做中移動的數據時，就有可能使用 Buffer 庫。原始數據存儲在 Buffer 類的實例中。一個 Buffer 相似於一個整數數組，但它對應於 V8 堆內存以外的一塊原始內存。
。。。
建立 Buffer 類
Node Buffer 類能夠經過多種方式來建立。
方法 1
建立長度爲 10 字節的 Buffer 實例：
var buf = new Buffer(10);
方法 2
經過給定的數組建立 Buffer 實例：
var buf = new Buffer([10, 20, 30, 40, 50]);
方法 3
經過一個字符串來建立 Buffer 實例：
var buf = new Buffer("www.123456789.cn", "utf-8");
utf-8 是默認的編碼方式，此外它一樣支持如下編碼："ascii", "utf8", "utf16le", "ucs2", "base64" 和 "hex"。
。。。
寫入緩衝區
語法
寫入 Node 緩衝區的語法以下所示：
buf.write(string[, offset[, length]][, encoding])
參數
參數描述以下：
-string - 寫入緩衝區的字符串。
-offset - 緩衝區開始寫入的索引值，默認爲 0 。
-length - 寫入的字節數，默認爲 buffer.length
-encoding - 使用的編碼。默認爲 'utf8' 。
返回值
返回實際寫入的大小。若是 buffer 空間不足， 則只會寫入部分字符串。
。。。
從緩衝區讀取數據
語法
讀取 Node 緩衝區數據的語法以下所示：
buf.toString([encoding[,start[,end]]])
參數
參數描述以下：
-encoding - 使用的編碼。默認爲 'utf8' 。
-start - 指定開始讀取的索引位置，默認爲 0。
-end - 結束位置，默認爲緩衝區的末尾。
返回值
解碼緩衝區數據並使用指定的編碼返回字符串。
。。。
將 Buffer 轉換爲 JSON 對象
語法
將 Node Buffer 轉換爲 JSON 對象的函數語法格式如右：buf.toJSON()
返回值
返回 JSON 對象。
。。。
緩衝區合併
語法
Node 緩衝區合併的語法以下所示：
Buffer.concat(list[, totalLength])
參數
參數描述以下：
-list - 用於合併的 Buffer 對象數組列表。
-totalLength - 指定合併後Buffer對象的總長度。
返回值
返回一個多個成員合併的新 Buffer 對象。
。。。
緩衝區比較
語法
Node Buffer 比較的函數語法以下所示, 該方法在 Node.js v0.12.2 版本引入：
buf.compare(otherBuffer);
參數
參數描述以下：
otherBuffer - 與 buf 對象比較的另一個 Buffer 對象。
返回值
返回一個數字，表示 buf 在 otherBuffer 以前，以後或相同。
。。。
拷貝緩衝區
語法
Node 緩衝區拷貝語法以下所示：
buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])
參數
參數描述以下：
-targetBuffer - 要拷貝的 Buffer 對象。
-targetStart - 數字, 可選, 默認: 0
-sourceStart - 數字, 可選, 默認: 0
-sourceEnd - 數字, 可選, 默認: buffer.length
返回值
沒有返回值。
。。。
緩衝區裁剪
Node 緩衝區裁剪語法以下所示：
buf.slice([start[, end]])
參數
參數描述以下：
-start - 數字, 可選, 默認: 0
-end - 數字, 可選, 默認: buffer.length
返回值
返回一個新的緩衝區，它和舊緩衝區指向同一塊內存，可是從索引 start 到 end 的位置剪切。
。。。
緩衝區長度
語法
Node 緩衝區長度計算語法以下所示：
buf.length;
返回值
返回 Buffer 對象所佔據的內存長度。
:::::::::::::::::::::::::::::::::::::::::::
Node.js Stream(流)
Stream 是 Node.js 中很是重要的一個模塊，應用普遍。
Stream 是一個抽象接口，Node 中有不少對象實現了這個接口。例如，對http 服務器發起請求的request 對象就是一個 Stream，還有stdout（標準輸出）。
該抽象接口是可讀、可寫或是既可讀又可寫的，經過這些接口，咱們能夠和磁盤文件、套接字、HTTP請求來交互，實現數據從一個地方流動到另外一個地方的功能。
Node.js，Stream 有四種流類型：
-Readable - 可讀操做。
-Writable - 可寫操做。
-Duplex - 可讀可寫操做.
-Transform - 操做被寫入數據，而後讀出結果。
全部的 Stream 對象都是 EventEmitter 的實例。經常使用的事件有：
-data - 當有數據可讀時觸發。
-end - 沒有更多的數據可讀時觸發。
-error - 在接收和寫入過程當中發生錯誤時觸發。
-finish - 全部數據已被寫入到底層系統時觸發。
。。。
管道流
管道提供了一個輸出流到輸入流的機制。一般咱們用於從一個流中獲取數據並將數據傳遞到另一個流中。
。。。
鏈式流
鏈式是經過鏈接輸出流到另一個流並建立多個對個流操做鏈的機制。鏈式流通常用於管道操做。
接下來咱們就是用管道和鏈式來壓縮和解壓文件。
::::::::::::::::::::::::::::::::::::::::::
Node.js模塊系統
爲了讓Node.js的文件能夠相互調用，Node.js提供了一個簡單的模塊系統。
模塊是Node.js 應用程序的基本組成部分，文件和模塊是一一對應的。換言之，一個 Node.js 文件就是一個模塊，這個文件多是JavaScript 代碼、JSON 或者編譯過的C/C++ 擴展。
。。。
建立模塊
在 Node.js 中，建立一個模塊很是簡單，以下咱們建立一個 'main.js' 文件，代碼以下:
var hello = require('./hello');
hello.world();
以上實例中，代碼 require('./hello') 引入了當前目錄下的hello.js文件（./ 爲當前目錄，node.js默認後綴爲js）。
Node.js 提供了exports 和 require 兩個對象，其中 exports 是模塊公開的接口，require 用於從外部獲取一個模塊的接口，即所獲取模塊的 exports 對象。
。。。
服務端的模塊放在哪裏
也許你已經注意到，咱們已經在代碼中使用了模塊了。像這樣：
var http = require("http");
...
http.createServer(...);
Node.js中自帶了一個叫作"http"的模塊，咱們在咱們的代碼中請求它並把返回值賦給一個本地變量。
這把咱們的本地變量變成了一個擁有全部 http 模塊所提供的公共方法的對象。
Node.js 的 require方法中的文件查找策略以下：
因爲Node.js中存在4類模塊（原生模塊和3種文件模塊），儘管require方法極其簡單，可是內部的加載倒是十分複雜的，其加載優先級也各自不一樣。
。。。
從文件模塊緩存中加載
儘管原生模塊與文件模塊的優先級不一樣，可是都不會優先於從文件模塊的緩存中加載已經存在的模塊。
從原生模塊加載
原生模塊的優先級僅次於文件模塊緩存的優先級。require方法在解析文件名以後，優先檢查模塊是否在原生模塊列表中。以http模塊爲例，儘管在目錄下存在一個http/http.js/http.node/http.json文件，require("http")都不會從這些文件中加載，而是從原生模塊中加載。
原生模塊也有一個緩存區，一樣也是優先從緩存區加載。若是緩存區沒有被加載過，則調用原生模塊的加載方式進行加載和執行。
。。。
從文件加載
當文件模塊緩存中不存在，並且不是原生模塊的時候，Node.js會解析require方法傳入的參數，並從文件系統中加載實際的文件，加載過程當中的包裝和編譯細節在前一節中已經介紹過，這裏咱們將詳細描述查找文件模塊的過程，其中，也有一些細節值得知曉。
require方法接受如下幾種參數的傳遞：
-http、fs、path等，原生模塊。
-./mod或../mod，相對路徑的文件模塊。
-/pathtomodule/mod，絕對路徑的文件模塊。
-mod，非原生模塊的文件模塊。
::::::::::::::::::::::::::::::::::::::::::::::::::::::
Node.js 函數
在JavaScript中，一個函數能夠做爲另外一個函數接收一個參數。咱們能夠先定義一個函數，而後傳遞，也能夠在傳遞參數的地方直接定義函數。
Node.js中函數的使用與Javascript相似，舉例來講，你能夠這樣作：
function say(word) {
console.log(word);
}

function execute(someFunction, value) {
someFunction(value);
}

execute(say, "Hello");
以上代碼中，咱們把 say 函數做爲execute函數的第一個變量進行了傳遞。這裏返回的不是 say 的返回值，而是 say 自己！
這樣一來， say 就變成了execute 中的本地變量 someFunction ，execute能夠經過調用 someFunction() （帶括號的形式）來使用 say 函數。
固然，由於 say 有一個變量， execute 在調用 someFunction 時能夠傳遞這樣一個變量。
。。。
匿名函數
咱們能夠把一個函數做爲變量傳遞。可是咱們不必定要繞這個"先定義，再傳遞"的圈子，咱們能夠直接在另外一個函數的括號中定義和傳遞這個函數：
function execute(someFunction, value) {
someFunction(value);
}
execute(function(word){ console.log(word) }, "Hello");
咱們在 execute 接受第一個參數的地方直接定義了咱們準備傳遞給 execute 的函數。
用這種方式，咱們甚至不用給這個函數起名字，這也是爲何它被叫作匿名函數 。
。。。
函數傳遞是如何讓HTTP服務器工做的
帶着這些知識，咱們再來看看咱們簡約而不簡單的HTTP服務器：
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 函數傳遞了一個匿名函數。
用這樣的代碼也能夠達到一樣的目的：
var http = require("http");
function onRequest(request, response) {
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}
http.createServer(onRequest).listen(8888);
::::::::::::::::::::::::::::::::::::::::::::::
Node.js 路由
咱們要爲路由提供請求的URL和其餘須要的GET及POST參數，隨後路由須要根據這些數據來執行相應的代碼。
所以，咱們須要查看HTTP請求，從中提取出請求的URL以及GET/POST參數。這一功能應當屬於路由仍是服務器（甚至做爲一個模塊自身的功能）確實值得探討，但這裏暫定其爲咱們的HTTP服務器的功能。
咱們須要的全部數據都會包含在request對象中，該對象做爲onRequest()回調函數的第一個參數傳遞。可是爲了解析這些數據，咱們須要額外的Node.JS模塊，它們分別是url和querystring模塊。
固然咱們也能夠用querystring模塊來解析POST請求體中的參數，稍後會有演示。
如今咱們來給onRequest()函數加上一些邏輯，用來找出瀏覽器請求的URL路徑：
var http = require("http");
var url = require("url");

function start() {
function onRequest(request, response) {
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " 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;
好了，咱們的應用如今能夠經過請求的URL路徑來區別不一樣請求了--這使咱們得以使用路由（還未完成）來將請求以URL路徑爲基準映射處處理程序上。
在咱們所要構建的應用中，這意味着來自/start和/upload的請求可使用不一樣的代碼來處理。稍後咱們將看到這些內容是如何整合到一塊兒的。
如今咱們能夠來編寫路由了，創建一個名爲router.js的文件，添加如下內容：
function route(pathname) {
console.log("About to route a request for " + pathname);
}

exports.route = route;
如你所見，這段代碼什麼也沒幹，不過對於如今來講這是應該的。在添加更多的邏輯之前，咱們先來看看如何把路由和服務器整合起來。
咱們的服務器應當知道路由的存在並加以有效利用。咱們固然能夠經過硬編碼的方式將這一依賴項綁定到服務器上，可是其它語言的編程經驗告訴咱們這會是一件很是痛苦的事，所以咱們將使用依賴注入的方式較鬆散地添加路由模塊。
:::::::::::::::::::::::::::::::::::::::::
Node.js 全局對象
如今介紹 Node.js 全局對象，global 全局對象無需引用就能夠直接使用。
JavaScript 中有一個特殊的對象，稱爲全局對象（Global Object），它及其全部屬性均可以在程序的任何地方訪問，即全局變量。
在瀏覽器 JavaScript 中，一般window 是全局對象， 而Node.js 中的全局對象是 global，全部全局變量（除了 global 自己之外）都是 global 對象的屬性。
咱們在Node.js 中可以直接訪問到對象一般都是 global 的屬性，如 console、process 等，
。。。
全局對象與全局變量
global 最根本的做用是做爲全局變量的宿主。按照 ECMAScript 的定義，知足如下條件的變量是全局變量：
在最外層定義的變量；
全局對象的屬性；
隱式定義的變量（未定義直接賦值的變量）。
當你定義一個全局變量時，這個變量同時也會成爲全局對象的屬性，反之亦然。須要注 意的是，在Node.js 中你不可能在最外層定義變量，由於全部用戶代碼都是屬於當前模塊的， 而模塊自己不是最外層上下文。
注意： 永遠使用var 定義變量以免引入全局變量，由於全局變量會污染 命名空間，提升代碼的耦合風險。
。。。
process
process 是一個全局變量，即 global 對象的屬性。
它用於描述當前Node.js 進程狀態 的對象，提供了一個與操做系統的簡單接口。一般在你寫本地命令行程序的時候，少不了要 和它打交道。下面將會介紹process 對象的一些最經常使用的成員方法。
process.argv是命令行參數數組，第一個元素是 node，第二個元素是腳本文件名， 從第三個元素開始每一個元素是一個運行參數。
console.log(process.argv);
將以上代碼存儲爲argv.js，經過如下命令運行：
$ node argv.js 1991 name=byvoid --v "Carbo Kuo"
[ 'node',
'/home/byvoid/argv.js',
'1991',
'name=byvoid',
'--v',
'Carbo Kuo' ]
process.stdout是標準輸出流，一般咱們使用的 console.log() 向標準輸出打印 字符，而 process.stdout.write() 函數提供了更底層的接口。
process.stdin是標準輸入流，初始時它是被暫停的，要想從標準輸入讀取數據， 你必須恢復流，並手動編寫流的事件響應函數。
process.stdin.resume();
process.stdin.on('data', function(data) {
process.stdout.write('read from console: ' + data.toString());
});
process.nextTick(callback)的功能是爲事件循環設置一項任務，Node.js 會在 下次事件循環調響應時調用 callback。
初學者極可能不理解這個函數的做用，有什麼任務不能在當下執行完，須要交給下次事 件循環響應來作呢？
咱們討論過，Node.js 適合I/O 密集型的應用，而不是計算密集型的應用， 由於一個Node.js 進程只有一個線程，所以在任什麼時候刻都只有一個事件在執行。
若是這個事 件佔用大量的CPU 時間，執行事件循環中的下一個事件就須要等待好久，所以Node.js 的一 個編程原則就是儘可能縮短每一個事件的執行時間。process.nextTick() 提供了一個這樣的 工具，能夠把複雜的工做拆散，變成一個個較小的事件。
functiondoSomething(args, callback) {
somethingComplicated(args);
callback();
}
doSomething(functiononEnd() {
compute();
});
咱們假設compute() 和somethingComplicated() 是兩個較爲耗時的函數，以上 的程序在調用 doSomething() 時會先執行somethingComplicated()，而後當即調用 回調函數，在 onEnd() 中又會執行 compute()。下面用process.nextTick() 改寫上 面的程序：
functiondoSomething(args, callback) {
somethingComplicated(args);
process.nextTick(callback);
}
doSomething(functiononEnd() {
compute();
});
改寫後的程序會把上面耗時的操做拆分爲兩個事件，減小每一個事件的執行時間，提升事 件響應速度。
注意： 不要使用setTimeout(fn,0)代替process.nextTick(callback)， 前者比後者效率要低得多。
咱們探討了process對象經常使用的幾個成員，除此以外process還展現了process.platform、 process.pid、process.execPath、process.memoryUsage() 等方法，以及POSIX 進程信號響應機制。有興趣的讀者能夠訪問http://nodejs.org/api/process.html 瞭解詳細 內容。
。。。
console
console 用於提供控制檯標準輸出，它是由Internet Explorer 的JScript 引擎提供的調試 工具，後來逐漸成爲瀏覽器的事實標準。
Node.js 沿用了這個標準，提供與習慣行爲一致的 console 對象，用於向標準輸出流（stdout）或標準錯誤流（stderr）輸出字符。 ? console.log()：向標準輸出流打印字符並以換行符結束。
console.log 接受若干 個參數，若是隻有一個參數，則輸出這個參數的字符串形式。若是有多個參數，則 以相似於C 語言 printf() 命令的格式輸出。
第一個參數是一個字符串，若是沒有 參數，只打印一個換行。
console.error()：與console.log() 用法相同，只是向標準錯誤流輸出。
console.trace()：向標準錯誤流輸出當前的調用棧。
:::::::::::::::::::::::::::::::::::::
Node.js 經常使用工具 util
如今介紹Node.js經常使用工具util。
util做爲Node.js的一個核心模塊，可以提供經常使用函數的集合，彌補核心JavaScript的功能過於精簡的不足。
。。。
util.inherits
util.inherits(constructor, superConstructor)是一個實現對象間原型繼承的函數。
與常見的基於類的不一樣，JavaScript的面向對象特性是基於原型的。JavaScript沒有提供對象繼承的語言級別特性，而是經過原型複製來實現的。
在這裏咱們只介紹util.inherits的用法
注意：Sub僅僅繼承了Base在原型中定義的函數，而構造函數內部創造的base屬性和sayHello函數都沒有被Sub繼承。
同時，在原型中定義的屬性不會被console.log做爲對象的屬性輸出。若是咱們去掉objSub.sayHello(); 這行的註釋，
。。。
util.inspect
util.inspect(object,[showHidden],[depth],[colors])方法能夠將任意對象轉換爲字符串，一般用於調試和錯誤輸出。它至少接受一個object參數，即要轉換的對象。
showHidden是一個可選參數，若是值爲true，將會輸出更多隱藏信息。
depth表示最大遞歸的層數，若是對象很複雜，你能夠指定層數以控制輸出信息的多少。若是不指定depth，則默認遞歸2層，指定爲null時表示將不限遞歸層數完整遍歷對象。 若是color值爲true，則輸出格式將會以ANSI顏色編碼，一般用於在終端顯示更漂亮的效果。
特別要指出的是，util.inspect並不會簡單地直接把對象轉換爲字符串，即便該對象定義了toString方法也不會調用。
。。。
util.isArray(object)
若是給定的參數 "object" 是一個數組返回true，不然返回false。
。。。
util.isRegExp(object)
若是給定的參數"object"是一個正則表達式返回true，不然返回false。
。。。
util.isDate(object)
若是給定的參數 "object" 是一個日期返回true，不然返回false。
。。。
util.isError(object)
若是給定的參數 "object" 是一個錯誤對象返回true，不然返回false。
::::::::::::::::::::::::::::::::::::::
Node.js 文件系統
Node.js文件系統被封裝在fs模塊中，它提供了文件的讀取、寫入、改名、刪除、遍歷目錄、連接等POSIX文件系統操做。
與其餘模塊不一樣的是，fs模塊中全部的操做都提供了異步的和同步的兩個版本，例如讀取文件內容的函數有異步的fs.readFile()和同步的fs.readFileSync()。咱們以幾個函數爲表明，介紹fs經常使用的功能，並列出fs全部函數的定義和功能。
。。。
fs.readFile
Node.js讀取文件函數語法以下：
-fs.readFile(filename,[encoding],[callback(err,data)])
-filename（必選），表示要讀取的文件名。
-encoding（可選），表示文件的字符編碼。
-callback 是回調函數，用於接收文件的內容。
若是不指定encoding，則callback就是第二個參數。回調函數提供兩個參數err和data，err表示有沒有錯誤發生，data是文件內容。若是指定了encoding，data是一個解析後的字符串，不然data將會是以Buffer形式表示的二進制數據。
。。。
fs.readFileSync
fs.readFileSync(filename, [encoding])是fs.readFile同步的版本。它接受和 fs.readFile 相同的參數，而讀取到的文件內容會以函數返回值的形式返回。若是有錯 誤發生，fs將會拋出異常，你須要使用try和catch捕捉並處理異常。
注意：與同步I/O函數不一樣，Node.js中異步函數大多沒有返回值。
。。。
fs.open

fs.open(path, flags, [mode], [callback(err, fd)])是POSIX open函數的封裝，相似於C語言標準庫中的fopen函數。它接受兩個必選參數，path爲文件的路徑， flags 能夠是如下值：
r ：以讀取模式打開文件。
r+ ：以讀寫模式打開文件。
w ：以寫入模式打開文件，若是文件不存在則建立。
w+ ：以讀寫模式打開文件，若是文件不存在則建立。
a ：以追加模式打開文件，若是文件不存在則建立。
a+ ：以讀取追加模式打開文件，若是文件不存在則建立
。。。
fs.read
fs.read語法格式以下：
fs.read(fd, buffer, offset, length, position, [callback(err, bytesRead, buffer)])
參數說明：
-fd: 讀取數據並寫入buffer指向的緩衝區對象。
-offset: 是buffer的寫入偏移量。
-length: 是要從文件中讀取的字節數。
-position: 是文件讀取的起始位置，若是position的值爲null，則會從當前文件指針的位置讀取。
-callback:回調函數傳遞bytesRead和buffer，分別表示讀取的字節數和緩衝區對象。
::::::::::::::::::::::::::::::::::::::::::::
Node.js 工具模塊

在 Node.js 模塊庫中有不少好用的模塊。這些模塊都是很常見的，並同時開發基於任何節點的應用程序頻繁使用。接下來咱們爲你們介紹幾種經常使用模塊的使用：
序號 模塊名 描述
1 OS 模塊 提供基本的系統操做函數。
2 Path 模塊 提供了處理和轉換文件路的工具。
3 Net 模塊 用於底層的網絡通訊。提供了服務端和客戶端的的操做。
4 DNS 模塊 用於解析域名。
5 Domain 模塊 簡化異步代碼的異常處理，能夠捕捉處理try catch沒法捕捉的。
以上就是經常使用的Node.js工具模塊
::::::::::::::::::::::::::::::::::::::::::::
Node.js Web 模塊
如今介紹Node.js Web模塊，首先，你應該先了解什麼是Web服務器。
。。。
什麼是 Web 服務器？
Web服務器通常指網站服務器，是指駐留於因特網上某種類型計算機的程序。
Web服務器的基本功能就是提供Web信息瀏覽服務。它只需支持HTTP協議、HTML文檔格式及URL，與客戶端的網絡瀏覽器配合。
大多數web服務器都支持服務端的腳本語言（php、python、ruby）等，並經過腳本語言從數據庫獲取數據，將結果返回給客戶端瀏覽器。
目前最主流的三個Web服務器是Apache、Nginx、IIS。
-Client - 客戶端，通常指瀏覽器，瀏覽器能夠經過HTTP協議向服務器請求數據。
-Server - 服務端，通常指Web服務器，能夠接收客戶端請求，並向客戶端發送響應數據。
-Business - 業務層， 經過Web服務器處理應用程序，如與數據庫交互，邏輯運算，調用外部程序等。
-Data - 數據層，通常由數據庫組成。
。。。
使用 Node 建立 Web 服務器
Node.js提供了http模塊，http模塊主要用於搭建HTTP服務端和客戶端，若是要使用HTTP服務器或客戶端功能，則必須調用http模塊，代碼以下：
var http = require('http');
。。。
使用 Node 建立 Web 客戶端
使用Node建立Web客戶端須要引入http模塊，建立client.js文件，代碼以下所示：
var http = require('http');

// 用於請求的選項
var options = {
host: 'localhost',
port: '8081',
path: '/index.htm'
};

// 處理響應的回調函數
var callback = function(response){
// 不斷更新數據
var body = '';
response.on('data', function(data) {
body += data;
});

response.on('end', function() {
// 數據接收完成
console.log(body);
});
}
// 向服務端發送請求
var req = http.request(options, callback);
req.end();
::::::::::::::::::::::::::::::::::
Node.js Express 框架
Express 是一個爲Node.js設計的web開發框架，它基於nodejs平臺。
。。。
Express 簡介
Express是一個簡潔而靈活的node.js Web應用框架, 提供了一系列強大特性幫助你建立各類Web應用，和豐富的HTTP工具。
使用Express能夠快速地搭建一個完整功能的網站。
Express 框架核心特性包括：
-能夠設置中間件來響應HTTP請求。
-定義了路由表用於執行不一樣的HTTP請求動做。
-能夠經過向模板傳遞參數來動態渲染HTML頁面。
。。。
安裝 Express
安裝Express並將其保存到依賴列表中：
$ npm install express --save
以上命令會將Express框架安裝在當期目錄的node_modules目錄中， node_modules目錄下會自動建立express目錄。如下幾個重要的模塊是須要與express框架一塊兒安裝的：
-body-parser - node.js中間件，用於處理JSON, Raw, Text和URL編碼的數據。
-cookie-parser - 這就是一個解析Cookie的工具。經過req.cookies能夠取到傳過來的cookie，並把它們轉成對象。
-multer - node.js中間件，用於處理enctype="multipart/form-data"（設置表單的MIME編碼）的表單數據。
。。。
第一個 Express 框架實例
接下來咱們使用Express框架來輸出"Hello World"。
如下實例中咱們引入了express模塊，並在客戶端發起請求後，響應"Hello World"字符串。
建立express_demo.js文件
。。。
請求和響應
Express應用使用回調函數的參數： request和response對象來處理請求和響應的數據。
app.get('/', function (req, res) {
// --
})
request和response對象的具體介紹：
Request 對象 - request對象表示HTTP請求，包含了請求查詢字符串，參數，內容，HTTP頭部等屬性。常見屬性有：
-req.app：當callback爲外部文件時，用req.app訪問express的實例
-req.baseUrl：獲取路由當前安裝的URL路徑
-req.body / req.cookies：得到「請求主體」/ Cookies
-req.fresh / req.stale：判斷請求是否還「新鮮」
-req.hostname / req.ip：獲取主機名和IP地址
-req.originalUrl：獲取原始請求URL
-req.params：獲取路由的parameters
-req.path：獲取請求路徑
-req.protocol：獲取協議類型
-req.query：獲取URL的查詢參數串
-req.route：獲取當前匹配的路由
-req.subdomains：獲取子域名
-req.accpets（）：檢查請求的Accept頭的請求類型
-req.acceptsCharsets / req.acceptsEncodings / req.acceptsLanguages
-req.get（）：獲取指定的HTTP請求頭
-req.is（）：判斷請求頭Content-Type的MIME類型
。。。
Response 對象 - response對象表示HTTP響應，即在接收到請求時向客戶端發送的HTTP響應數據。常見屬性有：
-res.app：同req.app同樣
-res.append（）：追加指定HTTP頭
-res.set（）在res.append（）後將重置以前設置的頭
-res.cookie（name，value [，option]）：設置Cookie
-opition: domain / expires / httpOnly / maxAge / path / secure / signed
-res.clearCookie（）：清除Cookie
-res.download（）：傳送指定路徑的文件
-res.get（）：返回指定的HTTP頭
-res.json（）：傳送JSON響應
-res.jsonp（）：傳送JSONP響應
-res.location（）：只設置響應的Location HTTP頭，不設置狀態碼或者close response
-res.redirect（）：設置響應的Location HTTP頭，而且設置狀態碼302
-res.send（）：傳送HTTP響應
-res.sendFile（path [，options] [，fn]）：傳送指定路徑的文件 -會自動根據文件extension設定Content-Type
-res.set（）：設置HTTP頭，傳入object能夠一次設置多個頭
-res.status（）：設置HTTP狀態碼
-res.type（）：設置Content-Type的MIME類型
。。。
路由
咱們已經瞭解了HTTP請求的基本應用，而路由決定了由誰(指定腳本)去響應客戶端請求。
在HTTP請求中，咱們能夠經過路由提取出請求的URL以及GET/POST參數。
接下來咱們擴展Hello World，添加一些功能來處理更多類型的HTTP請求。
建立express_demo2.js文件
。。。
靜態文件

Express提供了內置的中間件express.static來設置靜態文件如：圖片，CSS, JavaScript等。 你可使用express.static中間件來設置靜態文件路徑。例如，若是你將圖片， CSS, JavaScript文件放在public目錄下，你能夠這麼寫： app.use(express.static('public')); 咱們能夠到public/images目錄下放些圖片,以下所示： node_modules server.js public/ public/images public/images/logo.png 讓咱們再修改下"Hello Word"應用添加處理靜態文件的功能。 。。。 GET 方法 在表單中經過GET方法提交兩個參數，咱們可使用server.js文件內的process_get路由器來處理輸入 。。。 POST 方法 在表單中經過POST方法提交兩個參數，咱們可使用server.js文件內的process_post路由器來處理輸入 。。。 文件上傳 建立一個用於上傳文件的表單，使用POST方法，表單enctype屬性設置爲multipart/form-data。 。。。 Cookie 管理 咱們可使用中間件向Node.js服務器發送cookie信息 ::::::::::::::::::::::::::::::::::: Node.js RESTful API 如今介紹Node.js的RESTful API。 。。。 什麼是 REST？ REST中文解釋爲，表述性狀態傳遞（英文：Representational State Transfer，簡稱REST），是Roy Fielding博士在2000年他的博士論文中提出來的一種軟件架構風格。 表述性狀態轉移是一組架構約束條件和原則。知足這些約束條件和原則的應用程序或設計就是RESTful。 須要注意的是，REST是設計風格而不是標準。REST一般基於使用HTTP，URI和XML（標準通用標記語言下的一個子集）以及HTML（標準通用標記語言下的一個應用）這些現有的普遍流行的協議和標準。REST一般使用JSON數據格式。 。。。 HTTP 方法 如下爲REST基本架構的四個方法： -GET - 用於獲取數據。 -PUT - 用於添加數據。 -DELETE - 用於刪除數據。 -POST - 用於更新或添加數據。 。。。 RESTful Web Services Webservice是一個平臺獨立的，低耦合的，自包含的、基於可編程的web的應用程序，可以使用開放的XML（標準通用標記語言下的一個子集）標準來描述、發佈、發現、協調和配置這些應用程序，用於開發分佈式的互操做的應用程序。 RESTful是基於REST架構的Web Services。 因爲輕量級以及經過HTTP直接傳輸數據的特性，Web服務的RESTful方法已經成爲最多見的替代方法。可使用各類語言（好比，Java程序、Perl、Ruby、Python、PHP和Javascript[包括Ajax]）實現客戶端。 RESTful Web服務一般能夠經過自動客戶端或表明用戶的應用程序訪問。可是，這種服務的簡便性讓用戶可以與之直接交互，使用它們的Web瀏覽器構建一個GET URL並讀取返回的內容。 ::::::::::::::::::::::::::::::::::::::::::::::::::: Node.js 多進程 Node.js自己是以單線程的模式運行的，但它使用的是事件驅動來處理併發，這樣有助於咱們在多核 cpu 的系統上建立多個子進程，從而提升性能。 每一個子進程老是帶有三個流對象：child.stdin, child.stdout和child.stderr。他們可能會共享父進程的stdio流，或者也能夠是獨立的被導流的流對象。 Node提供了child_process模塊來建立子進程，方法有： -exec - child_process.exec使用子進程執行命令，緩存子進程的輸出，並將子進程的輸出以回調函數參數的形式返回。 -spawn - child_process.spawn使用指定的命令行參數建立新進程。 -fork - child_process.fork是spawn()的特殊形式，用於在子進程中運行的模塊，如fork('./son.js')至關於spawn('node', ['./son.js']) 。與spawn方法不一樣的是，fork會在父進程與子進程之間，創建一個通訊管道，用於進程之間的通訊。 。。。 exec() 方法 child_process.exec使用子進程執行命令，緩存子進程的輸出，並將子進程的輸出以回調函數參數的形式返回。 語法以下所示： child_process.exec(command[, options], callback) 參數 參數說明以下： -command： 字符串， 將要運行的命令，參數使用空格隔開 -options ：對象，能夠是： -cwd，字符串，子進程的當前工做目錄 -env，對象，環境變量鍵值對 -encoding，字符串，字符編碼（默認： 'utf8'） -shell，字符串，將要執行命令的Shell（默認: 在UNIX中爲/bin/sh， 在Windows中爲cmd.exe， Shell應當能識別-c開關在UNIX中，或/s /c在 Windows中。 -在Windows中，命令行解析應當能兼容cmd.exe） -timeout，數字，超時時間（默認： 0） -maxBuffer，數字， 在stdout或stderr中容許存在的最大緩衝（二進制），若是超出那麼子進程將會被殺死（默認: 200*1024） -killSignal，字符串，結束信號（默認：'SIGTERM'） -uid，數字，設置用戶進程的ID -gid，數字，設置進程組的ID -callback ：回調函數，包含三個參數error, stdout和stderr。 -exec()方法返回最大的緩衝區，並等待進程結束，一次性返回緩衝區的內容。 。。。 spawn() 方法 child_process.spawn使用指定的命令行參數建立新進程，語法格式以下： child_process.spawn(command[, args][, options]) 參數 參數說明以下： -command： 將要運行的命令 -args： Array字符串參數數組 -options Object -cwd：String，子進程的當前工做目錄 -env：Object，環境變量鍵值對 -stdio：Array

String，子進程的stdio配置 -detached：Boolean，這個子進程將會變成進程組的領導 -uid：Number，設置用戶進程的ID -gid：Number，設置進程組的ID -spawn()方法返回流 (stdout & stderr)，在進程返回大量數據時使用。進程開始執行spawn()時就開始接收響應。 。。。 fork 方法 child_process.fork是spawn()方法的特殊形式，用於建立進程，語法格式以下： child_process.fork(modulePath[, args][, options]) 參數 參數說明以下： -modulePath： String，將要在子進程中運行的模塊 -args： Array，字符串參數數組 -options：Object -cwd：String，子進程的當前工做目錄 -env：Object，環境變量鍵值對 -execPath：String，建立子進程的可執行文件 -execArgv：Array，子進程的可執行文件的字符串參數數組（默認： process.execArgv） -silent：Boolean，若是爲true，子進程的stdin，stdout和stderr將會被關聯至父進程，不然，它們將會從父進程中繼承。（默認爲：false） -uid：Number，設置用戶進程的ID -gid：Number，設置進程組的ID 返回的對象除了擁有ChildProcess實例的全部方法，還有一個內建的通訊信道。

Node.js JXcore 打包
Node.js是一個開放源代碼、跨平臺的、用於服務器端和網絡應用的運行環境。
JXcore是一個支持多線程的 Node.js 發行版本，基本不須要對你現有的代碼作任何改動就能夠直接線程安全地以多線程運行。
。。。
JXcore 安裝
下載JXcore安裝包，而後進行解壓，在解壓的目錄下提供了jx二進制文件命令，接下來咱們主要使用這個命令。
步驟一、下載
在http://jxcore.com/downloads/中下載JXcore安裝包，你須要根據你本身的系統環境來下載安裝包：
一、Window系統下載：Download，
二、Linux/OSX下載安裝命令，直接下載解壓包下的jx二進制文件，而後拷貝到/usr/bin目錄下：
$ wget https://s3.amazonaws.com/nodejx/jx_rh64.zip$ unzip jx_rh64.zip$ cp jx_rh64/jx /usr/bin將/usr/bin添加到PATH路徑中：$ export PATH=$PATH:/usr/bin以上步驟若是操做正確，使用如下命令，會輸出版本號信息：$ jx --versionv0.10.32。。。包代碼例如，咱們的Node.js項目包含如下幾個文件，其中index.js是主文件：drwxr-xr-x 2 root root 4096 Nov 13 12:42 images-rwxr-xr-x 1 root root 30457 Mar 6 12:19 index.htm-rwxr-xr-x 1 root root 30452 Mar 1 12:54 index.jsdrwxr-xr-x 23 root root 4096 Jan 15 03:48 node_modulesdrwxr-xr-x 2 root root 4096 Mar 21 06:10 scriptsdrwxr-xr-x 2 root root 4096 Feb 15 11:56 style接下來咱們使用jx命令打包以上項目，並指定index.js爲Node.js項目的主文件：$ jx package index.js index以上命令執行成功，會生成如下兩個文件：-index.jxp：這是一箇中間件文件，包含了須要編譯的完整項目信息。-index.jx：這是一個完整包信息的二進制文件，可運行在客戶端上。