05-Node.js内置模块：fs文件模块

Node.js 的官方API文档

关于 Node.js 的内置模块和常见API，可以看官方文档。

查阅文档时，稳定指数如下：

  • 红色：废弃。

  • 橙色：实验。表示当前版本可用，其他版本不确定。也许不向下兼容，建议不要在生产环境中使用该特性。

  • 绿色：稳定。与 npm 生态系统的兼容性是最高的优先级。

Node.js 中模块的分类

Node.js 应用由模块组成，采用 CommonJS 模块规范。Node.js中的模块分为三种：

  • 内置模块

  • 第三方模块

  • 自定义模块

下面简单介绍一下。

1、内置模块

  1. const process = require('process');
  2. const path = require('path');
  4. console.log(process.version);
  5. console.log(path.resolve('../'));

require方法用于加载模块。

常见的内置模块包括：

  • FS：文件系统模块

  • path：路径模块

  • OS：操作系统相关

  • net：网络相关

  • http

  • …

你可能会有疑问：Node.js 这么牛吗？还能直接和操作系统做交互？

带着这个疑问，我们不妨简单看看 Node.js 的源码，以 os 模块举例：

现在你知道了，JS本身是没有能力获取底层系统资源的，这一切都是 JS虚拟机在和底层做交互，然后通过 JS 的表现形式，暴露给应用层。

另外，还有很多库，是直接使用C/++编写的，通过编译之后，再提供给 JS 应用层调用，或者直接提供给 Node.js层使用。

所有的编程语言底层都会回归C/C++，甚至是汇编语言。

2、require 加载第三方包的机制

  1. const express = require('express');

require 加载第三方包的机制：

（1）第三方包安装好后，这个包一般会存放在当前项目的 node_modules 文件夹中。我们找到这个包的 package.json 文件，并且找到里面的main属性对应的入口模块，这个入口模块就是这个包的入口文件。

（2）如果第三方包中没有找到package.json文件，或者package.json文件中没有main属性，则默认加载第三方包中的index.js文件。

（3）如果在 node_modules 文件夹中没有找到这个包，或者以上所有情况都没有找到，则会向上一级父级目录下查找node_modules文件夹，查找规则如上一致。

（4）如果一直找到该模块的磁盘根路径都没有找到，则会报错：can not find module xxx。

3、自定义模块（module）：

每个文件就是一个模块，有自己的作用域。在一个文件里面定义的变量、函数、类，都是私有的，对其他文件不可见。

举例：

  1. var example = require('./example.js');
  2. console.log(example.x); // 5
  3. console.log(example.addX(1)); // 6

读取文件

今天这篇文章，重点讲一下 Node 内置模块中的 fs（文件处理模块）。

在使用文件模块之前，记得先导入：

  1. // 导入文件模块
  2. const fs = require('fs');

fs 的英文全称是 File System。fs 模块提供了很多 api 方法，我们首先应该学习的方法是文件读取。

Node中文件读取的方式主要有以下几种。

异步读取文件 fs.readFile()

语法格式：

  1. fs.readFile(file[, options], callback(error, data))

代码举例：

  1. const fs = require('fs');
  3. fs.readFile('hello.txt', 'utf8', (err, data) => {
  4.     if (err) {
  5.         // 失败
  6.         console.log(err)
  7.     } else {
  8.         // 成功
  9.         console.log('异步读取数据：' + data2)
  10.     }
  11. });

如果需要嵌套读取多个文件，可以用 promise 或者 async … await 进行封装。代码举例如下。

promise 封装 fs.readFile()

  1. const fs = require('fs');
  3. function fsRead(path) {
  4.     return new Promise((resolve, reject) => {
  5.         fs.readFile(path, { flag: 'r', encoding: "utf-8" }, (err, data) => {
  6.             if (err) {
  7.                 //失败执行的内容
  8.                 reject(err)
  9.             } else {
  10.                 //成功执行的内容
  11.                 resolve(data)
  12.             }
  13.         })
  14.     })
  15. }
  17. var promise1 = fsRead('hello1.txt')
  18. promise1.then(res1 => {
  19.     console.log(res1);
  20.     return fsRead('hello2.txt');
  21. }).then(res2 => {
  22.     console.log(res2);
  23.     return fsRead('hello3.txt');
  24. }).then(res3 => {
  25.     console.log(res);
  26. })

async … await 封装 fs.readFile()

这个写法更为简洁，推荐。

  1. var fs = require('fs');
  3. function fsRead(path) {
  4.     return new Promise((resolve, reject) => {
  5.         fs.readFile(path, { flag: 'r', encoding: "utf-8" }, (err, data) => {
  6.             if (err) {
  7.                 //失败执行的内容
  8.                 reject(err)
  9.             } else {
  10.                 //成功执行的内容
  11.                 resolve(data)
  12.             }
  13.         })
  14.     })
  15. }
  17. async function ReadList() {
  18.     var res1 = await fsRead('hello1.txt');
  19.     var res2 = await fsRead('hello2.txt');
  20.     var res3 = await fsRead('hello3.txt');
  21. }
  23. // 执行方法
  24. ReadList();

同步读取文件 fs.readFileSync()

语法格式：

  1. fs.readFileSync(file[, options])

代码举例：

  1. const fs = require('fs');
  3. try {
  4.   const data = fs.readFileSync('hello.txt', 'utf8');
  5.   console.log(data);
  6. } catch(e) {
  7.   // 文件不存在，或者权限错误
  8.   throw e;
  9. }

Node.js 中的同步和异步的区别

fs模块对文件的几乎所有操作都有同步和异步两种形式。例如：readFile() 和 readFileSync()。

区别：

  • 同步调用会阻塞代码的执行，异步则不会。

  • 异步调用会将 读取任务 下达到任务队列，直到任务执行完成才会回调。

  • 异常处理方面：同步必须使用 try catch 方式，异步可以通过回调函数的第一个参数。【重要】

写入文件

语法格式：

  1. fs.write(fd, string[, position[, encoding]], callback)

async … await 封装：

  1. let fs = require('fs')
  3. function writeFs(path, content) {
  4.     return new Promise(function (resolve, reject) {
  5.         fs.writeFile(path, content, { flag: "a", encoding: "utf-8" }, function (err) {
  6.             if (err) {
  7.                 //console.log("写入内容出错")
  8.                 reject(err)
  9.             } else {
  10.                 resolve(err)
  11.                 //console.log("写入内容成功")
  12.             }
  13.         })
  14.     })
  15. }
  18. async function writeList() {
  19.     await writeFs('1.html', "<h1>qianguyihao</h1>");
  20.     await writeFs('2.html', "<h1>hello world</h1>");
  21.     await writeFs('3.html', "<h1>永不止步</h1>");
  22. }
  24. writeList()

删除文件

语法格式：

  1. fs.unlink(path, callback)

参数说明：

  • path：文件路径。
  • callback：回调函数。

代码举例：

  1. fs.unlink('path/file.txt', (err) => {
  2.     if (err) throw err;
  3.     console.log('文件删除成功');
  4. });

备注：fs.unlink() 不能用于删除目录。 如果要删除目录，可以使用 fs.rmdir()。

Buffer

通过 Buffer 开辟的内存空间，都是连续的内存空间，所以效率比较高。

代码举例1：

  2. // 将字符串转成 buffer 对象
  3. const str = 'qianguyihao';
  4. let buffer = Buffer.from(str);
  6. console.log(buffer); // 输出16进制编码
  7. console.log(buffer.toString()); // 输出字符串：qianguyihao

代码举例2：

  1. // 从内存中开辟一个新的缓冲区
  2. let buffer = Buffer.alloc(20);
  3. buffer[0] = 'a';
  5. console.log(buffer);

读取目录

语法格式：

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

参数说明：

  • path：文件路径。

  • options参数可以是：

    • recursive：是否以递归的方式创建目录，默认为 false。
    • mode：设置目录权限，默认为 0777。

代码举例：

  1. var fs = require("fs");
  3. console.log("查看 /tmp 目录");
  4. fs.readdir("/tmp/",function(err, files){
  5.    if (err) {
  6.        return console.error(err);
  7.    }
  8.    files.forEach( function (file){
  9.        console.log( file );
  10.    });
  11. });

其他的还有：（暂略）

  • 删除目录

  • 输入输出