轉換 想要 readfile 配置 事件 一秒 再次 包括 function

fs與流都可以處理文件，為什麽還要用流：

　　fs模塊處理文件的缺點：將文件的數據全讀到內存中，在把數據寫到文件內，會大量占用內存

流：

流（stream）是 Node.js 中處理流式數據的抽象接口，是一組有序的，有起點和終點的字節數據傳輸手段。可以實現將數據從一個地方流動到另一個地方，其邊讀取邊寫入的特點有別於fs模塊的文件處理，並且可以做到控制讀取文件和寫入文件的速度，從而減少內存的占用 nodeJS中提供了許多種流的對象，像用http模塊創建的服務器的回調內，req就是一個可讀流，res就是可寫流 流的特點： 　　1、邊讀 邊寫，是邊讀邊寫的，讀取一段文件，就將它寫入 　　2、流是基於事件的，所有的流對象都用 on綁定事件，並觸發

Node.js 中有四種基本的流類型：

• Writable - 可寫入數據的流（例如 fs.createWriteStream()）。
• Readable - 可讀取數據的流（例如 fs.createReadStream()）。
• Duplex - 可讀又可寫的流（例如 net.Socket）。
• Transform - 在讀寫過程中可以修改或轉換數據的 Duplex 流（例如 zlib.createDeflate()）。

可讀流：

let fs = require(‘fs‘)
//參數1：要讀取的文件
 

//參數2：配置項，有highWaterMark  每次能讀取多少，默認是64k，一次讀取64k 不需要更改
let rs = fs.createReadStream(‘1.txt‘, {     // 返回了一個可讀流的實例
    flags: ‘r‘        //對文件進行何種操作
        encoding: ‘utf-8‘        //設置之後，讀取的是字符串，不然默認為buffer
        start:3                    //從索引3開始讀
        end:7                    // 讀到索引為7的  包括結束
        highWaterMark: 1
})       

 
// 默認是不會把讀取的文件給你 需要監聽事件,數據到來的事件  rs.emit(‘data‘,數據);
// 所以把那個綁定這個事件
fs.on(‘data‘,function(chunk){
    console,log(chunk)
})
// 默認這個data事件不停的觸發，直到文件中的數據全部讀完
rs.on(‘end‘, function () {
    
})

如果每次讀取多少需要自己設置highWaterMark ，讀取文件的時候為了不亂碼，需要用到buffer拼接轉化

let rs = fs,createReadStream(‘1.txt‘, {highWaterMark: 1})
let arr = []
rs.on(‘data‘,function(chunk){
    arr.push(chunk)            //讀取文件時，是buffer類型，將每次讀取的buffer拼到一個數組內
    
})
// 當文件全部讀完，觸發end
res.end(‘end‘,function(){
    let filesData = Buffer.concat(arr).toString()
})

//報錯是  觸發err        文件不存在，會觸發這個事件
rs.on(‘err‘, function(err){

})

如果想要控制讀取的速度，可以用rs.pause() 暫停data事件的觸發， rs.resume() 恢復data事件的觸發

let arr = []
rs.on(‘data‘,function(chunk){
    arr.push(chunk)
    rs.pause()    //暫停
    setTimeout(()=>{
        rs.resume       //一秒恢復一次  data事件的觸發，直到數據讀完
    },1000)
})

rs.on(‘end‘, ()=>{
    console.log(Buffer.concat(arr).toString())
})

可寫流：

1、當往可寫流裏寫數據的時候，不會立刻寫入文件，先寫入緩存區，緩存區的大小就是highWaterMark，默認為16k 等緩存區滿了之後，再次真正的寫入文件裏 2、通過判斷ws.write的返回值判斷緩存區是否已經滿了。為true是，還沒滿，有空間，可以繼續寫，為false時，表示滿了 3、按理說如果返回false,就不能再往裏寫了，但是如果寫了，不會丟失，會先緩存在內存中，等緩沖區寫完清空之後，在從內存中讀取寫入。 所以一般在讀取文件寫入的時候。當緩存區滿了，一般會暫停可讀流的讀取 data事件，等寫完之後再次出發可讀流的data讀取文件，所以不會占用太多的內存

const fs = require(‘fs‘)
//第一個參數，寫入的文件位置  名稱
// 第二參數，配置項
let ws = fs.createWriteStream(‘./a.txt‘, {
      flags:‘w‘
      highWaterMark:2 
})
var flag = ws.write(‘1‘, function(){})        //flag為true
//write   寫的內容，必須是 字符串或者buffer，
// 會返回一個布爾值，提示是否還有空間寫入， 與highWaterMark對應，例如為寫入1時，第一次寫 返回一個true，表示還有空間寫入
//write是異步的 有回調函數，但是不常用
var flag = ws.write(‘2‘, function(){})       //flag為false
var flag = ws.write(‘3‘, function(){}) 
// 當數據寫入文件後，又有空間繼續寫入時，觸發drain事件
ws.on(‘drain‘,function(){
    
})
// 當所有文件寫完之後，觸發end，也可以在end時，在寫入最後的數據
ws.end(‘結束寫入‘)

利用可讀流可寫流，實現一個pipe,邊讀邊寫，控制讀取可寫入的速度： 讀取30b的文件，每次只能讀5b，每次只能寫入1b 1、可讀流第一次讀取5b 2、可寫流寫入讀取流讀取的數據，拿到5b開始寫，因為設置了highWaterMark為1，寫了1b之後，ws.write()就返回fasle。 表示沒有空間在寫入了，剩下的4b放到內存中，開始1b 1b的寫入 3、ws.write()返回false後，暫停可讀流 的 data事件，等待5b全部寫入 4、 5b寫完後，觸發ws.on(‘drain‘,function(){rs.resume()}), 恢復可讀流的 data事件，再次讀取了5b 5、直到文件讀完，寫完

const fs = require(‘fs‘)

function pipe(readFile,writeFileu){
    let rs = fs.createReadStream(readFile,{
        highWaterMark:5
    })
    let ws = fs.createWriteStream(writeFileu,{
        highWaterMark:1
    })
    rs.on(‘data‘,function(chunk){
        console.log(‘讀取‘)
        // 當ws.write() 返回false時，表示沒有空間繼續寫入了，暫停讀取
        if(ws.write(chunk) == false){
            rs.pause() // 暫停rs的data事件
        }
    })
    // 當觸發可寫流的drain，表示有空間繼續寫入了，繼續讀取文件
    ws.on(‘drain‘,function(){
        rs.resume() // 恢復rs的data事件        // 把當前讀入的內容都寫到文件中了，繼續調用讀寫
    })
    // 當讀取流觸發end方法，表示讀取完畢，這時關閉可寫流的寫入
    rs.on(‘end‘,function(){
        ws.end()
    })
}
pipe(‘1.txt‘,‘./2.txt‘)

Nodejs中流的操作，實現簡單的pipe