- nodejs
>1.旨在提供一種簡單的構建可伸縮網絡程序的方法
官方網站：http://nodejs.cn/api/
Node.js 是一個基於Chromev8 JavaScript 運行時建立的一個平台， 用來方便地搭建快速的， 易於擴展的網絡應用· Node.js 借助事件驅動， 非阻塞 I/O 模型變得輕量和高效
>2特點
\1. 它是一個Javascript運行環境
\2. 依賴於Chrome V8引擎進行代碼解釋
\3. 事件驅動
\4. 非阻塞I/O
\5. 輕量、可伸縮，適於實時數據交互應用
\6. 單進程，單線程
>3NodeJS的優缺點
優點：
1. 高並發（最重要的優點）
\2. 適合I/O密集型應用
缺點：
1. 不適合CPU密集型應用；CPU密集型應用給Node帶來的挑戰主要是：由於JavaScript單線程的原因，如果有長時間運行的計算（比如大循環），將會導致CPU時間片不能釋放，使得后續I/O無法發起；
解決方案：分解大型運算任務為多個小任務，使得運算能夠適時釋放，不阻塞I/O調用的發起；
\2. 只支持單核CPU，不能充分利用CPU
\3. 可靠性低，一旦代碼某個環節崩潰，整個系統都崩潰
原因：單進程，單線程
>4. 適合NodeJS的場景
\1. RESTful API
這是NodeJS最理想的應用場景，可以處理數萬條連接，本身沒有太多的邏輯，只需要請求API，組織數據進行返回即可。它本質上只是從某個數據庫中查找一些值並將它們組成一個響應。由於響應是少量文本，入站請求也是少量的文本，因此流量不高，一台機器甚至也可以處理最繁忙的公司的API需求。
\2. 統一Web應用的UI層
目前MVC的架構，在某種意義上來說，Web開發有兩個UI層，一個是在瀏覽器里面我們最終看到的，另一個在server端，負責生成和拼接頁面。
不討論這種架構是好是壞，但是有另外一種實踐，面向服務的架構，更好的做前后端的依賴分離。如果所有的關鍵業務邏輯都封裝成REST調用，就意味着在上層只需要考慮如何用這些REST接口構建具體的應用。那些后端程序員們根本不操心具體數據是如何從一個頁面傳遞到另一個頁面的，他們也不用管用戶數據更新是通過Ajax異步獲取的還是通過刷新頁面。
\3. 大量Ajax請求的應用
例如個性化應用，每個用戶看到的頁面都不一樣，緩存失效，需要在頁面加載的時候發起Ajax請求，NodeJS能響應大量的並發請求。 總而言之，NodeJS適合運用在高並發、I/O密集、少量業務邏輯的場景。
2.模塊中能放那些東西
function class variable
Node，CommonJS，瀏覽器甚至是W3C之間有什么關系：
概述
Node 應用由模塊組成，采用 CommonJS 模塊規范。
每個文件就是一個模塊，有自己的作用域。在一個文件里面定義的變量、函數、類，都是私有的，對其他文件不可見。
// example.js var x = 5; var addX = function (value) { return value + x; }; 上面代碼中，變量x和函數addX，是當前文件example.js私有的，其他文件不可見。
如果想在多個文件分享變量，必須定義為global對象的屬性。
global.warning = true; 上面代碼的warning變量，可以被所有文件讀取。當然，這樣寫法是不推薦的。
CommonJS規范規定，每個模塊內部，module變量代表當前模塊。這個變量是一個對象，它的exports屬性（即module.exports）是對外的接口。加載某個模塊，其實是加載該模塊的module.exports屬性。
var x = 5; var addX = function (value) { return value + x; }; module.exports.x = x; module.exports.addX = addX; 上面代碼通過module.exports輸出變量x和函數addX。
require方法用於加載模塊。
var example = require('./example.js'); console.log(example.x); // 5 console.log(example.addX(1)); // 6 require方法的詳細解釋參見《Require命令》一節。
CommonJS模塊的特點如下。
- 所有代碼都運行在模塊作用域，不會污染全局作用域。
- 模塊可以多次加載，但是只會在第一次加載時運行一次，然后運行結果就被緩存了，以后再加載，就直接讀取緩存結果。要想讓模塊再次運行，必須清除緩存。
- 模塊加載的順序，按照其在代碼中出現的順序。
module對象
Node內部提供一個Module構建函數。所有模塊都是Module的實例。
function Module(id, parent) { this.id = id; this.exports = {}; this.parent = parent; // ... 每個模塊內部，都有一個module對象，代表當前模塊。它有以下屬性。
module.id模塊的識別符，通常是帶有絕對路徑的模塊文件名。module.filename模塊的文件名，帶有絕對路徑。module.loaded返回一個布爾值，表示模塊是否已經完成加載。module.parent返回一個對象，表示調用該模塊的模塊。module.children返回一個數組，表示該模塊要用到的其他模塊。module.exports表示模塊對外輸出的值。
下面是一個示例文件，最后一行輸出module變量。
// example.js var jquery = require('jquery'); exports.$ = jquery; console.log(module); 執行這個文件，命令行會輸出如下信息。
{ id: '.', exports: { '$': [Function] }, parent: null, filename: '/path/to/example.js', loaded: false, children: [ { id: '/path/to/node_modules/jquery/dist/jquery.js', exports: [Function], parent: [Circular], filename: '/path/to/node_modules/jquery/dist/jquery.js', loaded: true, children: [], paths: [Object] } ], paths: [ '/home/user/deleted/node_modules', '/home/user/node_modules', '/home/node_modules', '/node_modules' ] } 如果在命令行下調用某個模塊，比如node something.js，那么module.parent就是null。如果是在腳本之中調用，比如require('./something.js')，那么module.parent就是調用它的模塊。利用這一點，可以判斷當前模塊是否為入口腳本。
if (!module.parent) { // ran with `node something.js` app.listen(8088, function() { console.log('app listening on port 8088'); }) } else { // used with `require('/.something.js')` module.exports = app; } module.exports屬性
module.exports屬性表示當前模塊對外輸出的接口，其他文件加載該模塊，實際上就是讀取module.exports變量。
var EventEmitter = require('events').EventEmitter; module.exports = new EventEmitter(); setTimeout(function() { module.exports.emit('ready'); }, 1000); 上面模塊會在加載后1秒后，發出ready事件。其他文件監聽該事件，可以寫成下面這樣。
var a = require('./a'); a.on('ready', function() { console.log('module a is ready'); }); exports變量
為了方便，Node為每個模塊提供一個exports變量，指向module.exports。這等同在每個模塊頭部，有一行這樣的命令。
var exports = module.exports; 造成的結果是，在對外輸出模塊接口時，可以向exports對象添加方法。
exports.area = function (r) { return Math.PI * r * r; }; exports.circumference = function (r) { return 2 * Math.PI * r; }; 注意，不能直接將exports變量指向一個值，因為這樣等於切斷了exports與module.exports的聯系。
exports = function(x) {console.log(x)}; 上面這樣的寫法是無效的，因為exports不再指向module.exports了。
下面的寫法也是無效的。
exports.hello = function() { return 'hello'; }; module.exports = 'Hello world'; 上面代碼中，hello函數是無法對外輸出的，因為module.exports被重新賦值了。
這意味着，如果一個模塊的對外接口，就是一個單一的值，不能使用exports輸出，只能使用module.exports輸出。
module.exports = function (x){ console.log(x);}; 如果你覺得，exports與module.exports之間的區別很難分清，一個簡單的處理方法，就是放棄使用exports，只使用module.exports。
AMD規范與CommonJS規范的兼容性
CommonJS規范加載模塊是同步的，也就是說，只有加載完成，才能執行后面的操作。AMD規范則是非同步加載模塊，允許指定回調函數。由於Node.js主要用於服務器編程，模塊文件一般都已經存在於本地硬盤，所以加載起來比較快，不用考慮非同步加載的方式，所以CommonJS規范比較適用。但是，如果是瀏覽器環境，要從服務器端加載模塊，這時就必須采用非同步模式，因此瀏覽器端一般采用AMD規范。
AMD規范使用define方法定義模塊，下面就是一個例子：
define(['package/lib'], function(lib){ function foo(){ lib.log('hello world!'); } return { foo: foo }; }); AMD規范允許輸出的模塊兼容CommonJS規范，這時define方法需要寫成下面這樣：
define(function (require, exports, module){ var someModule = require("someModule"); var anotherModule = require("anotherModule"); someModule.doTehAwesome(); anotherModule.doMoarAwesome(); exports.asplode = function (){ someModule.doTehAwesome(); anotherModule.doMoarAwesome(); }; }); require命令
基本用法
Node使用CommonJS模塊規范，內置的require命令用於加載模塊文件。
require命令的基本功能是，讀入並執行一個JavaScript文件，然后返回該模塊的exports對象。如果沒有發現指定模塊，會報錯。
// example.js var invisible = function () { console.log("invisible"); } exports.message = "hi"; exports.say = function () { console.log(message); } 運行下面的命令，可以輸出exports對象。
var example = require('./example.js'); example // { // message: "hi", // say: [Function] // } 如果模塊輸出的是一個函數，那就不能定義在exports對象上面，而要定義在module.exports變量上面。
module.exports = function () { console.log("hello world") } require('./example2.js')() 上面代碼中，require命令調用自身，等於是執行module.exports，因此會輸出 hello world。
加載規則
require命令用於加載文件，后綴名默認為.js。
var foo = require('foo'); // 等同於 var foo = require('foo.js'); 根據參數的不同格式，require命令去不同路徑尋找模塊文件。
（1）如果參數字符串以“/”開頭，則表示加載的是一個位於絕對路徑的模塊文件。比如，require('/home/marco/foo.js')將加載/home/marco/foo.js。
（2）如果參數字符串以“./”開頭，則表示加載的是一個位於相對路徑（跟當前執行腳本的位置相比）的模塊文件。比如，require('./circle')將加載當前腳本同一目錄的circle.js。
（3）如果參數字符串不以“./“或”/“開頭，則表示加載的是一個默認提供的核心模塊（位於Node的系統安裝目錄中），或者一個位於各級node_modules目錄的已安裝模塊（全局安裝或局部安裝）。
舉例來說，腳本/home/user/projects/foo.js執行了require('bar.js')命令，Node會依次搜索以下文件。
- /usr/local/lib/node/bar.js
- /home/user/projects/node_modules/bar.js
- /home/user/node_modules/bar.js
- /home/node_modules/bar.js
- /node_modules/bar.js
這樣設計的目的是，使得不同的模塊可以將所依賴的模塊本地化。
（4）如果參數字符串不以“./“或”/“開頭，而且是一個路徑，比如require('example-module/path/to/file')，則將先找到example-module的位置，然后再以它為參數，找到后續路徑。
（5）如果指定的模塊文件沒有發現，Node會嘗試為文件名添加.js、.json、.node后，再去搜索。.js件會以文本格式的JavaScript腳本文件解析，.json文件會以JSON格式的文本文件解析，.node文件會以編譯后的二進制文件解析。
（6）如果想得到require命令加載的確切文件名，使用require.resolve()方法。
目錄的加載規則
通常，我們會把相關的文件會放在一個目錄里面，便於組織。這時，最好為該目錄設置一個入口文件，讓require方法可以通過這個入口文件，加載整個目錄。
在目錄中放置一個package.json文件，並且將入口文件寫入main字段。下面是一個例子。
// package.json { "name" : "some-library", "main" : "./lib/some-library.js" } require發現參數字符串指向一個目錄以后，會自動查看該目錄的package.json文件，然后加載main字段指定的入口文件。如果package.json文件沒有main字段，或者根本就沒有package.json文件，則會加載該目錄下的index.js文件或index.node文件。
模塊的緩存
第一次加載某個模塊時，Node會緩存該模塊。以后再加載該模塊，就直接從緩存取出該模塊的module.exports屬性。
require('./example.js'); require('./example.js').message = "hello"; require('./example.js').message // "hello" 上面代碼中，連續三次使用require命令，加載同一個模塊。第二次加載的時候，為輸出的對象添加了一個message屬性。但是第三次加載的時候，這個message屬性依然存在，這就證明require命令並沒有重新加載模塊文件，而是輸出了緩存。
如果想要多次執行某個模塊，可以讓該模塊輸出一個函數，然后每次require這個模塊的時候，重新執行一下輸出的函數。
所有緩存的模塊保存在require.cache之中，如果想刪除模塊的緩存，可以像下面這樣寫。
// 刪除指定模塊的緩存 delete require.cache[moduleName]; // 刪除所有模塊的緩存 Object.keys(require.cache).forEach(function(key) { delete require.cache[key]; }) 注意，緩存是根據絕對路徑識別模塊的，如果同樣的模塊名，但是保存在不同的路徑，require命令還是會重新加載該模塊。
環境變量NODE_PATH
Node執行一個腳本時，會先查看環境變量NODE_PATH。它是一組以冒號分隔的絕對路徑。在其他位置找不到指定模塊時，Node會去這些路徑查找。
可以將NODE_PATH添加到.bashrc。
export NODE_PATH="/usr/local/lib/node" 所以，如果遇到復雜的相對路徑，比如下面這樣。
var myModule = require('../../../../lib/myModule'); 有兩種解決方法，一是將該文件加入node_modules目錄，二是修改NODE_PATH環境變量，package.json文件可以采用下面的寫法。
{ "name": "node_path", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "start": "NODE_PATH=lib node index.js" }, "author": "", "license": "ISC" } NODE_PATH是歷史遺留下來的一個路徑解決方案，通常不應該使用，而應該使用node_modules目錄機制。
模塊的循環加載
如果發生模塊的循環加載，即A加載B，B又加載A，則B將加載A的不完整版本。
// a.js exports.x = 'a1'; console.log('a.js ', require('./b.js').x); exports.x = 'a2'; // b.js exports.x = 'b1'; console.log('b.js ', require('./a.js').x); exports.x = 'b2'; // main.js console.log('main.js ', require('./a.js').x); console.log('main.js ', require('./b.js').x); 上面代碼是三個JavaScript文件。其中，a.js加載了b.js，而b.js又加載a.js。這時，Node返回a.js的不完整版本，所以執行結果如下。
$ node main.js b.js a1 a.js b2 main.js a2 main.js b2 修改main.js，再次加載a.js和b.js。
// main.js console.log('main.js ', require('./a.js').x); console.log('main.js ', require('./b.js').x); console.log('main.js ', require('./a.js').x); console.log('main.js ', require('./b.js').x); 執行上面代碼，結果如下。
$ node main.js b.js a1 a.js b2 main.js a2 main.js b2 main.js a2 main.js b2 上面代碼中，第二次加載a.js和b.js時，會直接從緩存讀取exports屬性，所以a.js和b.js內部的console.log語句都不會執行了。
require.main
require方法有一個main屬性，可以用來判斷模塊是直接執行，還是被調用執行。
直接執行的時候（node module.js），require.main屬性指向模塊本身。
require.main === module // true 調用執行的時候（通過require加載該腳本執行），上面的表達式返回false。
模塊的加載機制
CommonJS模塊的加載機制是，輸入的是被輸出的值的拷貝。也就是說，一旦輸出一個值，模塊內部的變化就影響不到這個值。請看下面這個例子。
下面是一個模塊文件lib.js。
// lib.js var counter = 3; function incCounter() { counter++; } module.exports = { counter: counter, incCounter: incCounter, }; 上面代碼輸出內部變量counter和改寫這個變量的內部方法incCounter。
然后，加載上面的模塊。
// main.js var counter = require('./lib').counter; var incCounter = require('./lib').incCounter; console.log(counter); // 3 incCounter(); console.log(counter); // 3 上面代碼說明，counter輸出以后，lib.js模塊內部的變化就影響不到counter了。
require的內部處理流程
require命令是CommonJS規范之中，用來加載其他模塊的命令。它其實不是一個全局命令，而是指向當前模塊的module.require命令，而后者又調用Node的內部命令Module._load。
Module._load = function(request, parent, isMain) { // 1. 檢查 Module._cache，是否緩存之中有指定模塊 // 2. 如果緩存之中沒有，就創建一個新的Module實例 // 3. 將它保存到緩存 // 4. 使用 module.load() 加載指定的模塊文件， // 讀取文件內容之后，使用 module.compile() 執行文件代碼 // 5. 如果加載/解析過程報錯，就從緩存刪除該模塊 // 6. 返回該模塊的 module.exports }; 上面的第4步，采用module.compile()執行指定模塊的腳本，邏輯如下。
Module.prototype._compile = function(content, filename) { // 1. 生成一個require函數，指向module.require // 2. 加載其他輔助方法到require // 3. 將文件內容放到一個函數之中，該函數可調用 require // 4. 執行該函數 }; 上面的第1步和第2步，require函數及其輔助方法主要如下。
require(): 加載外部模塊require.resolve()：將模塊名解析到一個絕對路徑require.main：指向主模塊require.cache：指向所有緩存的模塊require.extensions：根據文件的后綴名，調用不同的執行函數
一旦require函數准備完畢，整個所要加載的腳本內容，就被放到一個新的函數之中，這樣可以避免污染全局環境。該函數的參數包括require、module、exports，以及其他一些參數。
(function (exports, require, module, __filename, __dirname) { // YOUR CODE INJECTED HERE! }); Module._compile方法是同步執行的，所以Module._load要等它執行完成，才會向用戶返回module.exports的值。
require方法接受以下幾種參數的傳遞：
1. http、fs、path等，原生模塊。
2. ./mod或../mod，相對路徑的文件模塊。
3. /pathtomodule/mod，絕對路徑的文件模塊。
4. mod，非原生模塊的文件模塊。
當require一個文件模塊時,從當前文件目錄開始查找node_modules目錄；然后依次進入父目錄，查找父目錄下的
node_modules目錄；依次迭代，直到根目錄下的node_modules目錄。
簡而言之，如果require絕對路徑的文件，查找時不會去遍歷每一個node_modules目錄，其速度最快。其余
流程如下：
從module path數組中取出第一個目錄作為查找基准。
1. 直接從目錄中查找該文件，如果存在，則結束查找。如果不存在，則進行下一條查找。
2. 嘗試添加.js、.json、.node后綴后查找，如果存在文件，則結束查找。如果不存在，則進行下一條。
3. 嘗試將require的參數作為一個包來進行查找，讀取目錄下的package.json文件，取得main參數指定的文件。
4. 嘗試查找該文件，如果存在，則結束查找。如果不存在，則進行第3條查找
5. 如果繼續失敗，則取出module path數組中的下一個目錄作為基准查找，循環第1至5個步驟。
6. 如果繼續失敗，循環第1至6個步驟，直到module path中的最后一個值。
7. 如果仍然失敗，則拋出異常。
module.exports還是exports
一個模塊可以通過module.exports或exports將函數、變量等導出，以使其它JavaScript腳本通過require()函數引
入並使用。
如果你想你的模塊是一個特定的類型就用module.exports。如果你想的模塊是一個典型
的”實例化對象”就用exports。
require返回的其實是module.exports這個方法，exports其實是指向module.exports的一個引用
二、Node.js的Path對象
NodeJS中的Path對象，用於處理目錄的對象，提高開發效率。 用NodeJS的Path命令，與使用Linux下的shell腳本
命令相似。
引入path對象:
var path = require('path');
比較實用的方法：
1. path.normalize(p) : 格式化路徑
特點：將不符合規范的路徑格式化，簡化開發人員中處理各種復雜的路徑判斷
2. path.join([path1], [path2], […]) : 路徑合並
特點：將所有名稱用path.seq串聯起來，然后用normailze格式化
3. path.resolve([from …], to) : 路徑尋航
特點：相當於不斷的調用系統的cd命令
示例：
path.normalize('/foo/bar//baz/asdf/quux/..');
=> '/foo/bar/baz/asdf'
示例：
path.join('///foo', 'bar', '//baz/asdf', 'quux', '..');
=>'/foo/bar/baz/asdf'
4. path.relative(from, to) : 相對路徑
特點：返回某個路徑下相對於另一個路徑的相對位置串，相當於：path.resolve(from, path.relative(from,
to)) == path.resolve(to)
5. path.dirname(p) : 文件夾名稱
特點：返回路徑的所在的文件夾名稱
6. path.basename(p, [ext]) : 文件名稱
6. path.basename(p, [ext]) : 文件名稱
特點：返回指定的文件名，返回結果可排除[ext]后綴字符串
7. 擴展名稱 path.extname(p)
示例：
path.resolve('foo/bar', '/tmp/file/', '..', 'a/../subfile')
//相當於：
cd foo/bar
cd /tmp/file/
cd ..
cd a/../subfile
pwd
示例：
path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb')
=>'..\\..\\impl\\bbb'
path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb')
=>'../../impl/bbb'
示例：
path.dirname('/foo/bar/baz/asdf/quux')
=>'/foo/bar/baz/asdf'
示例
path.basename('/foo/bar/baz/asdf/quux.html')
=>'quux.html'
path.basename('/foo/bar/baz/asdf/quux.html', '.html')
=>'quux'
特點：返回指定文件名的擴展名稱
8. 特定平台的文件分隔符 path.sep
特點：獲取文件路徑的分隔符，主要是與操作系統相關
9. 特定平台的路徑分隔符 path.delimiter
特定平台的路徑分隔符, ‘;‘ 或者 ‘:‘.
Linux 上的例子:
Windows 上的例子:
示例：
path.extname('index.html')
=>'.html'
path.extname('index.')
=>'.'
path.extname('index')
=>''
示例：
linux:
'foo/bar/baz'.split(path.sep)
=>['foo', 'bar', 'baz']
window:
'foo\\bar\\baz'.split(path.sep)
=>['foo', 'bar', 'baz']
process.env.PATH.split(path.delimiter)
// returns
['/usr/bin', '/bin', '/usr/sbin', '/sbin', '/usr/local/bin']
console.log(process.env.PATH)
// 'C:\Windows\system32;C:\Windows;C:\Program Files\nodejs\'
process.env.PATH.split(path.delimiter)
// returns
['C:\Windows\system32', 'C:\Windows', 'C:\Program Files\nodejs\']
process.env.PATH.split(path.delimiter)
// returns
['C:\Windows\system32', 'C:\Windows', 'C:\Program Files\nodejs\']
nodejs 全局變量
1. module.filename：開發期間，該行代碼所在的文件。
2. __filename：始終等於 module.filename。
3. __dirname：開發期間，該行代碼所在的目錄。
4. process.cwd()：運行node的工作目錄，可以使用 cd /d 修改工作目錄。
5. require.main.filename：用node命令啟動的module的filename, 如 node xxx，這里的filename就是這個
xxx。
require()方法的坐標路徑是：module.filename；
fs.readFile()的坐標路徑是：process.cwd()。
異步（async）和同步(sync)
Nodejs中Api一般都是異步的接口，如果調用同步的只需要在后面加上xxxSync()。
Node.js 文件系統（fs 模塊）模塊中的方法均有異步和同步版本，例如讀取文件內容的函數有異步的
fs.readFile() 和同步的 fs.readFileSync()。
Node文件系統：目錄操作
1. 判斷文件路徑是否存在： fs.exists(path, callback)
參數說明：
2. 創建目錄 fs.mkdir/mkdirSync(path[, mode], callback)
var fs = require("fs");
//異步讀取文件
fs.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
}
console.log("Asynchronous read: " + data.toString());
});
// /同步讀取文件
var data = fs.readFileSync('input.txt');
console.log("Synchronous read: " + data.toString());
console.log("Program Ended");
path 欲檢測的文件路徑
callback 回調
fs.exists("test",function(exists){
console.log(exists);
})
path - 文件路徑 ; mode - 設置目錄權限，默認為0777 callback - 回調函數
3. 查看目錄 fs.readdir(path, callback(err, files))
path - 文件路徑。
callback - 回調函數，回調函數帶有兩個參數err, files，err 為錯誤信息，files 為 目錄下的文件數組列表
返回結果： [ 'note.txt' ]
4. 刪除目錄 fs.rmdir(path, callback)
參數使用說明如下：
path - 文件路徑。 callback - 回調函數，沒有參數。
注意：只能刪除空的目錄，有文件的目錄會報錯：
[Error: ENOTEMPTY: directory not empty, rmdir 'F:\FullStack-Cource-2017\Nodejs-Laravel-Action\03-
Node模塊-FileSystem\test']
Node文件模塊:文件操作說明
1. 寫入文件 fs.writeFile(filename, data[, options], callback)
如果文件存在，寫入的內容會覆蓋舊文件內容
參數使用說明如下：
var fs = require("fs");
fs.mkdir("test",function(error){
if (err) return console.error(err);
console.log('目錄創建成功');
})
fs.readdir("test",function(error,files){
console.log(files);
})
fs.rmdir("test",function(error){
console.log(error);
})
2. 文件讀取 fs.readFile( url , code , callback);
1. 異步讀取文件
fs.readFile("test/1.txt","utf-8",function(error,data){ console.log(data); })
2. 異步讀取文件
var data =fs.readFileSync("test/1.txt","utf-8"); console.log(data);
3. 向文件中追加寫入 fs.appendFile(name,str,encode,callback);
參數說明：
name : 文件名 str ： 添加的字段 encode ： 設置編碼 callback ： 回調函數
栗子
fs.appendFile("test/1.txt",'窗前明月光，疑是地上霜','utf8',function(eror){
})
4. 改變文件名 : fs.rename(old文件名，新文件名，callback(傳遞一個err
參數))
fs.rename("test/1.txt","test/a.txt",function(error){
})
5. 查看文件狀態 fs.stat(fileaddr,callback(error,stats))
在fs模塊中，可以使用 fs.stat() 方法或 fs.lstat() 方法查看一個文件或目錄的信息，如文件的大小、創建時
間、權限等信息。這兩個方法的唯一區別是當查看符號鏈接文件的信息時，必須使用 fs.lstat() 方法。
var fs = require("fs"); var path = require("path");
path - 文件路徑。
data - 要寫入文件的數據，可以是 String(字符串) 或 Buffer(流) 對象。
options - 該參數是一個對象，包含 {encoding, mode, flag}。默認編碼為 utf8, 模式為 0666 ，flag 為
'w'
callback - 回調函數，回調函數只包含錯誤信息參數(err)，在寫入失敗時返回。
var fs = require("fs");
fs.writeFile("test/1.txt","hello file",function(error){
console.log(error);
})
var fileaddr = path.resolve(__dirname,"file/note.txt");
/**
* fileaddr: 需要查看狀態的相對，或者絕對地址
fs.Stats對象的方法如下：
stats.isFile() ： 判斷被查看對象是否是一個文件。如果是標准文件，返回true。是目錄、套接字、符號連
接、或設備等返回false。
stats. isDirectory() ： 判斷被查看對象是否是一個目錄。如果是目錄，返回true。
stats. isBlockDevice() ： 判斷被查看對象是否是一個塊設備文件。 如果是塊設備，返回true，大多數情況下
類UNIX系統的塊設備都位於/dev目錄下。
stats. isCharacterDevice() ： 判斷被查看對象是否是一個字符設備文件。如果是字符設備，返回true。
stats. isSymbolicLink() ： 判斷被查看對象是否是一個符號鏈接文件。如果是符號連接，返回true。該方法僅
在fs.lstat()方法的回調函數中有效。
stats.isFIFO() ： 判斷被查看對象是否是一個FIFO文件。如果是FIFO，返回true。FIFO是UNIX中的一種特殊
類型的命令管道。該方法僅在LINUX系統下有效。
stats.isSocket() ： 判斷被查看對象是否是一個socket文件。 如果是UNIX套接字，返回true。該方法僅在
LINUX系統下有效。
fs.Stats對象的屬性如下：
dev : 文件或目錄所在的設備ID。該屬性值在UNIX系統下有效；
mode : 文件或目錄的權限標志，采用數值形式表示；
nlink : 文件或目錄的的硬連接數量；
uid : 文件或目錄的所有者的用戶ID。該屬性值在UNIX系統下有效；
gid : 文件或目錄的所有者的用戶組ID。該屬性值在UNIX系統下有效；
rdev : 字符設備文件或塊設備文件所在設備ID。該屬性值在UNIX系統下有效；**
ino : 文件或目錄的索引編號。該屬性值僅在UNIX系統下有效；
size : 文件的字節數；
* callback(error,stats): error:返回的錯誤信息
* stats:返回的成功信息
*/
fs.stat(fileaddr,function(error,stats){
if(error){
console.log(error)
}else{
console.log(stats);
console.log(stats.isFile());
console.log(stats.isDirectory());
console.log(stats.isCharacterDevice());
console.log(stats.isSymbolicLink());
console.log(stats.isFIFO());
console.log(stats.isSocket());
console.log(stats.isBlockDevice());
}
})
atime : 文件或目錄的訪問時間；
mtime : 文件或目錄的最后修改時間；
ctime : 文件或目錄狀態的最后修改時間；
birthtime : 文件創建時間，文件創建時生成。在一些不提供文件
birthtime 的文件系統中，這個字段會使用 ctime 或 1970-01-01T00:00Z 來填充；
6. 刪除文件 fs.unlink(path, callback)
參數說明
path - 文件路徑 callback - 回調函數，無參
fs.unlink("test/a.txt",function(){})
url
┌─────────────────────────────────────────────────────────────────────────────────────────────┐ │ href │ ├──────────┬──┬─────────────────────┬─────────────────────┬───────────────────────────┬───────┤ │ protocol │ │ auth │ host │ path │ hash │ │ │ │ ├──────────────┬──────┼──────────┬────────────────┤ │ │ │ │ │ hostname │ port │ pathname │ search │ │ │ │ │ │ │ │ ├─┬──────────────┤ │ │ │ │ │ │ │ │ │ query │ │ " https: // user : pass @ sub.host.com : 8080 /p/a/t/h ? query=string #hash " │ │ │ │ │ hostname │ port │ │ │ │ │ │ │ │ ├──────────────┴──────┤ │ │ │ │ protocol │ │ username │ password │ host │ │ │ │ ├──────────┴──┼──────────┴──────────┼─────────────────────┤ │ │ │ │ origin │ │ origin │ pathname │ search │ hash │ ├─────────────┴─────────────────────┴─────────────────────┴──────────┴────────────────┴───────┤ │ href │ └─────────────────────────────────────────────────────────────────────────────────────────────┘
http服務器端 ：http.server的事件
1、http.Server 的事件
http.Server 是一個基於事件的 HTTP 服務器，所有的請求都被封裝為獨立的事件，開發者只需要對它的事件編寫
響應函數即可實現 HTTP 服務器的所有功能。它繼承自EventEmitter，提供了以下幾個事件。
①request：當客戶端請求到來時，該事件被觸發，提供兩個參數 req 和res，分別是http.ServerRequest 和
http.ServerResponse 的實例，表示請求和響應信息。
request.post('http://service.com/upload', {form:{key:'value'}})
request.post('http://service.com/upload').form({key:'value'})
var r = request.post('http://service.com/upload')
var form = r.form()
form.append('my_field', 'my_value')
form.append('my_buffer', new Buffer([1, 2, 3]))
form.append('my_file', fs.createReadStream(path.join(__dirname, 'doodle.png'))
form.append('remote_file', request('http://google.com/doodle.png'))
var server =new http.Server();
server.on("request",function(request,response){
//用於接收客戶端post過來的數據
var reqJson="";
request.on("data",function(chunk){
reqJson +=chunk;
});
request.on("end",function(){
console.log(reqJson);
response.writeHead(200,{
'Content-Type':'text/html'
});
//對接收的數據處理后返回
response.end(reqJson);
})
});
② connection：當 TCP 連接建立時，該事件被觸發，提供一個參數 socket，為net.Socket 的實例。
connection 事件的粒度要大於 request，因為客戶端在Keep-Alive 模式下可能會在同一個連接內發送多次請
求。
③close ：當服務器關閉時，該事件被觸發。注意不是在用戶連接斷開時。除此之外還有 checkContinue、
upgrade、clientError 事件，通常我們不需要關心，只有在實現復雜的 HTTP 服務器的時候才會用到。
在這些事件中， 最常用的就是 request 了， 因此 http 提供了一個捷徑：
http.createServer([requestListener]) ， 功能是創建一個 HTTP 服務器並將requestListener 作為 request 事
件的監聽函數，這也是我們前面例子中使用的方法。
var http = require('http');
/**
* 創建服務器的兩種寫法，第一種寫法如下
* 由於server已經繼承了EventEmitter的事件功能，所以可以使用高級函數編寫方式監控事件
* @param {Function} request event
*/
var server = http.createServer(function(req,res)
{
//這里的req為http.serverRequest
res.writeHeader(200,{'Content-Type':'text/plain'});
res.end('hello world');
});
/**
* 說明：創建服務器的第二種寫法
* 有關server對象的事件監聽
* @param {Object} req 是http.IncomingMessag的一個實例，在keep-alive連接中支持多個請求
* @param {Object} res 是http.ServerResponse的一個實例
*/
var server = new http.Server();
server.on('request',function(req,res){
res.writeHeader(200,{'Content-Type':'text/plain'});
res.end('hello world');
});
/**
* 說明：新的TCP流建立時出發。 socket是一個net.Socket對象。 通常用戶無需處理該事件。
* 特別注意，協議解析器綁定套接字時采用的方式使套接字不會出發readable事件。 還可以通過
request.connection訪問socket。
* @param {Object} socket
*/
server.on('connection',function(socket){});
/**
* 源API: Event: 'close'
* 說明：關閉服務器時觸發
*/
server.on('close',function(){});
/**
* 說明：每當收到Expect: 100-continue的http請求時觸發。 如果未監聽該事件，服務器會酌情自動發送100
Continue響應。
* 處理該事件時，如果客戶端可以繼續發送請求主體則調用response.writeContinue， 如果不能則生成合適的HTTP
響應（例如，400 請求無效）
* 需要注意到, 當這個事件觸發並且被處理后, request 事件將不再會觸發.
* @param {Object} req
* @param {Object} req
*/
server.on('checkContinue',function(req,res){});
/**
* 說明：如果客戶端發起connect請求，如果服務器端沒有監聽，那么於客戶端請求的該連接將會被關閉
* @param {Object} req 是該HTTP請求的參數，與request事件中的相同。
* @param {Object} socket 是服務端與客戶端之間的網絡套接字。需要自己寫一個data事件監聽數據流
* @param {Object} head 是一個Buffer實例，隧道流的第一個包，該參數可能為空。
*/
server.on('connect',function(req,socket,head){});
/**
* 說明：這個事件主要是對HTTP協議升級為其他協議后的事件監聽，如果服務器端沒有監聽，那么於客戶端請求的該連
接將會被關閉
* @param {Object} req 是該HTTP請求的參數，與request事件中的相同。
* @param {Object} socket 是服務端與客戶端之間的網絡套接字。需要自己寫一個data事件監聽數據流
* @param {Object} head 是一個Buffer實例，升級后流的第一個包，該參數可能為空。
*/
server.on('upgrade',function(req,socket,head){});
/**
* 說明：如果一個客戶端連接觸發了一個 'error' 事件, 它就會轉發到這里
* @param {Object} exception
* @param {Object} socket
*/
server.on('clientError',function(exception,socket){});
/**
* 源API：server.listen(port, [hostname], [backlog], [callback])
* 說明：監聽一個 unix socket, 需要提供一個文件名而不是端口號和主機名。
* @param {Number} port 端口
* @param {String} host 主機
* @param {Number} backlog 等待隊列的最大長度，決定於操作系統平台，默認是511
* @param {Function} callback 異步回調函數
*/
//server.listen(3000,'localhost',100,function(){});
/**
* 源API：server.listen(path, [callback])
* 說明：啟動一個 UNIX 套接字服務器在所給路徑 path 上監聽連接。
* 可能用處：多路徑或渠道數據來源監聽分隔
* @param {String} path
* @param {Function} callback
*/
//server.listen('path',function(){})
/**
* 源API：server.listen(handle, [callback])
* 說明：Windows 不支持監聽一個文件描述符。
* @param {Object} handle 變量可以被設置為server 或者 socket
* @param {Function} callback
*/
//server.listen({},function(){});
/**
* 說明：最大請求頭數目限制, 默認 1000 個. 如果設置為0, 則代表不做任何限制.
* @type {number}
*/
server.maxHeadersCount = 1000;
/**
* 源API：server.setTimeout(msecs, callback)
* 說明：為套接字設定超時值。如果一個超時發生，那么Server對象上會分發一個'timeout'事件，同時將套接字作為
參數傳遞。
* 設置為0將阻止之后建立的連接的一切自動超時行為
* @param {Number} msecs
* @param
*/
server.setTimeout(1000,function(){});
/**
* 說明：一個套接字被判斷為超時之前的閑置毫秒數。 默認 120000 (2 分鍾)
* @type {number}
*/
server.timeout = 120000;
/**
* 說明：這里的主機將是本地
* @param {Number} port 端口
* @param {Function} callback 異步回調函數
*/
server.listen(3000,function(){
console.log('Listen port 3000');
});
var https = require('https');
var zlib = require('zlib');
var post_data="………………";//請求數據
var reqdata = JSON.stringify(post_data);
var options = {
hostname: '10.225.***.***',
port: '8443',
path: '/data/table/list',
method: 'POST',
rejectUnauthorized: false,
requestCert: true,
nodejs 簡單http 文件上傳
auth: 'admin:123456************',
headers: {
'username': 'admin',
'password': '123456************',
'Cookie': 'locale=zh_CN',
'X-BuildTime': '2015-01-01 20:04:11',
'Autologin': '4',
'Accept-Encoding': 'gzip, deflate',
'X-Timeout': '3600000',
'Content-Type': 'Application/json',
"Content-Length":reqdata.length
}
};
var req = https.request(options, function (res) {
});
req.write(reqdata);
req.on('response', function (response) {
switch (response.headers['content-encoding']) {
case 'gzip':
var body = '';
var gunzip = zlib.createGunzip();
response.pipe(gunzip);
gunzip.on('data', function (data) {
body += data;
});
gunzip.on('end', function () {
var returndatatojson= JSON.parse(body);
req.end();
});
gunzip.on('error', function (e) {
console.log('error' + e.toString());
req.end();
});
break;
case 'deflate':
var output = fs.createWriteStream("d:temp.txt");
response.pipe(zlib.createInflate()).pipe(output);
req.end();
break;
default:req.end();
break;
}
});
req.on('error', function (e) {
console.log(new Error('problem with request: ' + e.message));
req.end();
setTimeout(cb, 10);
});
// 這是一個簡單的Node HTTP,能處理當前目錄的文件
// 並能實現良種特殊的URL用於測試
// 用http://localhost:8000 或http://127.0.0.1:8000 連接這個服務器
// 首先,加載所有要用的模塊
var http = require('http'); // HTTP服務器API
var fs = require('fs'); // 文件系統API
var server = new http.Server(); // 創建新的HTTP服務器
var port = 8000;
server.listen(port); // 在端口8000傷運行它
var log = require('util').log;
log('Http Server is listening ' + port + ' port.');
// Node使用'on'方法注冊事件處理程序
// 當服務器收到新請求,則運行函數處理它
server.on('request', function(request, response) {
var filename = null;
// 解析請求的URL
var url = require('url').parse(request.url);
switch(url.pathname) {
case '/upload':
var _fileName = request.headers['file-name'];
log(_fileName);
request.once('data', function(data) {
// 大文件
// var fis = fs.createWriteStream('/txt.txt');
// fis.write(data);
// fis.end();
fs.writeFile(_fileName, data);
response.end();
});
break;
case '/' || '/index.html' :
filename = 'index.html';
default:
filename = filename || url.pathname.substring(1); // 去掉前導'/'
// 基於其擴展名推測內容類型
var type = (function(_type) {
switch(_type) { // 擴展名
case 'html':
case 'htm': return 'text/html; charset=UTF-8';
case 'js': return 'application/javascript; charset=UTF-8';
case 'css': return 'text/css; charset=UTF-8';
case 'txt': return 'text/plain; charset=UTF-8';
case 'manifest': return 'text/cache-manifest; charset=UTF-8';
default: return 'application/octet-stream';
}
}(filename.substring(filename.lastIndexOf('.') + 1)));
// 異步讀取文件,並將內容作為單獨的數據塊傳回給回調函數
// 對於確實很大的文件,使用API fs.createReadStream()更好
fs.readFile(filename, function(err, content) {
if (err) { // 如果由於某些原因無法讀取文件
response.writeHead(404, {'Content-type' : 'text/plain; charset=UTF-8'});
response.write(err.message);
} else { // 否則讀取文件成功
response.writeHead(200, {'Content-type' : type});
response.write(content); // 把文件內容作為響應主體
}
response.end();
});
}
});
2、http.ServerRequest
http.ServerRequest 是 HTTP 請求的信息，是后端開發者最關注的內容。它一般由http.Server 的 request
事件發送，作為第一個參數傳遞，通常簡稱 request 或 req。
HTTP 請求一般可以分為兩部分：請求頭（Request Header）和請求體（Requset Body）。以上內容由於長
度較短都可以在請求頭解析完成后立即讀取。而請求體可能相對較長，需要一定的時間傳輸。
http.ServerRequest 提供了以下3個事件用於控制請求體傳輸。
data ：當請求體數據到來時，該事件被觸發。該事件提供一個參數 chunk，表示接收到的數據。如果該事件
沒有被監聽，那么請求體將會被拋棄。該事件可能會被調用多次。
end ：當請求體數據傳輸完成時，該事件被觸發，此后將不會再有數據到來。
close： 用戶當前請求結束時，該事件被觸發。不同於 end，如果用戶強制終止了傳輸，也還是調用close。