node的文件系统和数据流

回顾：

1、 fs.open(path，type，callback)

fs.open(‘input.txt’，’r+’，function(err,fd){ //fd是被打开文件的描述符

​ if(err){

​ return console.log(err)

​ }

})

2、Buffer对象：JavaScript处理二进制数据的能力很弱，node创建内置的Buffer对象来处理二进制数据。使用时不需要require导入

​ （1）Buffer.alloc(number)：创建给定单元个数的缓冲区。返回的是Buffer对象

​ （2）Buffer.from(string/[])：创建一个缓冲区，缓冲区中的数据由参数给定。

注意：在JavaScript中一个汉字占3个字节

3、fs模块中读取文件的函数

​ （1）readFile(filename，callback) ：异步的读

​ （2）readFileSync(filenam，callback)：同步的读

4、向文本文件中写入数据

​ writeFile(filename，data，callback)：覆盖式写入。异步的写

一、node的文件系统

1、二进制文件的读写：按字节读写（一个字节是8个二进制位）

​ （1）读二进制文件

​ fs.read(fd, buffer, offset, length, position, callback)

​ fd：文件描述符。由open函数返回

​ buffer：被写入数据的缓冲区。缓存从文件中读取的数据

​ offset：偏移量。描述的是写入缓冲区的位置

​ length：表示从文件中读取的字节数

​ position：表示从文件中读取数据的位置。若为null，表示从当前位置开始读

​ callback：回调函数。

//导入fs模块
const fs = require('fs')
//创建Buffer缓冲区
let buf = Buffer.alloc(1024) //缓存区共有1024个单元(字节)，每个单元存储的数据只能是0~255之间的整数
//打开文件
fs.open('../input.txt','r+',function(err,fd){  //fd是被打开文件的描述符
    if(err){
        return console.log(err)
    }
    fs.read(fd,buf,0,buf.length,0,function(err,bytes){ //bytes表示从文件中实际读取的字节数
        if(err){
            return console.log(err)
        }
        if(bytes > 0){ //表示从文件中已经读取到了数据
            console.log(buf.slice(0,bytes).toString())//将缓冲区中有数据的转换成字符串输出
        }
    })
})

（2）关闭文件：

​ close(fd，callback)

​ fd：文件描述符。由open函数返回

​ callback：回调函数。

2、 写二进制文件：向二进制文件中写入数据

​ fs.write(fd, buffer[, offset[, length[, position]]], callback) //将buffer中的数据写入fd所描述的文件中

​ 写入时若文件不存在则新建文件，若文件存在则覆盖原文件

3、向文件中追加数据

​ （1）异步的追加

​ fs.appendFile(path, data[, options], callback)

​ path：文件全名（路径和文件名）

​ data：要追加的数据

​ callback：回调函数

​ （2）同步的追加

​ fs.appendFileSync(path, data[, options], callback)

4、目录操作

​ （1）创建目录

​ fs.mkdir(path[, model], callback)

​ path：目录名（包含有路径）

​ model：可选的，表示目录的权限

​ callback：回调函数

​ （2）读取目录

​ fs.readdir(path, callback)

​ path：目录名（包含有路径）

​ callback：回调函数。两个参数（err, files），files中放的是读取目录中的文件和子目录信息。实质是集合

fs.readdir('c:\\',(err,files)=>{ //files中存放的E盘下的所有文件和文件夹
      if(err){
        throw err
      }
      files.forEach((file)=>{ //遍历files
        console.log(file)
         fs.stat('c:\\'+file,function(error,stats){
            if(error){
                return console.log(error)
            }
            if(stats.isFile()){  //判断当前的file是否是文件，若是文件就输出
                console.log(file)
            }
         })
      })
   })

​ （3）删除目录

​ fs.rmdir(path, callback)

​ path：目录名（包含有路径）

​ callback：回调函数。

fs.rmdir(‘woniu’,(err)=>{
if(err){
throw err
}
console.log(“删除成功!”)
})

二、node的数据流（Stream接口）

1、系统处理缓存的方式

​ （1）传统方式：先将数据全部读入缓存(内存)，然后再进行处理。

​ 优点：符合人的思维方式，流程比较流畅

​ 缺点：对于数据量很大的文件，处理效率低下

​ （2）’数据流’方式：读一块，处理一块。将待处理的数据分割成一块一块的，像‘流水’一样，每当有新的数据块进入内存时会触发一

​ 个事件，程序就从内存中获取新数据进行处理

​ 优点：程序处理数据的效率高

2、node中的数据流

​ （1）Readable —- 用于读操作的数据流

​ （2）Writeable —- 用于在写操作的数据流。

​ （3）Duplex —- 用于读取和写入操作

​ （4）Transform —- 输出基于输入的地方进行计算的一种双相流

3、node中使用数据流时触发的事件：每个数据流都有一个EventEmitter实例，该实例的作用是触发事件。

​ （1）data —- 当流中有数据可读取时触发。data是事件名

​ （2）end —- 当流中没有数据时触发。end是事件名

​ （3）error —- 当有任何错误触发。error是事件名

​ （4）finish —- 当所有数据已刷新到底层系统时触发。finish是事件名

4、从流中读取数据：fs模块的createReadStream方法的作用是创建一个读取数据的数据流

​ fs.createReadStream(文件全名)

const fs = require('fs')
let str = ''  //用来存储从流中读取的数据
//1.创建数据流：读文件的数据流
let readStream = fs.createReadStream('../input.txt')
//2.设置数据流的字符集
readStream.setEncoding('utf8')
//3.注册data事件：若该事件被触发，说明数据流中有数据了，数据会读到回调函数的val中，再将val保存到str中
readStream.on('data',function(val){
    str += val
})
//4.注册end事件：若该事件被触发，说明流中没有数据可读，表示读取结束
readStream.on('end',function(){
    console.log(str)
})
//5.注册error事件：若该事件被触发，说明读取数据出现了错误,输出错误信息栈中的信息
readStream.on('error',function(err){
    console.log(err.stack)
})

5、向流中写入数据：fs模块的createWriteStream方法，就可以创建一个写数据的数据流

​ fs.createWriteStream(文件名)

const fs = require('fs')
let str = '蜗牛学苑'  //将该字符串写入到文件中
//1. 创建写入流
let writeStream = fs.createWriteStream('./output.txt')
//2.设置写入流的字符集：先写入缓存
writeStream.write(str,'utf8')
//3.写入结束
writeStream.end()
//4.触发finish事件
writeStream.on('finish',function(){
    console.log('写入完成')
})
//5.触发error
writeStream.on('error',(err)=>{
    console.log(err.stack)
})
console.log('主程序结束!')

6、管道流：用于从一个流中获取数据，并通过该流输出到另一个流。

const fs = require('fs')
//1.创建一个输入流：用于读取数据
let readStream = fs.createReadStream('../input.txt')
//2.创建一个输出流：用于写数据
let writeStream = fs.createWriteStream('./output.txt')
//3.通过输入流调用方法：将数据送入输出流中
readStream.pipe(writeStream)
console.log('主程序结束!')

7、链式流：链式是一个机制，一个流的输出连接到另一个流，并创建一个链多流操作

​ （1）压缩文件：

const fs = require('fs')
const zlib = require('zlib') //压缩与解压缩的模块
fs.createReadStream('../input.txt')
.pipe(zlib.createGzip())  //zlib.createGzip()：创建压缩对象
.pipe(fs.createWriteStream('./input.zip'))  //生成一个.zip的压缩文件

​ （2）解压缩

const fs = require('fs')
const zlib = require('zlib')
fs.createReadStream('./input.zip')
 .pipe(zlib.createGunzip())  //zlib.createGunzip():创建一个解压缩的对象。通过管道连接到解压缩对象
 .pipe(fs.createWriteStream('../gun.txt')) //通过管道连接输出流