摘要：一個匿名函數(shù)，執(zhí)行，事件全部完成，執(zhí)行最后一句，程序執(zhí)行完畢。這個事件的監(jiān)聽器為一個匿名函數(shù)，事件名稱為，當(dāng)秒以后被觸發(fā)先對象發(fā)送一個事件觸發(fā)了匿名函數(shù)即監(jiān)聽器，監(jiān)聽器被執(zhí)行。

node.js單進(jìn)程，單線程的程序
每一個api都支持回調(diào)
所有的事件機制都是設(shè)計模式中的

一共是23種設(shè)計模式 
http://design-patterns.readth...
一個對象發(fā)生改變的時候，將自動通知其他對象，其他對象將相應(yīng)的做出反應(yīng)。發(fā)生改變的對象為觀察目標(biāo)，被通知的對象為觀察者。一個觀察目標(biāo)可以對應(yīng)多個觀察者，而這些觀察者之間沒有任何聯(lián)系，可以根據(jù)需要增加觀察者，使得系統(tǒng)更加容易擴展，依賴關(guān)系為一對多，又被稱為模型-視圖模式

web server接收到請求，將其關(guān)閉，進(jìn)行處理，然后接著服務(wù)下一個web請求。
當(dāng)請求完成以后，放回處理隊列，當(dāng)?shù)竭_(dá)隊列開頭的時候，將其結(jié)果返回給用戶
即非阻塞式I/O 事件驅(qū)動I/O
會有一個主循環(huán)來監(jiān)聽事件，當(dāng)檢測到事件以后，觸發(fā)回調(diào)函數(shù)

PS C:UsersmingmDesktop	est> node main.js
連接成功
數(shù)據(jù)接收成功
程序執(zhí)行完畢
PS C:UsersmingmDesktop	est>

// 引入一個 events 模塊
var events = require("events");
// 創(chuàng)建 eventEmitter對象
var eventEmitter = new events.EventEmitter();

// 創(chuàng)建connection事件的處理程序
var connectHandLer = function connected() {
    console.log("連接成功");

    // 觸發(fā) data_received 事件
    eventEmitter.emit("data_received");
};

// 綁定cinnection事件處理程序
eventEmitter.on("connection", connectHandLer);

// 綁定data_received事件，并完成處理程序的書寫
eventEmitter.on(
        "data_received",
        function() {
            console.log("數(shù)據(jù)接收成功");
        }
    );

// 觸發(fā) connection 事件
eventEmitter.emit("connection");

console.log("程序執(zhí)行完畢");

程序的執(zhí)行過程，先完成各種綁定，觸發(fā)connection事件以后，尋找綁定的處理程序，為connected()，然后，執(zhí)行一半，又被觸發(fā)，data_received事件。尋找綁定的處理程序。一個匿名函數(shù)，執(zhí)行，事件全部完成，執(zhí)行最后一句，程序執(zhí)行完畢。
多用戶執(zhí)行的情況下，觸發(fā)事件以后，若處理程序正被其他用戶占用，排隊，直到前方全部處理完成以后，接著該用戶使用處理程序進(jìn)行處理。

node所有的異步I/O操作在完成的時候都會發(fā)送到一個事件到達(dá)事件隊列。node里的對象能夠分發(fā)事件
產(chǎn)生的事件的對象都是events.EventEmitter的實例

events模塊提供一個對象，它是對事件的觸發(fā)和事件的監(jiān)聽的封裝

PS C:UsersmingmDesktop	est> node main.js
事件觸發(fā)
PS C:UsersmingmDesktop	est>

過五秒后響應(yīng)

// event.js文件
var EventEmitter = require("events").EventEmitter;
var event = new EventEmitter();    // 創(chuàng)建一個event對象
event.on("some_event", function(){console.log("事件觸發(fā)");});
setTimeout(function(){event.emit("some_event");}, 5000);

大概解釋一下這段代碼
前兩句很簡單，后兩句說一下，event的對象注冊了一個事件的監(jiān)聽器。這個事件的監(jiān)聽器為一個匿名函數(shù)，事件名稱為some_event，當(dāng)5000秒以后被觸發(fā)先對象event發(fā)送一個事件some_event觸發(fā)了匿名函數(shù)即監(jiān)聽器，監(jiān)聽器被執(zhí)行。
其中EventEmitter的每個事件由一個事件名和若干參數(shù)組成，對于一個事件能有若干的監(jiān)聽器，當(dāng)事件觸發(fā)的時候，監(jiān)聽器會被依次調(diào)用，事件參數(shù)作為回調(diào)函數(shù)的參數(shù)進(jìn)行傳遞，需要注意的是，監(jiān)聽器會被依次調(diào)用

error是一個多帶帶列出來的事件，一般要為其綁定一個監(jiān)聽器，因為node如果拋出error，若沒有監(jiān)聽器執(zhí)行，將會直接退出執(zhí)行，并返回錯誤

處理TCP或者文件流的時候，需要用到二進(jìn)制的數(shù)據(jù)，定義了一個Buffer類，該類用于專門存放二進(jìn)制數(shù)據(jù)的緩沖區(qū)

const buf = Buffer.from("ming", "ascii");    // 聲明一個只讀的變量

console.log(buf.toString("hex"));

console.log(buf.toString("utf-8"));

PS C:UsersmingmDesktop	est> node main.js
6d696e67
ming
PS C:UsersmingmDesktop	est>

PS C:UsersmingmDesktop	est> node main.js
23456789:;<=>?@ABCDEFGHIJK
23456789:;<=>?@ABCDEFGHIJK
PS C:UsersmingmDesktop	est>

buf = Buffer.alloc(26);
for(var i = 0; i < 26; i++){
    buf[i] = 50 + i;
};
console.log(buf.toString("ascii"));
console.log(buf.toString("utf8"));

PS C:UsersmingmDesktop	est> node main.js
{"type":"Buffer","data":[1,2,3,4,5]}
PS C:UsersmingmDesktop	est>

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
const json = JSON.stringify(buf);

console.log(json);

> JSON.parse("{"1": 3, "2": [4, 5, 6]}", function (k, v) {
...     console.log(k); // 輸出當(dāng)前的屬性名，從而得知遍歷順序是從內(nèi)向外的，
...     console.log("----------");              // 最后一個屬性名會是個空字符串。
...     console.log(v);
... });
1
----------
3
0
----------
4
1
----------
5
2
----------
6
2
----------
[ <3 empty items> ]

----------
{}
undefined
>

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
const json = JSON.stringify(buf);

console.log(json);


const copy = JSON.parse(    // 調(diào)用JSON.parse函數(shù)，將字符串轉(zhuǎn)換為對象，后一個參數(shù)為轉(zhuǎn)換的函數(shù)，轉(zhuǎn)換的時候?qū){(diào)用
        json,
        (key, value) => {    // 此為es6的語法，一個匿名函數(shù)
            console.log(value, "----", !!value, "----", value.type, "-----", value.data);
            return value && value.type === "Buffer" ? Buffer.from(value.data): value;    // 只留下最后一個進(jìn)行轉(zhuǎn)換，前面的轉(zhuǎn)換全部被覆蓋
        }
    )

// 輸出: 
console.log(copy);

PS C:UsersmingmDesktop	est> node main.js
{"type":"Buffer","data":[1,2,3,4,5]}
Buffer ---- true ---- undefined ----- undefined
1 "----" true "----" undefined "-----" undefined
2 "----" true "----" undefined "-----" undefined
3 "----" true "----" undefined "-----" undefined
4 "----" true "----" undefined "-----" undefined
5 "----" true "----" undefined "-----" undefined
[ 1, 2, 3, 4, 5 ] "----" true "----" undefined "-----" undefined
{ type: "Buffer", data: [ 1, 2, 3, 4, 5 ] } "----" true "----" "Buffer" "-----" [ 1, 2, 3, 4, 5 ]

PS C:UsersmingmDesktop	est>

var buffer1 = Buffer.from("222");
var buffer2 = Buffer.from("3333");
var buffer3 = Buffer.concat([buffer1, buffer2]);
console.log(buffer3.toString());

流為一個抽象的接口，

PS C:UsersmingmDesktop	est> node main.js
end！
33333333333333333333333333
PS C:UsersmingmDesktop	est>

var fs = require("fs");
var data = "";

// 創(chuàng)建可讀流
var readerStream = fs.createReadStream("input.txt");

// 設(shè)置編碼為 utf8
readerStream.setEncoding("UTF8");

// 處理流事件 data事件
readerStream.on("data", (chunk) => {data += chunk;});    // 遇到數(shù)據(jù)讀取，將讀取到的內(nèi)容賦值給data

// 處理流事件 end事件
readerStream.on("end", () => {console.log(data);});    // 將讀取到的保存到內(nèi)存中的數(shù)據(jù)打印出來

// 處理事件 error
readerStream.on("error", (err) => {console.log(err.stack);});    // 處理error事件，將錯誤輸出，避免程序的運行中斷

console.log("end！");

PS C:UsersmingmDesktop	est> node main.js
程序執(zhí)行完畢
寫入完成
PS C:UsersmingmDesktop	est>

var fs = require("fs");
var data = "這是一段示例";

// 創(chuàng)建一個可以寫入的流，寫入到文件output.txt中
var writerStream = fs.createWriteStream("output.txt");

// 使用 utf8 編碼寫入數(shù)據(jù)
writerStream.write(data, "UTF8");

// 標(biāo)記文件末尾
writerStream.end();

// 處理流事件 --> data, end, add error
writerStream.on("finish", () => {console.log("寫入完成");});

writerStream.on("error", () => {console.log(err.stack);});

console.log("程序執(zhí)行完畢");

把兩個文件之間建立流，讓一個文件的數(shù)據(jù)流向另外一個文件

PS C:UsersmingmDesktop	est> node main.js
程序執(zhí)行完畢
PS C:UsersmingmDesktop	est>

var fs = require("fs");

// 創(chuàng)建一個可讀流
var readerStream = fs.createReadStream("input.txt");

// 創(chuàng)建一個可寫流
var writerStream = fs.createWriteStream("output.txt");

// 管道讀寫操作
// 將兩個流通過管道連接起來
readerStream.pipe(writerStream);

console.log("程序執(zhí)行完畢");

這里需要注意的是，由于流的影響，導(dǎo)致在操作的時候，會覆蓋掉要寫入文件的內(nèi)容，原先的內(nèi)容會被覆蓋

PS C:UsersmingmDesktop	est> node main.js
文件壓縮完成
PS C:UsersmingmDesktop	est>

var fs = require("fs");
var zlib = require("zlib");

// 壓縮 input.txt文件為 input.txt.gz
fs.createReadStream("input.txt")    // 創(chuàng)建一個可讀流
    .pipe(zlib.createGzip())        // 將創(chuàng)建的可寫流和壓縮流連接
    .pipe(fs.createWriteStream("input.txt.gz"));    // 在創(chuàng)建可寫流，將三個流連接到一起

console.log("文件壓縮完成");

var fs = require("fs");
var read = fs.createReadStream("output.txt");
var write = fs.createWriteStream("input.txt");
read.pipe(write);
console.log("執(zhí)行完畢");