帶你一塊兒擼一遍 nodejs 經常使用核心模塊（三）

壓縮模塊

zlib 能夠用來實現對 HTTP 中定義的 gzip 和 deflate 內容編碼機制的支持。 HTTP 的 Accept-Encoding 頭字段用來標記客戶端接受的壓縮編碼。 使用 zlib 編碼成本會很高, 結果應該被緩存。（下面的演示代碼只演示壓縮）

//compresss方法實現壓縮 
compress(req, res, statObj, realPat) {    //實現壓縮功能
    let encoding = req.headers['accept-encoding'];   //瀏覽器請求頭會自動帶上accept-encoding 告訴 服務器支持哪幾種壓縮格式
    if (encoding) {
        if (encoding.match(/\bgzip\b/)) {
            res.setHeader('content-encoding','gzip')
            return zlib.createGzip()    //返回壓縮流  let zip = compress(req, res, statObj, realPat); 
            //經過fs.createReadStream(realPath).pipe(zip).pipe(res) 返回給客戶端
        } else if (encoding.match(/\bdeflate\b/)) {
            res.setHeader('content-encoding', 'deflate')
            return zlib.createDeflate();  //返回壓縮流  let zip = compress(req, res, statObj, realPat); 
            //經過fs.createReadStream(realPath).pipe(zip).pipe(res) 返回給客戶端
        } else {
            return false
        }
    } else {
        return false
    }
}
複製代碼

加密和摘要算法

crypto 模塊提供了加密功能，包含對 OpenSSL 的哈希、HMAC、加密、解密、簽名、以及驗證功能的一整套封裝.

let crypto = require('crypto');
console.log(crypto.getHashes());
[ 'DSA',
  'DSA-SHA',
  'DSA-SHA1',
  'DSA-SHA1-old',
  'RSA-MD4',
  'RSA-MD5',
  'RSA-MDC2',
  'RSA-RIPEMD160',
  'RSA-SHA',
  'RSA-SHA1',
  'RSA-SHA1-2',
  'RSA-SHA224',
  'RSA-SHA256',
  'RSA-SHA384',
  'RSA-SHA512',
  'dsaEncryption',
  'dsaWithSHA',
  'dsaWithSHA1',
  'dss1',
  'ecdsa-with-SHA1',
  'md4',
  'md4WithRSAEncryption',
  'md5',
  'md5WithRSAEncryption',
  'mdc2',
  'mdc2WithRSA',
  'ripemd',
  'ripemd160',
  'ripemd160WithRSA',
  'rmd160',
  'sha',
  'sha1',
  'sha1WithRSAEncryption',
  'sha224',
  'sha224WithRSAEncryption',
  'sha256',
  'sha256WithRSAEncryption',
  'sha384',
  'sha384WithRSAEncryption',
  'sha512',
  'sha512WithRSAEncryption',
  'shaWithRSAEncryption',
  'ssl2-md5',
  'ssl3-md5',
  'ssl3-sha1',
  'whirlpool' ]
複製代碼

//幾種經常使用的
let crypto = require('crypto');

// console.log(crypto.getHashes());
// 摘要算法
let str = 'hello';
let r = crypto.createHash('md5').update(str).digest('hex');
console.log(r)

let crypto = require('crypto');
let r2 = crypto.createHash('md5').update('hello').digest('hex')
console.log(r2)
let r1 = crypto.createHash('md5').update('h').update('ell').update('o').digest('hex')
console.log(r1)

// 加鹽算法
let mac = crypto.createHmac('sha256', 'xl');  //用哈希算法，以一個密鑰和一個消息爲輸入，生成一個消息摘要做爲輸出
let r = mac.update('hello').digest('hex')
console.log(r)
複製代碼

process - 進程

進程（Process）是計算機中的程序關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操做系統結構的基礎。進程是線程的容器。程序是指令、數據及其組織形式的描述，進程是程序的實體。

process 對象是一個全局變量，它提供當前 Node.js 進程的有關信息，以及控制當前 Node.js 進程。

1. 'exit' 事件

兩種狀況下 'exit' 事件會被觸發：

• 顯式調用 process.exit() 方法，使得 Node.js 進程即將結束；
• Node.js 事件循環數組中再也不有額外的工做，使得 Node.js 進程即將結束。

2. 'message' 事件

消息經過 childprocess.send() 發送），會觸發 'message' 事件。具體用法演示下面額外管道 ipc模式有. 3. 'kill' 事件 -- 注意只有父進程才能夠kill子進程

process.kill(pid[, signal]) //pid 進程id 能夠經過process.pid獲取

child_process - 子進程

父子進程之間創建管道有三種模式 pipe/0,1,2/ignore，

1. 默認狀況下，子進程的 stdin、 stdout 和 stderr 會重定向到 ChildProcess 對象上相應的 subprocess.stdin、 subprocess.stdout 和 subprocess.stderr 流
2. 0,1,2是共享輸入輸出（繼承父進程輸入輸出）的再也不演示
3. ignore

額外的 fd 能夠被指定來建立父進程和子進程之間的額外管道

1.額外管道pipe模式

//pipe模式

//主進程
let {spawn} = require('child_process');
let path = require('path');
// 啓動一個子進程
let child = spawn('node', ['sub_process1.js', '--port', '3000'], {
    cwd: path.join(__dirname, 'test'),            //sub_prpcesss1.js文件路徑
    stdio:[0,1,2,'pipe']          //默認pipe  (stdin、stdout 和 stderr  --> 0、1 和 2  ==>共享標準輸入，標準輸出，錯誤輸出)
})
child.stdout.on('data', function (data) {  //接收子進程的數據
    console.log(data.toString())
})

//被啓動的子進程
console.log(process.argv)  //子進程輸出數據
process.stdout.write('123')   //
---------------------------------------------------
//最終在控制檯打出的結果
[ 'C:\\Program Files\\nodejs\\node.exe',
  'c:\\Users\\Administrator\\Desktop\\growth_plan\\Everest4\\22.process\\test\\sub_process1.js',
  '--port',
  '3000' ]
複製代碼

2. 額外管道 ipc模式

// on  send

//主進程
let {spawn} = require('child_process');
let path = require('path');

let child = spawn('node', ['03.ipc.js',],{
    cwd:path.join(__dirname, 'test'),
    stdio:[0,1,2,'ipc']  
})
child.on('message', function(data){
    console.log(data);
    child.send('world');
    // process.kill(child.pid)   //主進程能夠強制殺死子進程
})

// 子進程 03.ipc.js
process.send('hello');

process.on('message',function(data){
    console.error(data);
    process.exit();   //執行完退出進程
})
複製代碼

另外經常使用的fork其實就是衍生一個新的 Node.js 進程，並經過創建 IPC 通信通道來調用指定的模塊，該通道容許父進程與子進程之間相互發送信息。

//主進程
let {fork} = require('child_process');
let path = require('path');
let child = fork('04.fork.js',['a','b'],{
    cwd:path.join(__dirname,'test'),
    silent:false                           // 若是爲 true，則子進程中的 stdin、 stdout 和 stderr 會被導流到父進程中，不然它們會繼承自父進程。
})

child.send('hello')
child.on('message', function(data) {
    console.log(data)
})
//子進程 04.fork.js
process.send('end')
process.on('message', function(data) {
    console.log(data)
    process.exit()
})
複製代碼

集羣

爲了提升服務器的利用率，能不能多核的來處理呢？因而就有了cluster模塊。 cluster模塊能夠輕鬆實現運行在同一機器不一樣進程上的TCP或HTTP服務器集羣。它們仍使用相同的底層套接字，從而在相同的IP地址和端口組合上處理請求。

進程並非開的越多越好，通常是服務器有幾核通常開幾個進程；

let cluster = require('cluster');
let http = require('http');

let len = require('os').cpus().length;   //獲取cpu的核數
if (cluster.isMaster) {//主進程 
    for(let i = 0; i<len; i++) {     //有幾核就開幾個子進程   
        cluster.fork()     
    }
} else {
    http.createServer(function(req, res) {
        res.end('child'+process.pid)
    }).listen(3000)
}
複製代碼

//主進程
let os = require('os');

let {fork} = require('child_process');
let path = require('path');
let http = require('http');

let server = http.createServer(function(req, res) {
    res.end('xxx');
})
server.listen(3000)    //開了一個3000端口
for(let i = 0; i<os.cpus().length;i++){
    let child = fork('1.server.js',{
        cwd: path.join(__dirname),
        silent:false
    });

    child.send('server', server)    //公用服務
}
//子進程 1.server.js
let http = require('http');
process.on('message',function(data,server){
    http.createServer(function(req,res){
        res.end('child'+process.pid)
    }).listen(server); // 子進程公用這個服務
});
複製代碼

以上就是nodejs的經常使用核心模塊的一部分，由於涉及的內容比較多並無深刻進去，特別是加密和摘要算法這一塊，我也僅僅是會用，其實每一個部分均可以展開裏面有不少知識，不少深刻的知識我本人也不是很瞭解，但願上面的一些核心內容可以幫助到你，固然有不少不足之處但願朋友們提出指正。也但願和各位朋友一塊兒學習分享！

相關內容：

1. nodejs經常使用核心模塊(一)
2. nodejs經常使用核心模塊(二)

後記:

nodejs經常使用核心模塊到這裏就結束了，可能有不少零零散散的一些知識點沒有提到，但願你們看完這一系列的文章有一些收穫，同時有不足之處和經常使用可是沒有提到的知識點但願朋友們提出指正，互相交流，共同進步！