Node中的FS核心模块(包括可读、可写传输流)

FS核心模块(fileSystem)

在Nodejs中有一个文件系统，对计算机中的文件进行增删改查操作。

在nodejs中我们提供了一个模块，叫做fs模块系统，专门用于操作文件系统。

在nodejs中这个模块是可以直接使用的。

---

使用

• 引入文件系统

const fs = require('fs');

读取文件

fs.readFile(path, options ,(error, data) => {});

此方法用于读取文件，传入三个参数，

第一个参数是文件路径+文件名，相较于自身文件来说

第二个参数是可配置项

第三个参数是回调函数，用于处理文件读取的结果操作，回调接收两个参数，一个是失败到的结果，一个是成功的结果

fs.readFile('../text/demo.txt', (error, data) => {
    if(error){
        console.log('读取失败');
        return;
    }
    console.log('读取成功\n', data);
});

// 读取成功 
//<Buffer 2b 20 e8 bf 99 e6 98 af e4 b8 80 e6 ae b5 e8 a2 ab e8 af bb e5 8f 96 e7 9a 84 e6 96 87 e4 bb b6>

注意 在读取成功时，返回的是buffer对象保存的一段16进制的值。可以使用toString()来转成字符串。

fs.readFile('../text/demo.txt', (error, data) => {
    if(error){
        console.log('读取失败');
        return;
    }
    console.log('读取成功', data.toString());
});
//读取成功
// + 这是一段被读取的文件

当路径出现错误或者文件读取出现未知的错误时，则会打印错误对象error

   //      ---------读取成功
    //        date------数据
    //        error-----null
    //      ---------读取失败
    //        date------null
    //        error-----错误对象

• 同步读取文件

let data = fs.readFileSync(path, option)

和普通读取文件作用类似，只不过在读取文件操作时会阻塞同步代码的执行。

---

• 流式文件读取(重要)

相较与简单文件读取的区别

简单读取文件，即在读取文件时一次将文件读取，一步完成

流式文件读取，即先开启读取文件的通道(读取流)，后面可多次读取文件，多步完成

// 普通文件读取
const fs = require('fs');
// 流式文件读取
const rs = fs.createReadStream(path, options);

path : 读取路径和文件

options : 可配置对象

{

​	--- flags ：打开文件要执行的操作，默认值为'w'

​	--- encoding : 设置文件的编码方式，默认为utf8

​	--- mode : 设置文件的操作权限， 默认0o666 = 0o222 +0o444(即可被读取写入)

​	--- fd : 文件统一标识符，

​	--- autoClose ：自动关闭文件流  默认为true

​	--- emitClose ： 关闭(出现问题) --- 文件 ，默认为false

​	--- start ：读取文件的初始位置

​   --- end ：读取文件的结束位置
 
​   --- highWaterMark : 控制每次读取数据的大小， 默认值是 64 * 1024

}

使用

const fs = require('fs');

//创建可读流
const rs = fs.createReadStream(__dirname + '/text/newText.txt', options);
//检测可读流是否打开
rs.on('open', () => {
    console.log('可读流打开了');
});
//检测可读流是否关闭
rs.on('close', () => {
    console.log('可读流关闭了')
});

//读取文件
rs.on('data', (data) => {
    //获取到的每一段的buffer数据
    console.log(data);
    
    //data.length表示该buffer实例占用内存空间的大小
    console.log(data.length);
    //输出64 ---》 每一次读取64kb大小的数据
});

//读取的时候如果文件读取完了，会自动关闭可读流

---

写入文件

fs.writeFile(path, options, callback);

此方法用于写入文件，传入三个参数，

第一个参数是文件路径+文件名，相较于自身文件来说

第二个参数是写入的文件内容。

第三个参数是可配置项

​		--- encoding: 设置文件的编码方式，默认为utf8

​		--- mode: 设置文件的操作权限， 默认0o666 = 0o222 +0o444(即可被读取写入)

​							-- 0o111 : 文件可被执行的权限

​							-- 0o222 ：文件可被写入的权限

​							-- 0o444 ：文件可被读取的权限

​		--- falg：打开文件要执行的操作，默认值为'w'

​							-- 'w' : 追加

​							-- ‘a’ : 写入

第四个参数是回调函数，用于处理文件写入的结果操作，回调接收两个参数，一个是失败到的结果，一个是成功的结果

// 写入文件
fs.writeFile('./text/write.txt', '这是一段写入的内容', {mode: 0o222},(error, data)=>{
    if(error){
        throw new Error('写入失败');
    }
    console.log('写入成功', data);
});
//读取文件
fs.readFile('./text/write.txt', (error, data) => {
    if(error){
        throw new Error('读取失败');
    }
    console.log('读取成功\n', data.toString());
    
    
// 写入成功 undefined
    
// 读取成功
// 这是一段写入的内容

---

• 同步写入文件

let data = fs.writeFileSync(path, options);

• 流式文件写入(重要)

相较与简单文件写入的区别

简单写入文件，即在写入文件时一次将文件写入，一步完成

流式文件写入，即先开启写入文件的通道(可写流)，后面可多次写入文件，多步完成

使用fs.createWriteStream(path, option)创建写入文件流

有两个参数

第一个参数为写入的文件路径 + 文件名 + 文件名后缀

第二个参数为可选配置对象

{

​	--- flags ：打开文件要执行的操作，默认值为'w'

​	--- encoding : 设置文件的编码方式，默认为utf8

​	--- mode : 设置文件的操作权限， 默认0o666 = 0o222 +0o444(即可被读取写入)

​	--- fd : 文件统一标识符，

​	--- autoClose ：自动关闭文件流  默认为true

​	--- emitClose ： 关闭(出现问题) --- 文件 ，默认为false

​	--- start ：写入文件的初始位置

}

使用文件读写

const fs = require('fs');

// 创建写入流
let ws = fs.createWriteStream(__dirname + 'demo.txt');

// 检测可写流的状态(必须), 流打开时调用回调
ws.on('open', () => {
    console.log('可写流打开');
});
// 流关闭时调用回调
ws.on('close', () => {
   console.log('可写流已关闭'); 
});

//使用可写流写入数据
ws.write('第一段写入数据');
ws.write('写入的第二段数据');
ws.write('写入第三段的数据');

// 关闭可写流（避免创建的可写流过多，导致内存溢出）

// 在node8中使用此方法关闭流会导致数据的丢失
ws.close();
//node8版本中使用此方法
ws.end();

---

注意：

简单读取和简单写入文件都试一次完成的，当读写的数据量过于庞大时，会出现内存溢出。

如，当存入10gb的数据，而内存只有8gb时，读取的文件不能一次性放入内存中，那么就会出现错误，无法读取，当写入的数据量过于庞大时，内存中的文件数据一次性不能写入硬盘，也会出现写入错误。

流式读取，流式写入可以避开这些问题，写入读取时可以分部执行。

---

综合可读流，可写流案例。

// 案例：将text文件夹下的音频读取出来，然后写入到当前文件夹下

const fs = require('fs');

// 创建可写流
const ws = fs.createWriteStream(`${__dirname}/音频.mp3`, {});

// 创建可读流
const rs = fs.createReadStream(`${__dirname}/text/橘子海 (Orange Ocean) - 夏日漱石 (Summer Cozy Rock).mp3`, {
    highWaterMark: 10 * 1024 * 1024, //每次读取10mb数据
});

// 检测可写流
ws.on('open', () => {
    console.log('可写流开启');
});

ws.on('close', () => {
    console.log('可写流关闭');
});

// 检测可读流
rs.on('open', () => {
    console.log('可读流开启');
});

rs.on('close', () => {
    console.log('可读流关闭');

    // 在可读流关闭时关闭可写流
    ws.close();
});

// 读取数据
rs.on('data', (data) => {

    console.log(data.length);

    // 分流写入数据
    ws.write(data);
});

检测是文件还是目录(目录 文件是否存在)

// fs.stat 检测是文件还是目录 fs.statSync()同步获取stats对象,通过返回值接收。
fs.stat('./ttt',function(error,stats){
  if(error){
    console.log(error);
    return;
  }
  console.log('文件：'+stats.isFile());
  console.log('目录：'+stats.isDirectory());
})

写入追加文件

fs.appendFile

// fs.appendFile 追加文件 
fs.appendFile('./index.txt','新写入的',function(error){
  if(error){
    console.log(error);
    return;
  }
  console.log('写入成功');
})

删除文件

fs.unlink

fs.unlink('index.html',function(error){
  if(error){
    console.log(error);
    return;
  }
  console.log('删除文件成功');
})

创建文件目录

fs.mkdir

//2. fs.mkdir 创建目录 
fs.mkdir('TEXT',function(error){
  if(error){
    console.log(error);
    return;
  }
  console.log('创建目录成功');
})

读取目录

fs.readdir 读取目录下第一级内容
把目录下面的文件和文件夹全部获取。

fs.readdir('./TEXT',function(error,data){
 if(error){
   console.log(error);
   return;
 }
 console.log(data);
  //data是数组类型，包含文件夹以及文件的名字(只有第一级目录内容)。拿到一个文件夹下面的所有目录 
})

删除文件目录

fs.rmdir 删除目录

// rmdir 这个方法只能删除目录，不能删除文件 
fs.rmdir('/text',function(error){
  if(error){
    console.log(error);
    return;
  }
  console.log('删除目录成功');
})

重命名

通过fs.rename实现

// 1.改名 2.剪切文件(移动) 
fs.rename('./index.html','./n.html',function(error){
 if(error){
   console.log(error);
   return;
 }
 console.log('修改名字成功');
})