03node.js Stream(流)、模塊系統(tǒng)

01、Stream 是一個抽象接口，Node 中有很多對象實現(xiàn)了這個接口。例如，對http 服務器發(fā)起請求的request 對象就是一個 Stream，還有stdout（標準輸出）。
Node.js，Stream 有四種流類型：
Readable - 可讀操作。
Writable - 可寫操作。
Duplex - 可讀可寫操作.
Transform - 操作被寫入數(shù)據(jù)，然后讀出結果。
所有的 Stream 對象都是 EventEmitter 的實例。常用的事件有：
data - 當有數(shù)據(jù)可讀時觸發(fā)。
end - 沒有更多的數(shù)據(jù)可讀時觸發(fā)。
error - 在接收和寫入過程中發(fā)生錯誤時觸發(fā)。
finish - 所有數(shù)據(jù)已被寫入到底層系統(tǒng)時觸發(fā)
02、從流中讀取數(shù)據(jù)
input.txt

夜幕小草老師test

main.js

var fs = require("fs");
var data = '';
// 創(chuàng)建可讀流
var readerStream = fs.createReadStream('input.txt');
// 設置編碼為 utf8。
readerStream.setEncoding('UTF8');
// 處理流事件 --> data, end, and error
readerStream.on('data', function(chunk) {
   data += chunk;
});
readerStream.on('end',function(){
   console.log(data);
});
readerStream.on('error', function(err){
   console.log(err.stack);
});
console.log("程序執(zhí)行完畢");

執(zhí)行結果：

程序執(zhí)行完畢
夜幕小草老師test

03、寫入流
創(chuàng)建 main.js 文件, 代碼如下：

var fs = require("fs");
var data = '夜幕小草老師test;

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

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

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

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

writerStream.on('error', function(err){
   console.log(err.stack);
});

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

以上程序會將 data 變量的數(shù)據(jù)寫入到 output.txt 文件中。代碼執(zhí)行結果如下：

$ node main.js 
程序執(zhí)行完畢
寫入完成。

04、管道流
管道提供了一個輸出流到輸入流的機制。通常我們用于從一個流中獲取數(shù)據(jù)并將數(shù)據(jù)傳遞到另外一個流中

var fs = require("fs");

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

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

// 管道讀寫操作
// 讀取 input.txt 文件內(nèi)容，并將內(nèi)容寫入到 output.txt 文件中
readerStream.pipe(writerStream);

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

05、鏈式流
鏈式是通過連接輸出流到另外一個流并創(chuàng)建多個對個流操作鏈的機制。鏈式流一般用于管道操作。
接下來我們就是用管道和鏈式來壓縮和解壓文件。
創(chuàng)建 compress.js 文件, 代碼如下：

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

// 壓縮 input.txt 文件為 input.txt.gz
fs.createReadStream('input.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('input.txt.gz'));
  
console.log("文件壓縮完成。");

$ node compress.js 
文件壓縮完成。

執(zhí)行完以上操作后，我們可以看到當前目錄下生成了 input.txt 的壓縮文件 input.txt.gz。
接下來，讓我們來解壓該文件，創(chuàng)建 decompress.js 文件，代碼如下：

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

// 解壓 input.txt.gz 文件為 input.txt
fs.createReadStream('input.txt.gz')
  .pipe(zlib.createGunzip())
  .pipe(fs.createWriteStream('input.txt'));
  
console.log("文件解壓完成。");

結果

$ node decompress.js 
文件解壓完成。

-----------------------------------------------------模塊系統(tǒng)-----------------------------------------------------------------
為了讓Node.js的文件可以相互調(diào)用，Node.js提供了一個簡單的模塊系統(tǒng)。
模塊是Node.js 應用程序的基本組成部分，文件和模塊是一一對應的。換言之，一個 Node.js 文件就是一個模塊，這個文件可能是JavaScript 代碼、JSON 或者編譯過的C/C++ 擴展。
01、創(chuàng)建模塊
在 Node.js 中，創(chuàng)建一個模塊非常簡單，如下我們創(chuàng)建一個 'main.js' 文件，代碼如下:

var hello = require('./hello');
hello.world();

以上實例中，代碼 require('./hello') 引入了當前目錄下的hello.js文件（./ 為當前目錄，node.js默認后綴為js）。
Node.js 提供了exports 和 require 兩個對象，其中 exports 是模塊公開的接口，require 用于從外部獲取一個模塊的接口，即所獲取模塊的 exports 對象。
接下來我們就來創(chuàng)建hello.js文件，代碼如下：

exports.world = function() {
  console.log('Hello World');
}

在以上示例中，hello.js 通過 exports 對象把 world 作為模塊的訪問接口，在 main.js 中通過 require('./hello') 加載這個模塊，然后就可以直接訪 問 hello.js 中 exports 對象的成員函數(shù)了。
有時候我們只是想把一個對象封裝到模塊中，格式如下：

module.exports = function() {
  // ...
}

例如：

//hello.js 
function Hello() { 
    var name; 
    this.setName = function(thyName) { 
        name = thyName; 
    }; 
    this.sayHello = function() { 
        console.log('Hello ' + name); 
    }; 
}; 
module.exports = Hello;

這樣就可以獲取一個對象了

//main.js 
var Hello = require('./hello'); 
hello = new Hello(); 
hello.setName('BYVoid'); 
hello.sayHello();

模塊接口的唯一變化是使用 module.exports = Hello 代替了exports.world = function(){}。 在外部引用該模塊時，其接口對象就是要輸出的 Hello 對象本身，而不是原先的 exports。
02、服務端的模塊放在哪里
也許你已經(jīng)注意到，我們已經(jīng)在代碼中使用了模塊了。像這樣：

var http = require("http");

...

http.createServer(...);

Node.js中自帶了一個叫做"http"的模塊，我們在我們的代碼中請求它并把返回值賦給一個本地變量。
這把我們的本地變量變成了一個擁有所有 http 模塊所提供的公共方法的對象。
Node.js 的 require方法中的文件查找策略如下：
由于Node.js中存在4類模塊（原生模塊和3種文件模塊），盡管require方法極其簡單，但是內(nèi)部的加載卻是十分復雜的，其加載優(yōu)先級也各自不同。如下圖所示：

image.png

從文件模塊緩存中加載
盡管原生模塊與文件模塊的優(yōu)先級不同，但是都不會優(yōu)先于從文件模塊的緩存中加載已經(jīng)存在的模塊。
從原生模塊加載
原生模塊的優(yōu)先級僅次于文件模塊緩存的優(yōu)先級。require方法在解析文件名之后，優(yōu)先檢查模塊是否在原生模塊列表中。以http模塊為例，盡管在目錄下存在一個http/http.js/http.node/http.json文件，require("http")都不會從這些文件中加載，而是從原生模塊中加載。
原生模塊也有一個緩存區(qū)，同樣也是優(yōu)先從緩存區(qū)加載。如果緩存區(qū)沒有被加載過，則調(diào)用原生模塊的加載方式進行加載和執(zhí)行。
從文件加載
當文件模塊緩存中不存在，而且不是原生模塊的時候，Node.js會解析require方法傳入的參數(shù)，并從文件系統(tǒng)中加載實際的文件，加載過程中的包裝和編譯細節(jié)在前一節(jié)中已經(jīng)介紹過，這里我們將詳細描述查找文件模塊的過程，其中，也有一些細節(jié)值得知曉。
require方法接受以下幾種參數(shù)的傳遞：
http、fs、path等，原生模塊。
./mod或../mod，相對路徑的文件模塊。
/pathtomodule/mod，絕對路徑的文件模塊。
mod，非原生模塊的文件模塊。
在路徑 Y 下執(zhí)行 require(X) 語句執(zhí)行順序：

1. 如果 X 是內(nèi)置模塊
   a. 返回內(nèi)置模塊
   b. 停止執(zhí)行
2. 如果 X 以 '/' 開頭
   a. 設置 Y 為文件根路徑
3. 如果 X 以 './' 或 '/' or '../' 開頭
   a. LOAD_AS_FILE(Y + X)
   b. LOAD_AS_DIRECTORY(Y + X)
4. LOAD_NODE_MODULES(X, dirname(Y))
5. 拋出異常 "not found"

LOAD_AS_FILE(X)
1. 如果 X 是一個文件, 將 X 作為 JavaScript 文本載入并停止執(zhí)行。
2. 如果 X.js 是一個文件, 將 X.js 作為 JavaScript 文本載入并停止執(zhí)行。
3. 如果 X.json 是一個文件, 解析 X.json 為 JavaScript 對象并停止執(zhí)行。
4. 如果 X.node 是一個文件, 將 X.node 作為二進制插件載入并停止執(zhí)行。

LOAD_INDEX(X)
1. 如果 X/index.js 是一個文件,  將 X/index.js 作為 JavaScript 文本載入并停止執(zhí)行。
2. 如果 X/index.json 是一個文件, 解析 X/index.json 為 JavaScript 對象并停止執(zhí)行。
3. 如果 X/index.node 是一個文件,  將 X/index.node 作為二進制插件載入并停止執(zhí)行。

LOAD_AS_DIRECTORY(X)
1. 如果 X/package.json 是一個文件,
   a. 解析 X/package.json, 并查找 "main" 字段。
   b. let M = X + (json main 字段)
   c. LOAD_AS_FILE(M)
   d. LOAD_INDEX(M)
2. LOAD_INDEX(X)

LOAD_NODE_MODULES(X, START)
1. let DIRS=NODE_MODULES_PATHS(START)
2. for each DIR in DIRS:
   a. LOAD_AS_FILE(DIR/X)
   b. LOAD_AS_DIRECTORY(DIR/X)

NODE_MODULES_PATHS(START)
1. let PARTS = path split(START)
2. let I = count of PARTS - 1
3. let DIRS = []
4. while I >= 0,
   a. if PARTS[I] = "node_modules" CONTINUE
   b. DIR = path join(PARTS[0 .. I] + "node_modules")
   c. DIRS = DIRS + DIR
   d. let I = I - 1
5. return DIRS
最后編輯于 ：
?著作權歸作者所有,轉載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內(nèi)容

  • 1 Node.js模塊的實現(xiàn) 之前在網(wǎng)上查閱了許多介紹Node.js的文章,可惜對于Node.js的模塊機制大都著...
    zlx_2017閱讀 1,499評論 0贊 1
  • Node.js是目前非?；馃岬募夹g，但是它的誕生經(jīng)歷卻很奇特。 眾所周知，在Netscape設計出JavaScri...
    w_zhuan閱讀 3,732評論 2贊 41
  • 1 Node.js模塊的實現(xiàn)# 之前在網(wǎng)上查閱了許多介紹Node.js的文章,可惜對于Node.js的模塊機制大都...
    七寸知架構閱讀 2,159評論 1贊 50
  • topics： 1.The Node.js philosophy 2.The reactor pattern 3....
    宮若石閱讀 1,238評論 0贊 1
  • 模塊 Node 有簡單的模塊加載系統(tǒng)。在 Node 里，文件和模塊是一一對應的。下面例子里，foo.js加載同一個...
    保川閱讀 685評論 0贊 0

友情鏈接更多精彩內(nèi)容