nodejs和vue的那些事

1. 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密集、少許業務邏輯的場景。

Ryan dahl對node.js初衷

2008年，我在尋找一個新的編程平臺來作網站。我並非想要一門新的語言，實際上，語言自身的細節對我來講並不重要。我真正關心的是，該語言可否提供先進的推送功能並集成到網站中來，就像我在Gmail中看到的那樣——可以從服務器端把數據主動推送給用戶，而不是採用不斷輪詢拉取數據的方式。現有的平臺都把服務器做爲接受請求而後返回相應內容的設備。要把事件推送到瀏覽器，平臺須要可以持續處理大量打開的網絡鏈接，而這其中有許多鏈接實際上是空閒的。

我知道如何使用系統調用（用C）實現這樣的功能。若是隻使用非阻塞式socket，每一個鏈接的開銷都會很是小。在小規模測試中，我能夠演示一臺服務器，它能同時處理幾千個閒置鏈接，或實現至關大的吞吐量。我知道這是在Unix服務器上用戶空間程序可以實現的最優操做了。可是，我並不想使用C，我須要的是一種漂亮靈活的動態語言。若是須要，我能夠在每種編程語言中都用如出一轍的系統調用，但這樣作異常醜陋，並且這只是socket編程的「替代」方法而已。我認爲，非阻塞socket編程並不是那麼困難，只要一切都作成非阻塞的就能夠實現了。

因而，我有了個主意：JavaScript結合非阻塞socket！由於JavaScript並無現成的socket庫，因此我能夠勇作第一人，來推介這個嶄新且大有前途的接口。只要把V8接上個人非阻塞C代碼，我就能把它完成。我終止了當時承接的工做，開始全力實現這個想法。當我編寫好併發布了最初的版本後，馬上就有用戶開始反饋bug，而後我開始不停地處理這些bug，就這樣，不知不覺過去了3年。

實踐證實，JavaScript與非阻塞socket配合得至關完美。開始我並不敢確定這一點，但閉包讓全部事情變得可能。只須要簡單的幾行JavaScript代碼，就能夠構建出很是複雜的非阻塞服務器。我最初還擔憂，系統會過於小衆，但很快我就放心了，由於世界各地的黑客們紛紛開始爲其編寫程序庫。惟一的事件循環隊列和純粹的非阻塞接口讓程序庫沒必要增長昂貴的線程，就能添加愈來愈多的複雜功能。

在Node中，用戶會發現系統在默認狀況下就能很好地擴展。由於其核心繫統作出的選擇是，不容許系統中的任何部分作出太壞的事情來（好比堵塞當前線程），因此總體性能也不會太差。若是以可以處理的流量做爲計量，Node的方法要比傳統的阻塞式操做好上一個數量級。

如今，Node已經在全球被衆多公司所使用，包括創業公司、Voxer、Uber，以及沃爾瑪、微軟這樣的知名公司。能夠說，天天經過Node處理的請求數以億計。隨着愈來愈多的人蔘與到本項目中來，可用的第三方模塊和擴展增加迅猛，並且質量也不斷提高。雖然我曾建議將Node用於關鍵任務應用，但如今，即使是要求最苛刻的服務器系統，我也會熱誠地推薦使用Node。

>5.commonjs

1.如何定義一個自定義的模塊

一個文件就是一個模塊 a.js 文件名就是模塊 a

2.模塊中能放那些東西

 function class variable

Node，CommonJS，瀏覽器甚至是W3C之間有什麼關係：

  |---------------瀏覽器----- ------------------|        |--------------------------CommonJS----------------------------------|

 

  |  BOM  |       | DOM |        | ECMAScript |         | FS |           | TCP |         | Stream |        | Buffer |          |........|

 

  |-------W3C-----------|       |---------------------------------------Node--------------------------------------------------|

CommonJS定義的模塊分爲:{模塊引用(require)} {模塊定義(exports)} {模塊標識(module)}

 

require()用來引入外部模塊；exports對象用於導出當前模塊的方法或變量，惟一的導出口；module對象就表明模塊自己。

 //sum.js

 exports.sum = function(){...作加操做..};

 

 //calculate.js

 var math = require('sum');

exports.add = function(n){

    return math.sum(val,n);

 };

 

CommonJS定義的模塊分爲:{模塊引用(require)} {模塊定義(exports)} {模塊標識(module)}

 

require()用來引入外部模塊；exports對象用於導出當前模塊的方法或變量，惟一的導出口；module對象就表明模塊自己。

 //sum.js

 exports.sum = function(){...作加操做..};

 

 //calculate.js

 var math = require('sum');

exports.add = function(n){

    return math.sum(val,n);

 };

 

2、AMD

 

CommonJS是主要爲了JS在後端的表現制定的，他是不適合前端的，爲何這麼說呢？

 

這須要分析一下瀏覽器端的js和服務器端js都主要作了哪些事，有什麼不一樣了：

 

 

 

---------------------------------------服務器端JS   |    瀏覽器端JS-------------------------------------------

 

                                   相同的代碼須要屢次執行  |    代碼須要從一個服務器端分發到多個客戶端執行

 

                                     CPU和內存資源是瓶頸   |    帶寬是瓶頸

 

                                        加載時從磁盤中加載   |    加載時須要經過網絡加載

 

---------------------------------------------------------------------------------------------------------------

 

 

 

因而乎，AMD(異步模塊定義)出現了，它就主要爲前端JS的表現制定規範。

 

AMD就只有一個接口：define(id?,dependencies?,factory);

 

它要在聲明模塊的時候制定全部的依賴(dep)，而且還要當作形參傳到factory中，像這樣：

 

 

 

 define(['dep1','dep2'],function(dep1,dep2){...});

 

 

define(function(){

     var exports = {};

     exports.method = function(){...};

     return exports;

 });

 

概述

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的一個引用
2、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的事件
一、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();
});
}
});

二、http.ServerRequesthttp.ServerRequest 是 HTTP 請求的信息，是後端開發者最關注的內容。它通常由http.Server 的 request事件發送，做爲第一個參數傳遞，一般簡稱 request 或 req。HTTP 請求通常能夠分爲兩部分：請求頭（Request Header）和請求體（Requset Body）。以上內容因爲長度較短均可以在請求頭解析完成後當即讀取。而請求體可能相對較長，須要必定的時間傳輸。http.ServerRequest 提供瞭如下3個事件用於控制請求體傳輸。data ：當請求體數據到來時，該事件被觸發。該事件提供一個參數 chunk，表示接收到的數據。若是該事件沒有被監聽，那麼請求體將會被拋棄。該事件可能會被調用屢次。end ：當請求體數據傳輸完成時，該事件被觸發，此後將不會再有數據到來。close： 用戶當前請求結束時，該事件被觸發。不一樣於 end，若是用戶強制終止了傳輸，也仍是調用close。