閒來無事，把node又拾起來看看

        處在國企單位，成天閒的要死要死的，民族的花朵都快枯萎了

哎呀呀，打起精神.......早睡早起，多看書。。。開始進入苦讀狀態，苦練武功，爭取有朝一日報效祖國。。。哈哈  開玩笑的

開始看書吧  記得Node.js+MonogoDB+AngularJs 這本書好像是去年4月份買的  買了很久了 一直沒領會他的精髓  上班沒事  絕對再看看  雖然對個人工做沒什麼幫助，哎呀呀  仍是看吧.....................

1、node的事件模型：包含了事件隊列、事件循環、線程池

2、實現定時器：

 超時時間：延遲一段時間執行，只須要執行一次setTimeout();clearTimeout()取消超時時間函數

時間間隔：按按期的延遲時間間隔執行工做，對於按期工做setInterval();

即時計時器：setImmediate();容許你把工做調度爲在時間隊列中的當前事件完成以後執行，即在I/O事件的回調函數開始執行以後

process. nextTick：調度工做，在I/O時間被觸發以前執行

從事件循環中取消定時器引用：unref()/ref()從新引用

3、事件發射器和監聽器：

建立自定義事件：

4、Node.js處理數據：

數據形式有：文本、JSON字符串、二進制緩衝區、數據流

一、處理json

Json字符串轉js對象：JSON.parse(String);轉化爲對象用點來訪問

js對象轉爲JSON字符串：JSON.stringify();

2.使用buffer管理二進制的緩衝數據

（緩衝數據：有字節組成，比文本數據佔用較少空間）

node.js提供buffer(緩衝區模塊，全局性的，不須要require()引入)容許在緩衝結構中建立、讀取、寫入和操做二進制數據

建立緩衝區：new Buffer（）；

寫入緩衝區：buffer.writer();

讀取緩衝區：tostring();

肯定緩衝區長度：buffer.length();返回的是字節長度

複製緩衝區：buffer.copy(new_buffer);

緩衝區切片：buffer.slice(start,end);

拼接緩衝區：Buffer.concat();

3.使用Stream模塊來傳送數據流

（stream模塊是node的重要模塊。數據流是可讀、可寫、或者便可讀又可寫的內存結構）

流的目的是從一個地方向另外一個地方傳送數據的通用機制；流通常用於HTTP數據和文件

Readable流（可讀流）：

常見實例：在客戶端的HTTP相應、在服務器的HTTP請求、fs讀取流、zlib流、crypto(加密)流、TCP套接字、子進程的stdout和stderr、process.stdin

公開事件：readable/data/end/close/error

方法：read():從流中讀取數據。能夠返回string對象、buffer對象或者null

           setEncoding();設置從read()請求讀取返回string的編碼

          pause();暫停從該對象發出的data事件

          resume():恢復從該對象發出的data事件

          pipe(de,[options]);把這個流的輸出傳輸到由de目的地指定的writable流對象

          unpipe():從寫入的目的地斷開這一對象

實現自定義Readable流對象：

1.首先繼承：

var stream = require('stream');

var util = require('util');

util.inherits(answers,stream.Readable); //繼承了Readable流的功能

2.建立對象調用的實例：

function answers(opt){

　　stream.Readable.call(this,opt); //建立對象調用的實例

　　...........

}

3.調用push()來輸出Readable對象中的數據的_read()方法（即處理數據的推出）

answers.prototype._read = function(){

　　if(){

　　　　this.push();

　　}

}

Writable流（可寫流）：

把數據寫入一種能夠輕鬆的在代碼的另外一個區域被使用的形式的機制

常見實例：客戶端上的HTTP請求、服務騎上的HTTP響應、fs寫入流、zlib流、crypto（加密）流、TCP套接字、子進程的stdin、process.stdout/process.stderr

公開事件：drain/finish/pipe/unpipe

方法：

 

 

.................................喲嘿 下班了  ...明天繼續

 

2018/1/16       星期二  繼續 

 

Writable流（可寫流）：

公開事件：

drain：當準備好寫入更多的數據時，發出此事件通知監聽器

finish：等end()在Writable對象上調用，全部的數據都被刷新，而且不會有更多的數據將被接收時發出此事件

pipe：當pipe()方法在Readable流上被調用，以添加此Writable爲目的地，發出此事件

unpipe:當unpipe()方法在Readable流上被調用，以刪除此Writable爲目的地，發出此事件

 方法：

write("要寫入的數據"，【指定字符串的編碼】，【指定當數據已經徹底刷新時執行的回調函數】)：將數據塊寫入流對象的數據位置

end():與write()同，把writable對象置於不在接收數據的狀態，併發送finish事件

實現自定義writable流對象：

1.首先繼承：

var stream = require('stream');

var util = require('util');

util.inherits(answers,stream.writable); //繼承了writable流的功能

2.建立對象調用的實例：

function answers(opt){

　　stream.writable.call(this,opt); //建立對象調用的實例

　　this.data = new Array();

}

3.實現一個_write()方法存儲writable對象的數據（即處理數據的推出）

answers.prototype._write = function(data,encoding,callback){

　this.data.push(data.toString(encoding));

　　console.log(data);

　　callback();

};

4.調用：

var  W = new answers（）；

W.writer("iiiiiiii");

 

Duplex流（可讀可寫雙向流）：

（TCP套接字連接）

實現自定義Duplex流對象：

1.首先繼承：

var stream = require('stream');

var util = require('util');

util.inherits(answers,stream.Duplex); //繼承了Duplex流的功能

2.建立對象調用的實例：

function answers(opt){

　　stream.Duplex.call(this,opt); //建立對象調用的實例

　　this.data = [];

}

***************************************************************************

Duplex流的opt參數接受一個allowHalfOpen屬性設置爲true或false的對象，若是爲true,則即便可寫入端已經結束，可讀取端也保持打開狀態；反之亦然；若是爲false,則結束可寫入端也會結束可讀取端，反之亦然

****************************************************************************

3.實現一個全Duplex()流時，在原型化Duplex類的時候須要同時實現_read()方法和_write()方法

answers.prototype._write = function(data,encoding,callback){

　this.data.push(data.toString(encoding));

};

answers.prototype._read = function(){

　　this.push();

}

4.調用：

var  W = new answers（）；

W.writer("iiiiiiii");

W.on('data',function(chunk){　

})

 

Transform(交換)流：

擴展了Duplex流，但他修改了Writable流和Readable流之間的數據，當你須要修改從一個系統到另外一個系統的數據時，此流類型會很是有用。

Transform流的實例：

zlib流、crypto流

在Transform流中不須要實現_read()和_write()原型方法，這些被做爲直通函數提供，

可是須要實現_transform（"要寫入的數據"，【指定字符串的編碼】，【指定當數據已經徹底刷新時執行的回調函數】）方法和_flush（回調函數）方法

_transform（）接收來自Write()請求的數據，對齊修改，並推出修改後的數據

1.首先繼承：

var stream = require('stream');

var util = require('util');

util.inherits(answers,stream.Transform); //繼承了Duplex流的功能

2.建立對象調用的實例：

function answers(opt){

　　stream.Transform.call(this,opt); //建立對象調用的實例

}

3.實現一個Transform()流時，須要實現_transform()方法和_flush()方法

answers.prototype._transform = function(data,encoding,callback){}

answers.prototype._flush = function(data,encoding,callback){}

 

流對象最酷的事情：把Readable流用管道輸送到Writable流-----------------pipe(writableStrem,[options]):即把Readable流的輸出直接輸入到Writable流中

options參數接收一個end屬性設置爲true，或false的對象，當end爲true時，Writable流隨着Readable流的結束而結束。

readStream.pipe(WriteStream,{end:true});

 

zlib壓縮與解壓縮數據：

zilib壓縮模塊可使你很是方便、高效的壓縮和解壓縮在緩衝區中的數據

zlib支持的壓縮辦法：

gzip/gunzip:標準gzip壓縮

deflate/inflate:基於huffman編碼的標準deflate壓縮算法

deflateRaw/inflateRaw:針對原始緩衝區的deflate壓縮算法

壓縮和解壓緩衝區：

function(buffer,callback)  function:壓縮/解壓縮辦法   buffer:被壓縮/解壓縮的緩衝區  callback:壓縮/解壓縮發生以後執行的回調函數

壓縮和解壓縮流：

pipe();

 

Node訪問文件系統：（fs模塊）

若是須要經過管理動態文件來支持web應用程序或服務，文件系統的交互變得十分重要

fs模塊提供了大多數語言中可用的標準文件訪問API來打開、讀取、寫入文件及與其交互

（具有建立、讀取、修改、在目錄結構中穿行的能力、刪除、截斷、重命名文件和文件夾）

var fs = reqiure('fs');

同步和異步文件系統調用

異步：write()    同步：writeSync()

<英語很差的我呀    重症患者     同步：synchronization     異步：asynchronization>

(全部的異步調用最終都有一個額外的參數，即在調用完成時執行的回調函數，而且一般包含一個錯誤做爲其第一個參數err)

打開和關閉文件：

fs.open(path,flags,[mode],callback);

fs.openSync(path,flags,[mode]);

path:文件系統的標準路勁字符串，flags:指定打開文件的模式（r/r+/rs/rs+/w/wx/w+/wx+/a/ax/a+/ax+）

fs.close(fd,callback);

fs.close(fd)

寫入文件：

4種不一樣的方式將數據寫入文件

1.簡單文件寫入：

fs.writeFile(path,data,[options],callback)

fs.writeFileSync(path,data,[options])

path:指定文件路徑，data:寫入數據string或者buffer對象  options:參數是一個對象（可包含encoding/mode/flag）

2.同步文件寫入：（等待許久的快遞到了 。。先去那個快遞..）(沒有想象中的號 有點悲傷)

開始吧............

1.fs.openSync();打開文件

fs.writeSync(fd,data,offset,length,position)  寫入文件

3.異步寫入文件：

（異步方法爲了保證執行的吮吸，最簡單的辦法就是把異步操做卸載上一個慚怍的回調函數中）

1.fs.open()

2.fs.write(fd,data,offset,length,position,callback)

4.流式文件寫入

往一個文件寫入大量的數據，使用流是最好的辦法

Writeable流打開，經過pipe()管道鏈接Readable流

1.建立Writable對象

fs.creatWriteStream(path,[options])

2.使用標準的流式write（buffer）方法來寫，寫入完後調用end()方法關閉流

 

讀取文件：

1.簡單的讀取文件

fs.readFile(path,[options],callback)

fs.readFileSync(path,[options])

2.同步文件讀取

fs.openSync();

fs.readSync(fd,buffer,offset,length,position);

3.異步文件讀取

fs.open()

fs.read(fd,buffer,offset,length,position,callback);callback接收三個參數 error錯誤,bytes讀取的字節數,buffer從讀取請求填充數據的緩衝區

4.流式文件讀取

Readable流打開，經過pipe（）管道鏈接Writable流

fs.creatReadStream(path,[options]);

打開文件流後，經過read()請求，或者經過data事件處理讀出數據

 

驗證路徑的存在性：

fs.exists(path,callback) //回調函數帶參  傳入true或false

fs.exixtsSync(path)；//返回true或者false

獲取文件信息：

fs.stats(path,callback)

fs.statsSync(path)

 

 

 

。。。。。。。。。。。。。。。。下班了        沒看完 悲催  明天繼續.....

 

獲取文件信息：

fs.stats(path,callback);   stats對象做爲回調函數的第二個參數被傳入，而第一個參數是error

fs.statsSync(path);同步方法返回一個stats對象

stats對象上經常使用的屬性和方法：

isFile():若是是一個文件，返回true

isDirectory():若是是一個目錄，返回true

isSocket():若是是一個套接字，返回true

dev :指定文件所造的設備的ID

mode:指定文件的訪問模式

size:指定文件的字節數

blksize:指定用於存儲該文件的塊大小，以字節爲單位

blocks:指定文件在磁盤上佔用的塊的數目

atime:指定上次訪問文件的時間

mtime:指定文件的最後修改時間

ctime:指定文件的建立時間

 

列出文件：列出在目錄中的文件和文件夾

fs.readdir(path,callback)  返回的列表做爲第二個參數傳遞迴回調函數，錯誤做爲第一參數

fs.readdirSync(path)  返回指定目錄中條目名稱的字符串數組

 

刪除目錄：

fs.unlink(path,callback);

fs.unlinkSync(path);返回true或者false,表明是否刪除成功

 

截斷Truncate文件:經過把文件結束處設置爲比當前值小的值來減小文件大小（不是很清楚）

fs.truncate(path,len,callback);傳遞一個錯誤值給回調函數

fs.truncate(path,len);函數返回true/false

 

創建和刪除目錄：

創建目錄：

fs.mkdir(path,[mode],callback)

fs.mkdirSync(path,[mode])

mode:指定新目錄的訪問模式

刪除目錄：

fs.rmdir(path,callback)

fs.rmdirSync(path)

 

重命名文件和目錄：

fs.rename(oldpath,newpath,callback);//回調函數傳遞一個錯誤值

fs.renameSync(oldpath,newpath);

 

監視文件更改入：文件發生變化時執行回調函數

fs.watchFile(path,[options],callback);

options:是一個對象，包含:presistent(持續)和interval(間隔)屬性；{presistent:true}持續監視，{interval:2000}每隔2秒監視一次

callback:當文件發生變化，就會執行

 

在Node中實現HTTP服務：

 node提供內置的http和https模塊，實現HTTP和HTTPS服務器和服務的能力

使用http模塊實現客戶端和服務端時使用的對象：

處理URL：

（URL:統一資源定位符------充當HTTP服務器用來處理來自客戶端的請求的一個地址標籤）

協議http   身份驗證user:pass    主機名host  主機host.com    端口：80    路徑：resource/path?query=string   路徑名：resource      搜索/查詢: ？query=string  散列：#hash

http://user:pass@host.com:80/resource/path?query=string#hash

瞭解URL對象

url模塊：

把URL字符串轉化爲URL對象的功能

url.parse(urlstr,[parseQueryString],[slasheeDenoteHost])

parseQueryString：爲true，則解析查詢字符串部分爲對象字面量，默認爲false

slasheeDenoteHost:爲true把格式爲//host/path的URL解析爲{host:'host',pathname:'/path'}  而不是{pathname:'//host/path'},默認值爲false

把URL對象轉爲URL字符串

url.format(urlobj);

URL對象的屬性：

href/protocol/host/auth/hostname/port/pathname/search/path/query/hash

解析URL組件

把URL解析到新的位置，from:原始URL字符串，to:URL被解析到的新位置

url.resolve(from,to)://只是更改了路徑之後的位置

處理查詢字符串和表單參數：基本的鍵值對

使用querystring模塊的parse（）方法將字符串轉換成JS對象

使用querystring模塊的stringify（）方法將JS對象轉換成字符串

 

 

瞭解請求、響應、和服務器對象

http.clientRequest對象

http.request(options,callback);   //獲得一個ClientRequest對象

options:是一個對象，定義瞭如何把客戶端的HTTP請求打開併發送到服務器

callback:回調函數，惟一的參數是　　IncomingMessage對象，該對象來自服務端的響應

clientRequest對象實現了一個Writable流

clientRequest對象，指定的選項：

host/hostname/port/localAddress/socketPath/method/path/headers/auth/agent

http.serverResponse對象

使用serverResponse對象指定併發送到客戶端的響應，實現了一個writeable流 ，提供其的全部功能

http.IncomingMessage對象

IncomingMessage對象實現了一個Readable流，讓客戶端請求或服務器響應做爲流源讀入，意味着readable和data事件能夠被監聽並用來從六中讀出數據

 

HTTPserver對象

提供一個監聽端口的底層套接字和接收請求，而後發送響應給客戶端鏈接的處理程序

啓動HTTP服務器：

http.createServer([requestListiner]);//返回一個server對象

requestListener參數是請求事件被觸發時執行的回調函數，接收兩個慘，一個參數表明客戶端請求的IncomingMessage對象，第二個參數表明ServerResponse對象

經過server對象上的listen(port，【hostname】,【backlog】，【callback】)方法監聽

 

在node中實現HTTP客戶端和服務器

提供靜態文件服務：

1.啓動HTTP服務器並監聽端口

2.使用fs模塊在本地打開該文件，而後在響應中寫入文件內容

var fs = require('fs');

var http = reqiure('http');

var url = reqiure('url');

var root_dir = "html/";

http.createServer(function(request,response){     //建立server對象

　　var urlObj = url.parse(req.url,true,false);    //字符串轉對象，爲true，則解析查詢字符串部分爲對象字面量

　　fs.readFile(root_dir+urlObj.pathname,function(err,data){  //讀取靜態文件

　　　　if(err){

　　　　　　response.writerHead(404);

　　　　　　response.end(JSON.stringify(err));

　　　　　　return;

　　　　}

　　　　response.writeHead(200);

　　　　response.end(data); //把文件內容吸入響應對象中

　　})

}).listen(8080);

 

動態的GET服務器：