在学习fs中我们就可以操作我们的读写相关的一些文件
我们读写相关文件的时候，我们可以通过readFile(读)和writeFile(写)里面的某些数据
但是有一天我们读的数据很大的时候，万一我的内存并不能够直接把整个数据全部读取下来
所以我们要读取比较大的数据的时候，我们不可能一次性的把所有的数据都读取出来，这样效率太低了
我们希望的是读一点是一点，所以我们在读写比较大的数据的时候，我们可能需要用到流的这样子的一个接口

Node.js Stream(流)

Stream是一个抽象接口,Node中有很多对象实现了这个接口。例如:对http服务器发起请求的request,对象就是一个Stream,还有stdout(标准输出)

node.js Stream有四种流类型:

  • Readable:可读操作
  • Writeable:可写操作
  • Dupiex:可读可写操作
  • Transform:操作被写入数据,然后读出结果
    所有的Stream对象都是EventEmitter的实例。常用的事件有:
  • data:当有数据可读时触发
  • end:没有更多的数据可读时触发
  • error:在接收和写入过程中发生错误时触发
  • finish:所有数据已被写入过程到底层系统时触发

写入流

创建main.js

  1. let fs = require('fs')
  3. //写入流
  4. let data = 'www.sxt.com'
  6. //1.创建写入流
  7. //  --语法:fs.createWriteStream(文件路径,[可选配置操作])
  8. //创建一个可以写入状态的流,写入到文件output.txt中
  9. let wirterStream = fs.createWriteStream('output.txt')
  11. //使用utf-8编码写入数据
  12. wirterStream.write(data,'utf-8')
  14. //标记文件末尾
  15. wirterStream.end();
  17. //处理流事件 --> data,end,and error
  18. wirterStream.on('finish',function(){
  19.     console.log('写入完成')
  20. })
  22. wirterStream.on('error',function(err){
  23.     console.log(err.stack)
  24. })
  26. console.log('程序执行完毕')

执行:

  1. node main.js

fs.createWriteStream
简写形式:

  1. let fs = require('fs')
  2. let ws = fs.createWriteStream('hello.txt',{flags:'w',encoding:'utf-8'})
  3. console.log(ws)

结果:

  1. WriteStream {
  2.   fd: null,
  3.   path: 'hello.txt',
  4.   flags: 'w',
  5.   mode: 438,
  6.   ....
  7. }

可以进行事件的监听:

  1. //监听文件打开事件
  2. wx.on('open',function(){
  3.     console.log('文件打开')
  4. })
  6. //监听准备事件
  7. wx.on('ready',function(){
  8.     console.log('文件写入已准备状态')
  9. })
  11. //写入数据
  12. wx.write("hello world",function(err){
  13.     if(err){
  14.         console.log(err)
  15.     }else{
  16.         console.log("内容流入完成")
  17.     }
  18. })
  19. //end:表示写入完成
  20. wx.end(function(){
  21.     console.log('文件写入关闭')
  22. })
  24. //监听文件关闭事件
  25. wx.on('close',function(){
  26.     console.log('文件写入完成关闭')
  27. })

从流中读取数据

读和写很类似
创建input.txt文件:

  1. www.sxt.com

创建main.js文件:

  1. var fs = require('fs')

创建一个可读的流:fs.createReadStream

  1. let readerStream = fs.createReadStream('input.txt')

设置编码为utf-8:

  1. readerStream.setEncoding('utf-8')

输出readStream

  1. //1.首先导入fs模块
  2. let fs = require('fs')
  4. //2.创建读取流,语法:fs.createReadStream(路径,[可选配置项])
  5. let rs = fs.createReadStream('input.txt',{flags:'r',encoding:'utf-8'})
  7. console.log(rs)

结果:

  1. ReadStream {
  2.   fd: null,
  3.   path: 'input.txt',
  4.   flags: 'r',
  5.   mode: 438,
  6.   start: undefined,
  7.   end: Infinity,
  8.   pos: undefined,
  9.   bytesRead: 0,
  10.   ....
  11. }

基础的打开关闭

  1. rs.on('open',function(){
  2.     console.log('读取的文件已打开')
  3. })
  5. rs.on('close',function(){
  6.     console.log('读取流结束')
  7. })

在这里我们还有专门的一个事件去处理读取:我发一段一段发给你
一点一点小心翼翼的去读取;也是采用了事件去一点一点的去提取

我们的一点一点去提取的监听事件叫data

data可以用来监听我们数据流的:

  1. //每一批数据流入的完成
  2. rs.on('data',function(chunk){
  3.     console.log('单批数据流入')
  4.     console.log(chunk)
  5. })

小文件看不出大小,但是大文件就可以看出效果

  1. let rs = fs.createReadStream('文件路径',{flags:'r'})
  3. // console.log(rs)
  5. rs.on('open',function(){
  6.     console.log('读取的文件已打开')
  7. })
  9. //每一批数据流入的完成
  10. rs.on('data',function(chunk){
  11.     console.log('单批数据流入:',chunk.length)
  12.     console.log(chunk)
  13. })
  15. rs.on('close',function(){
  16.     console.log('读取流结束')
  17. })

输入流配合写入流:

  1. //1.首先导入fs模块
  2. let fs = require('fs')
  4. //2.创建读取流,语法:fs.createReadStream(路径,[可选配置项])
  5. let rs = fs.createReadStream('input.txt',{flags:'r',encoding:'utf-8'})
  7. let ws = fs.createWriteStream('a.txt',{flags:'w',encoding:'utf-8'})//写入;[可选配置项]跟读取一致
  9. // console.log(rs)
  11. rs.on('open',function(){
  12.     console.log('读取的文件已打开')
  13. })
  15. //每一批数据流入的完成
  16. rs.on('data',function(chunk){
  17.     console.log('单批数据流入:',chunk.length)
  18.     console.log(chunk)
  19.     ws.write(chunk,()=>{console.log('单批输入流入完成')})//写入
  20. })
  22. rs.on('close',function(){
  23.     ws.end
  24.     console.log('读取流结束')
  25. })

这个我们可以封装起来

  1. let fs = require('fs')
  3. function myFsWriteStreamTXT(FileName,neiru){
  4.     let ws = fs.createWriteStream(FileName,{flags:'w',encoding: 'utf-8'})
  5.     ws.on('open',function(){
  6.         console.log('写入开始')
  7.     })
  8.     ws.write(neiru,()=>{console.log('单批输入流入完成')})
  10.     ws.on('close',function(){
  11.         ws.end()
  12.     })
  13. }
  14. function myFsReadStreamTXT(FileName){
  15.     let rs = fs.createReadStream(FileName,{flags:'r',encoding:'utf-8'})
  17.     rs.on('open',function(){
  18.         console.log('读取的文件已打开')
  19.     })
  20.     rs.on('data',function(data){
  21.         console.log('单批数据流入:',data.length)
  22.         console.log(data)
  23.     })
  24.     rs.on('close',function(){
  25.         console.log('读取流结束')
  26.     })
  27. }
  28. function myFsReadEndWriteStreamTXT(FileName){
  29.     let rs = fs.createReadStream(FileName,{flags:'r',encoding:'utf-8'})
  31.     rs.on('open',function(){
  32.         console.log('读取的文件已打开')
  33.     })
  34.     rs.on('data',function(data){
  35.         console.log('单批数据流入:',data.length)
  36.         console.log(data)
  37.         myFsWriteStreamTXT(FileName,data)
  38.     })
  39.     rs.on('close',function(){
  40.         console.log('读取流结束')
  41.     })
  42. }
  44. module.exports = {myFsWriteStreamTXT,myFsReadStreamTXT,myFsReadEndWriteStreamTXT}

这样还是挺累的,所以它还有一个接口

这个接口可以让你们不用写这么多代码:用管道

管道流(学会输入输出流的原理后，这个就是关键(封装了以上的输入输出流提供给我们))

管道提供了一个输出流到输入流的机制。通过我们用于从一个流中获取数据并将数据传递到另一个流中。
具体如下:

  1. let fs = require('fs')
  3. let rs = fs.createReadStream('input.txt')
  4. let ws = fs.createWriteStream('b.txt')
  6. //管道读写操作
  7. //读取input.txt文件内容,并写入到output中
  8. rs.pipe(ws)

这个管道就是我们刚刚的输入输出流封装而成的一个管道