Node的文件操作、文件系统、数据流

一、Node的文件操作

对文件的I/O操作使用的是fs(FileSystem)模块

I/O操作是输入/输出操作（I表示Input，O表示Output）

1. 使用方法：使用require导入

var fs = require('fs')

2. 读文件

​ （1）异步读文件 —- 非阻塞方式地读

​ readFile(filename，callback)

​ 参数filename：表示文件的全名

​ 参数callback：回调函数。读文件结束后执行该函数

//导入fs模块
var fs = require('fs')
//调用异步读文件的方法
 fs.readFile('input.txt',function(err,data){ //err存放的是读文件出现错误的信息，data存放的是读取的文件内容
     if(err){
         return console.error(err)
     }
     console.log('文件内容是：',data.toString())
 })
console.log('主程序结束。。。。。')
//主程序结束。。。。。
//文件内容是: 停车坐爱枫林晚

（2）同步读文件 —- 阻塞方式的读

​ readFileSync(filename,encoding)，函数的返回值就是读取的文件内容

​ 参数filename：表示文件的全名

​ 参数encoding：表示字符集

//导入fs模块
var fs = require('fs')
//同步读文件
let data = fs.readFileSync('input.txt')
console.log('文件内容是：',data.toString())
console.log('主程序结束......')
//文件内容是： 停车坐爱枫林晚
//主程序结束......

3. 打开文件

​ open(path, flags[, mode], callback)

​ path：要打开的文件路径

​ flags：打开文件的方式

​ r：以只读的方式打开文件。若文件不存在则报错

​ r+：打开文件后可以读、写。若文件不存在则报错

​ w：以写入的方式打开文件。若打开的文件不存在，则创建文件

​ w+：打开文件进行读和写。若打开的文件不存在，则创建文件

​ a：打开文件进行追加（在文件原有内容的末尾追加新内容）。若打开的文件不存在，则创建文件

//导入fs模块
var fs = require('fs')
fs.open('input1.txt','w',function(err,fd){//fd是被打开文件的描述符
    if(err){
    return console.log(err)
    }
    console.log('文件打开成功！',fd)
    })
    console.log('程序结束……')

4. 区分文件和目录

​ stat(path, callback)

​ path：路径名

​ callback：回调函数

//导入fs模块
var fs = require('fs')
fs.stat('node_modules',function(err,stats){ //err表示打开文件发生错误时的信息，stats表示文件的状态信息
    if(err){
        return  console.log(err)   
    }
   console.log('是目录？',stats.isDirectory())  //判断stats是否是目录，若是返回true，若不是返回false
   console.log('是文件？',stats.isFile()) //判断stats是否是文件，若是返回true，不是返回false
})

5. 写文件：向文件中写入内容

​ writeFile(filename, data[, options], callback) —- 异步写。若文件存在则覆盖

fs.writeFile('input.txt','天冷了',function(err){
    if(err){
        return console.log(er)
    }
    console.log('文件写入成功!')
})
console.log('主程序结束......')

二、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：回调函数。

// 导入fs模块
const fs = require('fs')
// 创建Buffer缓冲区
let buf1 = Buffer.from([0x41,0x42,0x43])
fs.open('input1.txt','w+',(err,fd)=>{
    if (err) {
        return console.log(err)
    }
    fs.write(fd,buf1,(err)=>{
        if (err) {
            console.log('写入失败！')
        }
    })
    fs.close(fd)
})

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

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

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

3. 向文件中追加数据

​ （1）异步的追加

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

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

​ data：要追加的数据

​ callback：回调函数

// 异步
const fs = require('fs')
fs.appendFile('input.txt','\n吃泡芙',(err)=>{
    if (err) {
        throw err  //throw作用是将err抛出
    }
    console.log('追加数据成功')
})

​ （2）同步的追加

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

4. 目录操作

​ （1）创建目录

a、异步创建

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

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

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

​ callback：回调函数

//导入fs模块
var fs = require('fs')
fs.mkdir('./itachi',(err)=>{
    if(err){
        console.log(err);
    }
    console.log('创建成功！');
})

b、同步创建

fs.mkdirSync(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('itachi',(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')//如果设置成ascii，则会乱码
// 3.注册事件  若该事件被触发，说明数据流中有数据了，数据会读到回调函数的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)
})
console.log('程序结束')

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