Nodejs中流的操作,实现简单的pipe

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')

转载于:https://www.cnblogs.com/CZforever/p/10505687.html

你可能感兴趣的:(javascript,ViewUI)