12.node.js的文件系统（fs）

node.js的文件系统

Node.js 提供一组类似 UNIX（POSIX）标准的文件操作API。 Node 导入文件系统模块(fs)语法如下所示：

const fs = require("fs")

同步和异步

首先解释一下，什么是同步，什么是异步。
同步(sync)：发送方发出数据后，等接收方发回响应以后才发下一个数据包的通讯方式。可以理解为串行，比如有三个语句一起执行，同步会按顺序一个一个执行，且第二个会在第一个执行完后再执行，第三个会在第二个执行完后再执行。

异步(async)：发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式。可以理解为并行，同样有三个语句一起执行，这三个语句会一起执行，最后谁先执行完，谁也说不准。

Node.js 文件系统（fs 模块）模块中的方法均有异步和同步版本，例如读取文件内容的函数有异步的 fs.readFile() 和同步的 fs.readFileSync()。

异步的方法函数最后一个参数为回调函数，回调函数的第一个参数包含了错误信息(error)。建议大家使用异步方法，比起同步，异步方法性能更高，速度更快，而且没有阻塞。

下面，直接用代码来解释一波：
先新建一个hello.txt文件，内容如下：

我是一个稀松平常的文本文件。

const fs = require("fs");

// 异步读取
fs.readFile('hello.txt', function (err, data) {
    if (err) {
        return console.error(err);
    }
    console.log("异步读取: " + data.toString());
});

// 同步读取
let data = fs.readFileSync('hello.txt');
console.log("同步读取: " + data.toString());

console.log("程序执行完毕。");

运行结果：

这里，可能有些人会觉得，什么鬼，说好的异步快呢，怎么同步先跑完了。但是，你发现没有，异步其实是在同步前面执行的，但是他的结果却在程序执行完毕输出后才执行完毕，这说明什么，这说明，异步他不会像同步那么流氓，他不会自个儿占着茅坑，等肠胃里的东西都排完了，才让别人如厕，而是特别热心地让需要蹲坑的人一起XX。这个时候，有些人XX比他快，就可以先走了；而同步则不同，同步是上公共厕所还把门给锁了，他只要还没排完，就一直占着地儿，不让别人进。（例子略微恶心，但是自我感觉浅显易懂）

打开文件(open、openSync)

打开文件也有同步和异步两种方式
同步的语法是：

fs.openSync(path, flags[, mode], callback)

异步的语法是：

fs.open(path, flags[, mode], callback)

参数说明：

• path - 文件的路径。
• flags - 文件打开的行为。
• mode - 设置文件模式(权限)，文件创建默认权限为 0666(可读，可写)。
• callback - 回调函数，带有两个参数如：callback(err, fd)。

参数flags的可选值：

下面给出异步的实例，同步的其实也差不多，就是改个函数名而已：

const fs = require("fs");

// 异步打开文件
console.log("准备打开文件！");
fs.open('hello.txt', 'r+', function(err, fd) {
    if (err) {
        return console.error(err);
    }
    console.log("文件打开成功！");
});

显示：

获取文件信息

同步的语法是：

fs.statSync(path, callback)

异步的语法是：

fs.stat(path, callback)

参数描述：

• path：欲获取的文件路径
• callback：回调函数，带有两个参数如：(err, stats), stats 是 fs.Stats 对象。

fs.stat(path)执行后，会将stats类的实例返回给其回调函数。可以通过stats类中的提供方法判断文件的相关属性。例如判断是否为文件：

const fs = require('fs');

fs.stat('hello.txt', function (err, stats) {
    //使用stats的isFile()方法判断是否是文件
    console.log(stats.isFile());         //true
    //使用isDirectory()方法判断是否是木咯
    console.log(stats.isDirectory());   //false
});

显示如下：

stats类中常用方法：

方法	描述
stats.isFile()	如果是文件返回 true，否则返回 false。
stats.isDirectory()	如果是目录返回 true，否则返回 false。
stats.isBlockDevice()	如果是块设备返回 true，否则返回 false。
stats.isCharacterDevice()	如果是字符设备返回 true，否则返回 false。
stats.isSymbolicLink()	如果是软链接返回 true，否则返回 false。
stats.isFIFO()	如果是FIFO，返回true，否则返回 false。FIFO是UNIX中的一种特殊类型的命令管道。
stats.isSocket()	如果是 Socket 返回 true，否则返回 false。

接下来我们跑一个稍微厉害点的代码

const fs = require("fs");

console.log("准备打开文件！");
fs.stat('hello.txt', function (err, stats) {
    if (err) {
        return console.error(err);
    }
    console.log(stats);
    console.log("读取文件信息成功！");

    // 检测文件类型
    console.log("是否为文件(isFile) ? " + stats.isFile());
    console.log("是否为目录(isDirectory) ? " + stats.isDirectory());
});

显示：

再如，我们读取当前目录，并答应目录信息如下：

const fs = require("fs");

console.log("准备打开文件！");
fs.stat('.', function (err, stats) {
    if (err) {
        return console.error(err);
    }
    console.log(stats);
    console.log("读取目录信息成功！");

    // 检测文件类型
    console.log("是否为文件(isFile) ? " + stats.isFile());
    console.log("是否为目录(isDirectory) ? " + stats.isDirectory());
});

显示：

写入文件

同步的语法是：

fs.writeFileSync(file, data[, options], callback)

异步的语法是：

fs.writeFile(file, data[, options], callback)

注意：writeFile 直接打开文件默认是 w 模式，所以如果文件存在，该方法写入的内容会覆盖旧的文件内容。

参数描述：

• file - 文件名或文件描述符。
• data - 要写入文件的数据，可以是 String(字符串) 或 Buffer(缓冲) 对象。
• options - 该参数是一个对象，包含 {encoding, mode, flag}。默认编码为 utf8, 模式为 0666 ， flag 为 ‘w’
• callback - 回调函数，回调函数只包含错误信息参数(err)，在写入失败时返回。

const fs = require("fs");

console.log("准备写入文件");
fs.writeFile('input.txt', '我是通过 fs.writeFile 写入文件的内容',  function(err) {
    if (err) {
        return console.error(err);
    }
    console.log("数据写入成功！");
    console.log("-----------------------------------------");
    console.log("读取写入的数据！");
    fs.readFile('input.txt', function (err, data) {
        if (err) {
            return console.error(err);
        }
        console.log("异步读取文件数据: " + data.toString());
    });
});

显示：
1.多了一个叫input.txt的文件（之前没有创建）

2.控制台显示：

由于内容比较简单，后边就统一不写代码了，直接说一下异步的形式怎么用（同步只是运行起来不太一样，然后函数名都比异步多个Sync而已）

读取文件

异步的语法：

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

参数描述：

• fd - 通过 fs.open() 方法返回的文件描述符。
• buffer - 数据写入的缓冲区。
• offset - 缓冲区写入的写入偏移量。
• length - 要从文件中读取的字节数。
• position - 文件读取的起始位置，如果 position 的值为 null，则会从当前文件指针的位置读取。
• callback - 回调函数，有三个参数err, bytesRead, buffer，err 为错误信息， bytesRead 表示读取的字节数，buffer 为缓冲区对象。

实例：

const fs = require("fs");
const buf = new Buffer.alloc(1024);

console.log("准备打开已存在的文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
   console.log("文件打开成功！");
   console.log("准备读取文件：");
   fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
      if (err){
         console.log(err);
      }
      console.log(bytes + "  字节被读取");
      
      // 仅输出读取的字节
      if(bytes > 0){
         console.log(buf.slice(0, bytes).toString());
      }
   });
});

关闭文件

异步的语法：

fs.close(fd, callback)

参数描述：

• fd - 通过 fs.open() 方法返回的文件描述符。
• callback - 回调函数，没有参数。

const fs = require("fs");
const buf = new Buffer.alloc(1024);

console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
   console.log("文件打开成功！");
   console.log("准备读取文件！");
   fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
      if (err){
         console.log(err);
      }

      // 仅输出读取的字节
      if(bytes > 0){
         console.log(buf.slice(0, bytes).toString());
      }

      // 关闭文件
      fs.close(fd, function(err){
         if (err){
            console.log(err);
         } 
         console.log("文件关闭成功");
      });
   });
});

截取文件

异步语法：

fs.ftruncate(fd, len, callback)

参数描述：

• fd - 通过 fs.open() 方法返回的文件描述符。
• len - 文件内容截取的长度。
• callback - 回调函数，没有参数。

注意：一个中文是三个字节，其他编译器我不知道，但是我在WebStorm下一个中文是算三个字节

const fs = require("fs");
const buf = new Buffer.alloc(1024);

console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
   console.log("文件打开成功！");
   console.log("截取10字节内的文件内容，超出部分将被去除。");
   
   // 截取文件
   fs.ftruncate(fd, 10, function(err){
      if (err){
         console.log(err);
      } 
      console.log("文件截取成功。");
      console.log("读取相同的文件"); 
      fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
         if (err){
            console.log(err);
         }

         // 仅输出读取的字节
         if(bytes > 0){
            console.log(buf.slice(0, bytes).toString());
         }

         // 关闭文件
         fs.close(fd, function(err){
            if (err){
               console.log(err);
            } 
            console.log("文件关闭成功！");
         });
      });
   });
});

删除文件

异步语法：

fs.unlink(path, callback)

参数描述：

• path - 文件路径。
• callback - 回调函数，没有参数。

const fs = require("fs");

console.log("准备删除文件！");
fs.unlink('input.txt', function(err) {
   if (err) {
       return console.error(err);
   }
   console.log("文件删除成功！");
});

新建目录

异步语法：

fs.mkdir(path[, options], callback)

参数描述：

• path - 文件路径。
• options 参数可以是：
  – recursive - 是否以递归的方式创建目录，默认为 false。
  – mode - 设置目录权限，默认为 0777。
• callback - 回调函数，没有参数。

说一下option中的recursive属性的递归哈，有递归的话，那么你可以一次创建多级目录，不用管他当前目录下有没有存在这个目录，有他会进去，没有他会新建一个。
没有设置递归的话，一次只能创建一个目录，否则会报错。
比如以下代码，我的 . (也就是当前目录下没有tmp这个目录，我是没办法直接用下面的代码创建tmp目录和test目录的）

//代码运行时会报错
const fs = require("fs");
// tmp 目录必须存在
console.log("在./temp目录下创建目录 /test/");
fs.mkdir("./temp/test/",function(err){
    if (err) {
        return console.error(err);
    }
    console.log("目录创建成功。");
});

而如果我设置了递归的话，就可以了：
记住，option中的内容是一个JSON对象，要用 { } 括起来

const fs = require("fs");
// tmp 目录必须存在
console.log("迭代创建目录 ./temp/test/");
fs.mkdir("./temp/test/",{recursive:true},function(err){
    if (err) {
        return console.error(err);
    }
    console.log("目录创建成功。");
});

这段代码运行后就不会报错了，而且会一次性新建两个目录，分别是temp和test，且test是temp的子目录。

读取目录

异步语法：

fs.readdir(path, callback)

参数：

• path - 文件路径。
• callback - 回调函数，回调函数带有两个参数err, files，err 为错误信息，files 为 目录下的文件数组列表。

const fs = require("fs");

console.log("查看 当前 目录");
fs.readdir(".",function(err, files){
    if (err) {
        return console.error(err);
    }
    files.forEach( function (file){
        console.log( file );
    });
});

结果：

删除目录

异步语法：

fs.rmdir(path, callback)

参数描述：

• path - 文件路径。
• callback - 回调函数，没有参数。

const fs = require("fs");
// 执行前创建一个空的 /tmp/test 目录
console.log("准备删除目录 /temp/test");
fs.rmdir("./temp/test",function(err){
    if (err) {
        return console.error(err);
    }
    console.log("读取 /temp 目录");
    fs.readdir("./temp/",function(err, files){
        if (err) {
            return console.error(err);
        }
        files.forEach( function (file){
            console.log( file );
        });
    });
});

显示：

文件模块方法大全（不一定是最全的）