node的文件系统和数据流

最新推荐文章于 2023-03-04 04:55:09 发布

须臾不敢忘

最新推荐文章于 2023-03-04 04:55:09 发布

阅读量246

点赞数

文章标签： javascript

本文链接：https://blog.csdn.net/m0_74331160/article/details/127927609

版权

一、node的文件系统

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

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

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

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

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

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

一、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')) //通过管道连接输出流