前言

文件操作是开发过程中并不可少的一部分。Node.js 中的 fs 模块是文件操作的封装，它提供了文件读取、写入、更名、删除、遍历目录、链接等 POSIX 文件系统操作。与其它模块不同的是，fs 模块中所有的操作都提供了异步和同步的两个版本,具有 sync 后缀的方法为同步方法，不具有 sync 后缀的方法为异步方法

导入文件模块

const fs = require('fs');

文件操作

1.查看文件状态

fs.stat(path[, options], callback) (异步)
fs.stat()方法用于查询文件信息，可以用于查询文件的大小、创建时间、权限等相关信息。fs.stat()是异步方法，还有一个同步方法fs.statSync(path)。
回调有两个参数 (err, stats), stats是一个对象;
示例如下:

fs.stat(__dirname, function(err, stats){
  console.log(stats);
})

返回结果如下

Stats {
  dev: 178201719,
  mode: 16822,
  nlink: 1,
  uid: 0,
  gid: 0,
  rdev: 0,
  blksize: 4096,
  ino: 1970324837159953,
  size: 0,
  blocks: 8,
  atimeMs: 1585121851677.5623,
  mtimeMs: 1585121851600.7673,
  ctimeMs: 1585121851600.7673,
  birthtimeMs: 1584974594013.973,
  atime: 2020-03-25T07:37:31.678Z,
  mtime: 2020-03-25T07:37:31.601Z,
  ctime: 2020-03-25T07:37:31.601Z,
  birthtime: 2020-03-23T14:43:14.014Z
}
birthtime: 文件的创建时间
mtime: 文件中内容发生变化, 文件的修改时间

stats是一个fs.Stats对象，该对象中包含一个stats.isFile()和一个stats.isDirectory()方法。
stats.isFile() 用于查询当前路径对应的是否是一个文件, 检查文件是否存在
stats.isDirectory() 用于查询当前路径对应的是否是一个文件夹

fs.stat(__filename, function(err, stats){
  if (stats.isFile()){
        console.log("当前路径对应的是一个文件");
    }
})
fs.stat(__dirname, function(err, stats){
  if (stats.isDirectory()){
        console.log("当前路径对应的是一个文件夹");
    } 
})

fs.statSync(path[, options]) (同步)
没有回调函数, 返回的 fs.Stats 对象, 也有stats.isFile()和stats.isDirectory()方法。这两个方法和上面的用法是一样的

let stats = fs.statSync(__dirname);
if (stats.isFile()){
    console.log("当前路径对应的是一个文件");
} else if (stats.isDirectory()) {
    console.log("当前路径对应的是一个文件夹");
}
console.log(stats);

2.文件打开

fs.open(path[, flags[, mode]], callback)
异步地打开文件。
filename, 必选参数，文件名
flags, 操作标识，如"r",以读的方式打开
[mode],权限，如777，表示任何用户读写可执行
callback 打开文件后回调函数，参数默认第一个err,第二个fd为一个整数，表示打开文件返回的文件描述符，window中又称文件句柄

fs.open(__dirname + '/test.txt', 'r', '0666', function (err, fd) {
  console.log(fd);
});

3.文件读取

fs.readFile(path[, options], callback) (异步)有callback回调函数的就是异步方法
异步地读取文件的全部内容。
1.它接收第一个必选参数，表示读取的文件名。
2.第二个参数 encoding 是可选的，表示文件字符编码。
3.第三个参数callback是回调函数，用于接收文件的内容。回调函数提供两个参数 err 和 data ， err 表示有没有错误发生，data 是文件内容。
【注意】：
如果不指定 encoding ，则callback就是第二个参数。
如果指定 encoding ， data是一个解析后的字符串，否则将会以 Buffer 形式表示的二进制数据。

fs.readFile('data.txt', function(err, data){
  if(err) throw new Error('文件读取失败');
  console.log(data);  // <Buffer 4e 6f 64 65 4a 53 e5 ad a6 e4 b9 a0 e4 b9 8b e6 97 85>
})
fs.readFile('data.txt', 'utf8', function(err, data){
  if(err) throw new Error('文件读取失败');
  console.log(data);  // NodeJS学习之旅
})

fs.readFileSync(path[, options]) (同步)
同步地读取文件的全部内容。
没有回调函数, 但是用法和fs.readFile()类似

let data = fs.readFileSync('data.txt')
console.log(data);  // <Buffer 4e 6f 64 65 4a 53 e5 ad a6 e4 b9 a0 e4 b9 8b e6 97 85>
let data = fs.readFileSync('data.txt', 'utf8');
console.log(data);  // NodeJS学习之旅

4.文件写入

fs.writeFile(file, data[, options], callback)
1.第一个参数file为必选参数, 表示读取的文件名
2.第二个参数data, 是要写入的数据, ，可以指定一个字符串
3.第三个参数可选, 可以是encoding或者flag等
4.第四个参数callback是文件写入完成之后的callback回调函数, 只有err一个形参
示例

fs.writeFile('lyz.txt', 'NodeJs学习之旅', err => {
    if (err) throw err;
    console.log("文件写入成功");
});

【注意】将数据写入到一个文件时，如果文件已存在则覆盖该文件, 如果文件名不存在, 则会创建一个新的文件, 并将数据写入其中。

写入的数据也可以是Buffer数据

let buf = Buffer.from("我在学习NodeJS");
fs.writeFile('lyz.txt', buf, 'utf8', err => {
    if (err) throw err;
    console.log("文件写入成功");
});

fs.writeFileSync(file, data[, options])
文件写入同步操作
示例

fs.writeFileSync('lyz.txt', "NodeJs文件模块", 'utf8');
console.log('文件写入成功');

5.追加写入

fs.appendFile(path, data[, options], callback)
异步地将数据追加到文件，如果文件尚不存在则创建该文件。 data 可以是字符串或 Buffer
参数1：表示要向哪个文件中追加内容，指定一个文件的路径
参数2：表示要追加的具体的内容，可以传递字符串内容
可选参数：表示追加文本内容时候的编码格式，如果省略此参数。默认以utf8的格式追加内容
参数4：表示追加完成之后的回调, 有形参err，追加失败之后的错误结果

fs.appendFile("08.txt", "appendFile()方法", err => {
    if (err)  throw err;
    console.log("数据追加成功");
});

fs.appendFileSync(path, data[, options])
同步地将数据追加到文件，如果文件尚不存在则创建该文件。 data 可以是字符串或 Buffer

try {
    fs.appendFileSync("08.txt", "appendFileSync()方法");
    console.log("数据追加成功");
}catch (err) {
    throw err;
}

6.文件重命名

fs.rename(oldPath, newPath, callback)
异步地将 oldPath 上的文件重命名为 newPath 提供的路径名。 如果 newPath 已存在，则覆盖它。
oldPath 原来的文件名
newPath 新的文件名
callback 回调函数中只有err一个参数, 可以抛出异常

fs.rename("09.txt", "abc.txt", err => {
    if (err) throw err;
    console.log('重命名完成');
});

fs.renameSync(oldPath, newPath)
同步的 rename。返回 undefined。

7.删除文件

fs.unlink(path, callback)
异步地删除文件或符号链接。 除了可能的异常，完成回调没有其他参数。

fs.unlink('index.txt', err =>{
    if(err) throw err;
    console.log('删除文件成功');
})

fs.unlinkSync(path)
同步的 unlink。返回 undefined。

8.大文件操作

前面讲解的关于文件写入和读取操作都是一次性将数据读入内存或者一次性写入到文件中
但是如果数据比较大, 直接将所有数据都读到内存中会导致计算机内存爆炸,卡顿,死机等
所以对于比较大的文件我们需要分批读取和写入

8.1创建读取流

fs.createReadStream(path[, options])
从文件流中读取数据，读取的文件比较大时建议用流的方式读取，文件比较大会多次读取。
参数1：要读取的文件
可选参数：这个参数比较多, 可以参考官方文档。我们重点来看一下encoding和highWaterMark
encoding: 读取文件时的编码格式, 默认值:null, 会把读取到的数据放到Buffer中
如果想让读取到Buffer中的数据是字符串, 那么将这个值改为utf8即可
highWaterMark: 表示每次读取的字节数, 默认值: 64 * 1024。
示例

// 1.创建一个读取流
let readStream = fs.createReadStream('09.txt', {encoding: 'utf8', highWaterMark: 1});
// 为了方便演示, 这里每次读取一个字节
// 2.添加事件监听
readStream.on("open", function () {
    console.log("数据流与文件建立关系成功");
});
readStream.on("error", function () {
    console.log("数据流与文件建立关系失败");
});
readStream.on("data", function (data) {
    //文件比较大时，会多次读取，多次执行该回调函数  
    console.log("通过读取流从文件中读取到了数据", data);
});
readStream.on("end", function () {
    console.log("读取数据结束");
});
readStream.on("close", function () {
    console.log("数据流断开了与文件的关系");
});
打印结果
数据流与文件建立关系成功
通过读取流从文件中读取到了数据 N
通过读取流从文件中读取到了数据 o
通过读取流从文件中读取到了数据 d
通过读取流从文件中读取到了数据 e
读取数据结束
数据流断开了与文件的关系

8.2创建写入流

fs.createWriteStream(path[, options])
path 文件路径
[options] flags:指定文件操作，默认'w',；encoding,指定写入流编码；start指定写入文件的位置
【注意】和fs.write()方法一样, 将数据写入到一个文件时，如果文件已存在则覆盖该文件, 如果文件名不存在, 则会创建一个新的文件, 并将数据写入其中。
默认情况下，流在销毁后将不会触发 'close' 事件。所以这里要通过end() 方法结束写入流，释放资源

// 1.创建一个写入流
let writeStream = fs.createWriteStream("09.txt", {encoding: "utf8"});
// 2.监听写入流事件
writeStream.on("open", function () {
    console.log("数据流与文件建立关系成功");
});
writeStream.on("error", function () {
    console.log("数据流与文件建立关系失败");
});
writeStream.on("close", function () {
    console.log("数据流断开了与文件的关系");
});
let data = "Node";
let index = 0;
let timeId = setInterval(function () {
    let ch = data[index];
    index++;
    writeStream.write(ch);
    console.log("本次写入了", ch);
    if (data.length === index){
        clearInterval(timeId);
        // 结束写入流，释放资源 
        writeStream.end();  
    } 
}, 1000);

8.3文件拷贝

通过分批读取和分批写入将test.mp4中的数据拷贝到abc.mp4中
代码演示

// 1.创建读取流和写入流
let readStream = fs.createReadStream("test.mp4");
let writeStream = fs.createWriteStream("abc.mp4");

// 2.监听读取流事件
readStream.on("open", function () {
    console.log("读取流与文件建立关系成功");
});
readStream.on("error", function () {
    console.log("读取流与文件建立关系失败");
});
readStream.on("data", function (data) {
    // 4.将读取到的数据写入到新的文件中
    writeStream.write(data);
});
readStream.on("end", function () {
    console.log("读取数据结束");
});
readStream.on("close", function () {
    console.log("读取流断开了与文件的关系");
    // 5.结束写入流，释放资源 
    writeStream.end();
});

// 3.监听写入流事件
writeStream.on("open", function () {
    console.log("写入流与文件建立关系成功");
});
writeStream.on("error", function () {
    console.log("写入流与文件建立关系失败");
});
writeStream.on("close", function () {
    console.log("写入流断开了与文件的关系");
});

其实要实现文件拷贝, 根本不需要自己手动去写那么多代码, 在读取流中提供了一个管道方法, 可以快速实现拷贝
rs.pipe(destination, [options])
destination 必须一个可写入流数据对象
[opations] end 默认为true，表示读取完成立即关闭文件；

// 1.创建读取流和写入流
let readStream = fs.createReadStream("test.mp4");
let writeStream = fs.createWriteStream("abc.mp4");
// 2.利用读取流的管道方法快速实现拷贝
readStream.pipe(writeStream);
console.log("文件拷贝成功");

目录(文件夹)操作

const path = require("path");

let str = path.join(__dirname, "abc");

1.创建目录

fs.mkdir(path[, mode], callback)
异步地创建目录。
path, 被创建目录的完整路径及目录名；
[mode], 目录权限，默认0777
[callback(err)], 创建完目录的回调函数, err可能的异常

fs.mkdir(str, err => {
    if (err) throw err;
    console.log("创建目录成功");
});

fs.mkdirSync(path[, options])
同步地创建目录。 返回 undefined。

2.删除目录

fs.rmdir(path[, options], callback)
异步地删除目录。
path, 目录的完整路径及目录名；
[callback(err)], 操作完成回调函数；err操作失败对象

fs.rmdir(str, err => {
    if (err) throw err;
    console.log("删除目录成功");
});

fs.rmdirSync(path[, options])
同步地删除目录。

3.读取目录

fs.readdir(path[, options], callback)
异步地 读取目录的内容。
path, 要读取目录的完整路径及目录名；
[callback(err, files)], 读完目录回调函数；err错误对象，files数组，存放读取到的目录中的所有文件名

fs.readdir(__dirname, (err, files) => {
   if (err) throw err;
    console.log("读取到的数据", files);
});

fs.readdirSync(path[, options])
同步地 读取目录的内容。

实战训练：

只讲文件相关 Api 显得很枯燥，下面说一些 fs 在 Node.js 中的具体应用

【示例: 利用NodeJS生成项目模板】

const fs = require("fs");
const path = require("path");

class CreateProject{
    constructor(rootPath, projectName){
        this.rootPath = rootPath;
        this.projectName = projectName;
        this.subFiles = ["images", "css", "js", "index.html"];
    }
    initProject(){
        // 1.创建根目录
        let projectPath = path.join(this.rootPath, this.projectName);
        fs.mkdirSync(projectPath);
        // 2.创建子文件和字目录
        this.subFiles.forEach(function (fileName) {
            if (path.extname(fileName) === ""){
                let dirPath = path.join(projectPath, fileName);
                fs.mkdirSync(dirPath);
            } else {
                let filePath = path.join(projectPath, fileName);
                fs.writeFileSync(filePath, '');
            }
        })
    }
}
let cp = new CreateProject(__dirname, "jd");
cp.initProject();