Node.js v21.7.2 文档

Promise 示例#

基于 Promise 的操作返回一个 Promise，该 Promise 在异步操作完成时被兑现。

import { unlink } from 'node:fs/promises';

try {
  await unlink('/tmp/hello');
  console.log('successfully deleted /tmp/hello');
} catch (error) {
  console.error('there was an error:', error.message);
}const { unlink } = require('node:fs/promises');

(async function(path) {
  try {
    await unlink(path);
    console.log(`successfully deleted ${path}`);
  } catch (error) {
    console.error('there was an error:', error.message);
  }
})('/tmp/hello');copy

回调示例#

回调形式将完成回调函数作为其最后一个参数，并异步调用操作。传递给完成回调的参数取决于方法，但第一个参数始终保留给异常。如果操作成功完成，则第一个参数为 null 或 undefined。

import { unlink } from 'node:fs';

unlink('/tmp/hello', (err) => {
  if (err) throw err;
  console.log('successfully deleted /tmp/hello');
});const { unlink } = require('node:fs');

unlink('/tmp/hello', (err) => {
  if (err) throw err;
  console.log('successfully deleted /tmp/hello');
});copy

当需要最大性能（在执行时间和内存分配方面）时，node:fs 模块 API 的基于回调的版本优于使用 Promise API。

同步示例#

同步 API 会阻塞 Node.js 事件循环和进一步的 JavaScript 执行，直到操作完成。异常会立即抛出，可以使用 try…catch 处理，也可以允许冒泡。

import { unlinkSync } from 'node:fs';

try {
  unlinkSync('/tmp/hello');
  console.log('successfully deleted /tmp/hello');
} catch (err) {
  // handle the error
}const { unlinkSync } = require('node:fs');

try {
  unlinkSync('/tmp/hello');
  console.log('successfully deleted /tmp/hello');
} catch (err) {
  // handle the error
}copy

Promises API#

fs/promises API 提供异步文件系统方法，这些方法返回 Promise。

Promise API 使用底层的 Node.js 线程池在事件循环线程之外执行文件系统操作。这些操作不同步或线程安全。在对同一文件执行多个并发修改时必须小心，否则可能会导致数据损坏。

类：FileHandle#

一个 <FileHandle> 对象是数字文件描述符的对象包装器。

<FileHandle> 对象的实例由 fsPromises.open() 方法创建。

所有 <FileHandle> 对象都是 <EventEmitter>。

如果 <FileHandle> 未使用 filehandle.close() 方法关闭，它将尝试自动关闭文件描述符并发出进程警告，以帮助防止内存泄漏。请不要依赖此行为，因为它可能不可靠，并且文件可能不会关闭。相反，始终显式关闭 <FileHandle>。Node.js 可能会在将来更改此行为。

事件：'close'#

当 <FileHandle> 已关闭且不再可用时，将发出 'close' 事件。

filehandle.appendFile(data[, options])#

• data <string> | <Buffer> | <TypedArray> | <DataView> | <AsyncIterable> | <Iterable> | <Stream>
• options <Object> | <string>
  • encoding <string> | <null> 默认： 'utf8'
  • flush <boolean> 如果为 true，则在关闭底层文件描述符之前将其刷新。默认值： false。
• 返回值： <Promise> 成功时以 undefined 履行。

是 filehandle.writeFile() 的别名。

在操作文件句柄时，模式不能从使用 fsPromises.open() 设置的模式更改。因此，这等效于 filehandle.writeFile()。

filehandle.chmod(mode)#

• mode <integer> 文件模式位掩码。
• 返回值： <Promise> 成功时以 undefined 履行。

修改文件权限。参见 chmod(2)。

filehandle.chown(uid, gid)#

• uid <integer> 文件的新所有者的用户 ID。
• gid <integer> 文件的新组的组 ID。
• 返回值： <Promise> 成功时以 undefined 履行。

更改文件的拥有权。是 chown(2) 的包装器。

filehandle.close()#

• 返回值： <Promise> 成功时以 undefined 履行。

在等待句柄上的任何挂起操作完成之后关闭文件句柄。

import { open } from 'node:fs/promises';

let filehandle;
try {
  filehandle = await open('thefile.txt', 'r');
} finally {
  await filehandle?.close();
} copy

filehandle.createReadStream([options])#

• options <Object>
  • encoding <string> 默认值： null
  • autoClose <boolean> 默认值： true
  • emitClose <boolean> 默认值： true
  • start <integer>
  • end <integer> 默认值： Infinity
  • highWaterMark <integer> 默认值： 64 * 1024
• 返回值： <fs.ReadStream>

与 <stream.Readable> 的 16 KiB 默认 highWaterMark 不同，此方法返回的流的默认 highWaterMark 为 64 KiB。

options 可以包含 start 和 end 值，用于读取文件中的字节范围，而不是整个文件。start 和 end 都是包含的，从 0 开始计数，允许的值在 [0, Number.MAX_SAFE_INTEGER] 范围内。如果省略 start 或 start 为 undefined，filehandle.createReadStream() 将从当前文件位置开始顺序读取。encoding 可以是 <Buffer> 接受的任何一种。

如果 FileHandle 指向仅支持阻塞读取的字符设备（例如键盘或声卡），则读取操作将不会完成，直到数据可用。这可能会阻止进程退出，并阻止流自然关闭。

默认情况下，流将在销毁后发出 'close' 事件。将 emitClose 选项设置为 false 可以更改此行为。

import { open } from 'node:fs/promises';

const fd = await open('/dev/input/event0');
// Create a stream from some character device.
const stream = fd.createReadStream();
setTimeout(() => {
  stream.close(); // This may not close the stream.
  // Artificially marking end-of-stream, as if the underlying resource had
  // indicated end-of-file by itself, allows the stream to close.
  // This does not cancel pending read operations, and if there is such an
  // operation, the process may still not be able to exit successfully
  // until it finishes.
  stream.push(null);
  stream.read(0);
}, 100); copy

如果 autoClose 为 false，则即使发生错误，文件描述符也不会关闭。应用程序有责任关闭它并确保没有文件描述符泄漏。如果 autoClose 设置为 true（默认行为），则在 'error' 或 'end' 时，文件描述符将自动关闭。

读取长度为 100 字节的文件的最后 10 个字节的示例

import { open } from 'node:fs/promises';

const fd = await open('sample.txt');
fd.createReadStream({ start: 90, end: 99 }); copy

filehandle.createWriteStream([options])#

• options <Object>
  • encoding <string> 默认值： 'utf8'
  • autoClose <boolean> 默认值： true
  • emitClose <boolean> 默认值： true
  • start <integer>
  • highWaterMark <number> 默认值： 16384
  • flush <boolean> 如果为 true，则在关闭底层文件描述符之前将其刷新。默认值： false。
• 返回：<fs.WriteStream>

options 还可以包含 start 选项，以允许在文件开头后的某个位置写入数据，允许的值在 [0, Number.MAX_SAFE_INTEGER] 范围内。修改文件而不是替换文件可能需要将 flags open 选项设置为 r+，而不是默认的 r。encoding 可以是 <Buffer> 接受的任何一种。

如果 autoClose 设置为 true（默认行为），则在 'error' 或 'finish' 时，文件描述符将自动关闭。如果 autoClose 为 false，则即使发生错误，文件描述符也不会关闭。应用程序有责任关闭它并确保没有文件描述符泄漏。

默认情况下，流将在销毁后发出 'close' 事件。将 emitClose 选项设置为 false 可以更改此行为。

filehandle.datasync()#

• 返回值： <Promise> 成功时以 undefined 履行。

强制将与文件关联的所有当前排队的 I/O 操作发送到操作系统的同步 I/O 完成状态。有关详细信息，请参阅 POSIX fdatasync(2) 文档。

与 filehandle.sync 不同，此方法不会刷新修改后的元数据。

filehandle.fd#

• <number> 由 <FileHandle> 对象管理的数字文件描述符。

filehandle.read(buffer, offset, length, position)#

• buffer <Buffer> | <TypedArray> | <DataView> 将填充文件读取数据的缓冲区。
• offset <integer> 缓冲区中开始填充的位置。默认值： 0
• length <integer> 要读取的字节数。默认值： buffer.byteLength - offset
• position <integer> | <bigint> | <null> 从文件中开始读取数据的位置。如果为 null 或 -1，则将从当前文件位置读取数据，并且位置将更新。如果 position 是一个非负整数，则当前文件位置将保持不变。默认值：: null
• 返回值：<Promise> 成功时将完成，并具有两个属性的对象
  • bytesRead <integer> 读取的字节数
  • buffer <Buffer> | <TypedArray> | <DataView> 对传入的 buffer 参数的引用。

从文件中读取数据并将其存储在给定的缓冲区中。

如果文件没有同时修改，则当读取的字节数为零时，将到达文件末尾。

filehandle.read([options])#

• options <Object>
  • buffer <Buffer> | <TypedArray> | <DataView> 用于填充读取的文件数据的缓冲区。默认值: Buffer.alloc(16384)
  • offset <integer> 缓冲区中开始填充的位置。默认值： 0
  • length <integer> 要读取的字节数。默认值： buffer.byteLength - offset
  • position <integer> | <bigint> | <null> 从文件中开始读取数据的位置。如果为 null 或 -1，则将从当前文件位置读取数据，并且位置将更新。如果 position 是一个非负整数，则当前文件位置将保持不变。默认值：: null
• 返回值：<Promise> 成功时将完成，并具有两个属性的对象
  • bytesRead <integer> 读取的字节数
  • buffer <Buffer> | <TypedArray> | <DataView> 对传入的 buffer 参数的引用。

从文件中读取数据并将其存储在给定的缓冲区中。

如果文件没有同时修改，则当读取的字节数为零时，将到达文件末尾。

filehandle.read(buffer[, options])#

• buffer <Buffer> | <TypedArray> | <DataView> 将填充文件读取数据的缓冲区。
• options <Object>
  • offset <integer> 缓冲区中开始填充的位置。默认值： 0
  • length <integer> 要读取的字节数。默认值： buffer.byteLength - offset
  • position <integer> | <bigint> | <null> 从文件中开始读取数据的位置。如果为 null 或 -1，则将从当前文件位置读取数据，并且位置将更新。如果 position 是一个非负整数，则当前文件位置将保持不变。默认值：: null
• 返回值：<Promise> 成功时将完成，并具有两个属性的对象
  • bytesRead <integer> 读取的字节数
  • buffer <Buffer> | <TypedArray> | <DataView> 对传入的 buffer 参数的引用。

从文件中读取数据并将其存储在给定的缓冲区中。

如果文件没有同时修改，则当读取的字节数为零时，将到达文件末尾。

filehandle.readableWebStream([options])#

• options <Object>

  • type <string> | <undefined> 是否打开普通流或“字节”流。默认值: undefined

• 返回值: <ReadableStream>

返回一个ReadableStream，可用于读取文件数据。

如果此方法被调用多次或在FileHandle关闭或正在关闭时被调用，则会抛出错误。

import {
  open,
} from 'node:fs/promises';

const file = await open('./some/file/to/read');

for await (const chunk of file.readableWebStream())
  console.log(chunk);

await file.close();const {
  open,
} = require('node:fs/promises');

(async () => {
  const file = await open('./some/file/to/read');

  for await (const chunk of file.readableWebStream())
    console.log(chunk);

  await file.close();
})();copy

虽然ReadableStream会读取完整个文件，但它不会自动关闭FileHandle。用户代码仍然必须调用fileHandle.close()方法。

filehandle.readFile(options)#

• options <Object> | <string>
  • encoding <string> | <null> 默认值: null
  • signal <AbortSignal> 允许中止正在进行的 readFile
• 返回值: <Promise> 成功读取文件内容后完成。如果未指定编码（使用options.encoding），则数据将作为<Buffer>对象返回。否则，数据将为字符串。

异步读取整个文件内容。

如果options是字符串，则它指定encoding。

该 <FileHandle> 必须支持读取。

如果对文件句柄进行了一个或多个 filehandle.read() 调用，然后进行 filehandle.readFile() 调用，则数据将从当前位置读取到文件末尾。它并不总是从文件开头读取。

filehandle.readLines([options])#

• options <Object>
  • encoding <string> 默认值： null
  • autoClose <boolean> 默认值： true
  • emitClose <boolean> 默认值： true
  • start <integer>
  • end <integer> 默认值： Infinity
  • highWaterMark <integer> 默认值： 64 * 1024
• 返回值: <readline.InterfaceConstructor>

便捷方法，用于创建 readline 接口并在文件上进行流式处理。有关选项，请参见 filehandle.createReadStream()。

import { open } from 'node:fs/promises';

const file = await open('./some/file/to/read');

for await (const line of file.readLines()) {
  console.log(line);
}const { open } = require('node:fs/promises');

(async () => {
  const file = await open('./some/file/to/read');

  for await (const line of file.readLines()) {
    console.log(line);
  }
})();copy

filehandle.readv(buffers[, position])#

• buffers <Buffer[]> | <TypedArray[]> | <DataView[]>
• position <integer> | <null> 从文件开头开始读取数据的偏移量。如果 position 不是 number，则数据将从当前位置读取。默认值: null
• 返回值: <Promise> 成功后将完成一个包含两个属性的对象
  • bytesRead <integer> 读取的字节数
  • buffers <Buffer[]> | <TypedArray[]> | <DataView[]> 包含对 buffers 输入的引用的属性。

从文件读取并写入 <ArrayBufferView> 数组。

filehandle.stat([options])#

• options <Object>
  • bigint <boolean> 返回的 <fs.Stats> 对象中的数值是否应为 bigint。默认值： false。
• 返回值：<Promise> 使用 <fs.Stats> 完成对文件的操作。

filehandle.sync()#

• 返回值： <Promise> 成功时以 undefined 履行。

请求将打开的文件描述符的所有数据刷新到存储设备。具体实现取决于操作系统和设备。有关更多详细信息，请参阅 POSIX fsync(2) 文档。

filehandle.truncate(len)#

• len <integer> 默认值： 0
• 返回值： <Promise> 成功时以 undefined 履行。

截断文件。

如果文件大于 len 字节，则仅保留文件中的前 len 字节。

以下示例仅保留文件的前四个字节

import { open } from 'node:fs/promises';

let filehandle = null;
try {
  filehandle = await open('temp.txt', 'r+');
  await filehandle.truncate(4);
} finally {
  await filehandle?.close();
} copy

如果文件以前小于 len 字节，则会扩展它，并且扩展部分将填充空字节 ('\0')

如果 len 为负数，则将使用 0。

filehandle.utimes(atime, mtime)#

• atime <number> | <string> | <Date>
• mtime <number> | <string> | <Date>
• 返回值：<Promise>

更改由 <FileHandle> 引用的对象的系统文件时间戳，然后在成功时使用无参数完成 Promise。

filehandle.write(buffer, offset[, length[, position]])#

• buffer <Buffer> | <TypedArray> | <DataView>
• offset <整数> 从 buffer 中开始写入数据的起始位置。
• length <整数> 从 buffer 中写入的字节数。默认值：buffer.byteLength - offset
• position <整数> | <null> 从文件开头开始写入 buffer 中数据的偏移量。如果 position 不是一个 数字，数据将写入当前位置。有关详细信息，请参阅 POSIX pwrite(2) 文档。默认值：null
• 返回值：<Promise>

将 buffer 写入文件。

该 Promise 将以包含两个属性的对象来完成

• bytesWritten <整数> 写入的字节数
• buffer <Buffer> | <TypedArray> | <DataView> 对写入的 buffer 的引用。

在同一个文件上多次使用 filehandle.write() 而不等待 Promise 完成（或拒绝）是不安全的。对于这种情况，请使用 filehandle.createWriteStream()。

在 Linux 上，当文件以追加模式打开时，位置写入不起作用。内核会忽略位置参数，始终将数据追加到文件末尾。

filehandle.write(buffer[, options])#

• buffer <Buffer> | <TypedArray> | <DataView>
• options <Object>
  • offset <integer> 默认值： 0
  • length <integer> 默认值： buffer.byteLength - offset
  • position <integer> 默认值： null
• 返回值：<Promise>

将 buffer 写入文件。

类似于上面的 filehandle.write 函数，此版本接受一个可选的 options 对象。如果未指定 options 对象，则将使用上述值作为默认值。

filehandle.write(string[, position[, encoding]])#

• string <string>
• position <integer> | <null> 从文件开头开始的偏移量，string 中的数据应写入该偏移量。如果 position 不是 number，则数据将写入当前位置。有关更多详细信息，请参阅 POSIX pwrite(2) 文档。默认值： null
• encoding <string> 预期的字符串编码。默认值： 'utf8'
• 返回值：<Promise>

将 string 写入文件。如果 string 不是字符串，则 promise 会因错误而被拒绝。

该 Promise 将以包含两个属性的对象来完成

• bytesWritten <整数> 写入的字节数
• buffer <string> 对写入的 string 的引用。

在同一个文件上多次使用 filehandle.write() 而不等待 Promise 完成（或拒绝）是不安全的。对于这种情况，请使用 filehandle.createWriteStream()。

在 Linux 上，当文件以追加模式打开时，位置写入不起作用。内核会忽略位置参数，始终将数据追加到文件末尾。

filehandle.writeFile(data, options)#

• data <string> | <Buffer> | <TypedArray> | <DataView> | <AsyncIterable> | <Iterable> | <Stream>
• options <Object> | <string>
  • encoding <string> | <null> 当 data 是字符串时，预期的字符编码。默认值： 'utf8'
• 返回值：<Promise>

异步将数据写入文件，如果文件已存在则替换文件。data 可以是字符串、缓冲区、<AsyncIterable> 或 <Iterable> 对象。promise 成功后将以无参数的形式完成。

如果options是字符串，则它指定encoding。

<FileHandle> 必须支持写入。

在同一个文件上多次使用 filehandle.writeFile() 而不等待 promise 完成（或拒绝）是不安全的。

如果在一个文件句柄上调用了一个或多个 filehandle.write() 方法，然后又调用了 filehandle.writeFile() 方法，那么数据将从当前位置写入到文件末尾。它并不总是从文件开头开始写入。

filehandle.writev(buffers[, position])#

• buffers <Buffer[]> | <TypedArray[]> | <DataView[]>
• position <整数> | <空> 从文件开头开始的偏移量，buffers 中的数据应该写入到该偏移量。如果 position 不是一个 数字，数据将写入到当前位置。默认值： null
• 返回值：<Promise>

将一个 <ArrayBufferView> 数组写入文件。

Promise 将被一个包含两个属性的对象所实现

• bytesWritten <整数> 写入的字节数
• buffers <Buffer[]> | <TypedArray[]> | <DataView[]> 对 buffers 输入的引用。

在同一个文件上多次调用 writev() 而不等待 Promise 实现（或拒绝）是不安全的。

在 Linux 上，当文件以追加模式打开时，位置写入不起作用。内核会忽略位置参数，始终将数据追加到文件末尾。

filehandle[Symbol.asyncDispose]()#

filehandle.close() 的别名。

fsPromises.access(path[, mode])#

• path <字符串> | <Buffer> | <URL>
• mode <整数> 默认值： fs.constants.F_OK
• 返回值： <Promise> 成功时以 undefined 履行。

测试用户对 path 指定的文件或目录的权限。mode 参数是一个可选的整数，它指定要执行的可访问性检查。mode 应该为 fs.constants.F_OK 值，或者由 fs.constants.R_OK、fs.constants.W_OK 和 fs.constants.X_OK 中的任何一个按位或运算组成的掩码（例如 fs.constants.W_OK | fs.constants.R_OK）。查看 文件访问常量 以了解 mode 的可能值。

如果可访问性检查成功，Promise 将实现，没有返回值。如果任何可访问性检查失败，Promise 将被一个 <Error> 对象拒绝。以下示例检查当前进程是否可以读取和写入文件 /etc/passwd。

import { access, constants } from 'node:fs/promises';

try {
  await access('/etc/passwd', constants.R_OK | constants.W_OK);
  console.log('can access');
} catch {
  console.error('cannot access');
} copy

不建议使用 fsPromises.access() 检查文件在调用 fsPromises.open() 之前是否可访问。这样做会引入竞争条件，因为其他进程可能会在两次调用之间更改文件的状态。相反，用户代码应该直接打开/读取/写入文件，并在文件不可访问时处理所引发的错误。

fsPromises.appendFile(path, data[, options])#

• path <string> | <Buffer> | <URL> | <FileHandle> 文件名或 <FileHandle>
• data <string> | <Buffer>
• options <Object> | <string>
  • encoding <string> | <null> 默认： 'utf8'
  • mode <integer> 默认值: 0o666
  • flag <string> 查看 文件系统 flags 的支持。默认值: 'a'。
  • flush <boolean> 如果为 true，则在关闭底层文件描述符之前将其刷新。默认值： false。
• 返回值： <Promise> 成功时以 undefined 履行。

异步地将数据追加到文件，如果文件不存在则创建文件。data 可以是字符串或 <Buffer>。

如果options是字符串，则它指定encoding。

mode 选项仅影响新创建的文件。有关更多详细信息，请参见 fs.open()。

path 可以指定为 <FileHandle>，该文件已打开以进行追加（使用 fsPromises.open()）。

fsPromises.chmod(path, mode)#

• path <字符串> | <Buffer> | <URL>
• mode <string> | <integer>
• 返回值： <Promise> 成功时以 undefined 履行。

更改文件的权限。

fsPromises.chown(path, uid, gid)#

• path <字符串> | <Buffer> | <URL>
• uid <integer>
• gid <integer>
• 返回值： <Promise> 成功时以 undefined 履行。

更改文件的拥有者。

fsPromises.copyFile(src, dest[, mode])#

• src <string> | <Buffer> | <URL> 要复制的源文件名
• dest <string> | <Buffer> | <URL> 复制操作的目标文件名
• mode <integer> 指定复制操作行为的可选修饰符。可以创建由两个或多个值的按位 OR 组成的掩码（例如 fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE）默认值: 0。
  • fs.constants.COPYFILE_EXCL: 如果 dest 已经存在，则复制操作将失败。
  • fs.constants.COPYFILE_FICLONE: 复制操作将尝试创建写时复制 reflink。如果平台不支持写时复制，则使用回退复制机制。
  • fs.constants.COPYFILE_FICLONE_FORCE: 复制操作将尝试创建写时复制 reflink。如果平台不支持写时复制，则操作将失败。
• 返回值： <Promise> 成功时以 undefined 履行。

异步地将 src 复制到 dest。默认情况下，如果 dest 已经存在，则会覆盖它。

不保证复制操作的原子性。如果在目标文件打开写入后发生错误，将尝试删除目标文件。

import { copyFile, constants } from 'node:fs/promises';

try {
  await copyFile('source.txt', 'destination.txt');
  console.log('source.txt was copied to destination.txt');
} catch {
  console.error('The file could not be copied');
}

// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.
try {
  await copyFile('source.txt', 'destination.txt', constants.COPYFILE_EXCL);
  console.log('source.txt was copied to destination.txt');
} catch {
  console.error('The file could not be copied');
} copy

fsPromises.cp(src, dest[, options])#

• src <string> | <URL> 要复制的源路径。
• dest <string> | <URL> 要复制到的目标路径。
• options <Object>
  • dereference <boolean> 解引用符号链接。默认: false。
  • errorOnExist <boolean> 当 force 为 false 且目标存在时，抛出错误。默认: false。
  • filter <Function> 用于过滤复制的文件/目录的函数。返回 true 以复制项目，返回 false 以忽略它。忽略目录时，其所有内容也将被跳过。也可以返回一个解析为 true 或 false 的 Promise。默认: undefined。
    • src <string> 要复制的源路径。
    • dest <string> 要复制到的目标路径。
    • 返回: <boolean> | <Promise>
  • force <boolean> 覆盖现有文件或目录。如果将此设置为 false 并且目标存在，则复制操作将忽略错误。使用 errorOnExist 选项更改此行为。默认值： true。
  • mode <integer> 复制操作的修饰符。默认值： 0。请参阅 fsPromises.copyFile() 的 mode 标志。
  • preserveTimestamps <boolean> 当 true 时，将保留来自 src 的时间戳。默认值： false。
  • recursive <boolean> 递归复制目录 默认值： false
  • verbatimSymlinks <boolean> 当 true 时，将跳过符号链接的路径解析。默认值： false
• 返回值： <Promise> 成功时以 undefined 履行。

异步地将整个目录结构从 src 复制到 dest，包括子目录和文件。

当将目录复制到另一个目录时，不支持 glob，行为类似于 cp dir1/ dir2/。

fsPromises.lchmod(path, mode)#

• path <字符串> | <Buffer> | <URL>
• mode <integer>
• 返回值： <Promise> 成功时以 undefined 履行。

更改符号链接的权限。

此方法仅在 macOS 上实现。

fsPromises.lchown(path, uid, gid)#

• path <字符串> | <Buffer> | <URL>
• uid <integer>
• gid <integer>
• 返回值： <Promise> 成功时以 undefined 履行。

更改符号链接的所有权。

fsPromises.lutimes(path, atime, mtime)#

• path <字符串> | <Buffer> | <URL>
• atime <number> | <string> | <Date>
• mtime <number> | <string> | <Date>
• 返回值： <Promise> 成功时以 undefined 履行。

以与 fsPromises.utimes() 相同的方式更改文件的访问和修改时间，区别在于如果路径引用符号链接，则不会取消引用链接：而是更改符号链接本身的时间戳。

fsPromises.link(existingPath, newPath)#

• existingPath <string> | <Buffer> | <URL>
• newPath <string> | <Buffer> | <URL>
• 返回值： <Promise> 成功时以 undefined 履行。

从 existingPath 到 newPath 创建一个新的链接。有关更多详细信息，请参阅 POSIX link(2) 文档。

fsPromises.lstat(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • bigint <boolean> 返回的 <fs.Stats> 对象中的数值是否应为 bigint。默认值： false。
• 返回值：<Promise> 使用给定符号链接 path 的 <fs.Stats> 对象完成。

等效于 fsPromises.stat()，除非 path 指向符号链接，在这种情况下，链接本身会被统计，而不是它指向的文件。有关更多详细信息，请参阅 POSIX lstat(2) 文档。

fsPromises.mkdir(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <Object> | <integer>
  • recursive <boolean> 默认值： false
  • mode <string> | <integer> 在 Windows 上不支持。默认值： 0o777。
• 返回值：<Promise> 成功后，如果 recursive 为 false，则完成为 undefined，或者如果 recursive 为 true，则完成为创建的第一个目录路径。

异步创建目录。

可选的 options 参数可以是指定 mode（权限和粘性位）的整数，也可以是包含 mode 属性和 recursive 属性的对象，指示是否应该创建父目录。当 path 是一个存在的目录时调用 fsPromises.mkdir() 仅在 recursive 为 false 时导致拒绝。

import { mkdir } from 'node:fs/promises';

try {
  const projectFolder = new URL('./test/project/', import.meta.url);
  const createDir = await mkdir(projectFolder, { recursive: true });

  console.log(`created ${createDir}`);
} catch (err) {
  console.error(err.message);
}const { mkdir } = require('node:fs/promises');
const { join } = require('node:path');

async function makeDirectory() {
  const projectFolder = join(__dirname, 'test', 'project');
  const dirCreation = await mkdir(projectFolder, { recursive: true });

  console.log(dirCreation);
  return dirCreation;
}

makeDirectory().catch(console.error);copy

fsPromises.mkdtemp(prefix[, options])#

• prefix <string> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> 默认值： 'utf8'
• 返回值: <Promise> 解析为一个字符串，包含新创建的临时目录的文件系统路径。

创建一个唯一的临时目录。通过在提供的 prefix 末尾添加六个随机字符来生成一个唯一的目录名称。由于平台不一致，请避免在 prefix 中使用尾随的 X 字符。某些平台（尤其是 BSD）可能会返回超过六个随机字符，并将 prefix 中的尾随 X 字符替换为随机字符。

可选的 options 参数可以是一个指定编码的字符串，或者是一个包含 encoding 属性的对象，该属性指定要使用的字符编码。

import { mkdtemp } from 'node:fs/promises';
import { join } from 'node:path';
import { tmpdir } from 'node:os';

try {
  await mkdtemp(join(tmpdir(), 'foo-'));
} catch (err) {
  console.error(err);
} copy

fsPromises.mkdtemp() 方法会将六个随机选择的字符直接附加到 prefix 字符串中。例如，给定一个目录 /tmp，如果要创建 在 /tmp 内 的临时目录，则 prefix 必须以平台特定的路径分隔符（require('node:path').sep）结尾。

fsPromises.open(path, flags[, mode])#

• path <字符串> | <Buffer> | <URL>
• flags <string> | <number> 请参阅 文件系统 flags 的支持。默认值: 'r'。
• mode <string> | <integer> 如果创建文件，则设置文件模式（权限和粘滞位）。默认值: 0o666（可读可写）
• 返回值: <Promise> 解析为一个 <FileHandle> 对象。

打开一个 <FileHandle>。

有关更多详细信息，请参阅 POSIX open(2) 文档。

某些字符 (< > : " / \ | ? *) 在 Windows 下是保留的，如 命名文件、路径和命名空间 中所述。在 NTFS 下，如果文件名包含冒号，Node.js 将打开一个文件系统流，如 此 MSDN 页面 中所述。

fsPromises.opendir(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • encoding <string> | <null> 默认： 'utf8'
  • bufferSize <number> 从目录读取时内部缓冲的目录条目数。较高的值会导致更好的性能，但内存使用量也会更高。**默认值：** 32
  • recursive <boolean> 解析的 Dir 将是一个 <AsyncIterable>，其中包含所有子文件和目录。**默认值：** false
• 返回：<Promise> 满足一个 <fs.Dir>。

异步打开一个目录以进行迭代扫描。有关更多详细信息，请参阅 POSIX opendir(3) 文档。

创建一个 <fs.Dir>，其中包含所有用于从目录读取和清理目录的进一步函数。

encoding 选项在打开目录和后续读取操作时设置 path 的编码。

使用异步迭代的示例

import { opendir } from 'node:fs/promises';

try {
  const dir = await opendir('./');
  for await (const dirent of dir)
    console.log(dirent.name);
} catch (err) {
  console.error(err);
} copy

使用异步迭代器时，<fs.Dir> 对象将在迭代器退出后自动关闭。

fsPromises.readdir(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> 默认值： 'utf8'
  • withFileTypes <boolean> 默认值： false
  • recursive <boolean> 如果为 true，则递归读取目录的内容。在递归模式下，它将列出所有文件、子文件和目录。默认值： false。
• 返回值：<Promise> 以一个包含目录中所有文件名称的数组形式完成，不包括 '.' 和 '..'。

读取目录的内容。

可选的 options 参数可以是一个指定编码的字符串，或者是一个包含 encoding 属性的对象，用于指定文件名使用的字符编码。如果 encoding 设置为 'buffer'，则返回的文件名将作为 <Buffer> 对象传递。

如果 options.withFileTypes 设置为 true，则返回的数组将包含 <fs.Dirent> 对象。

import { readdir } from 'node:fs/promises';

try {
  const files = await readdir(path);
  for (const file of files)
    console.log(file);
} catch (err) {
  console.error(err);
} copy

fsPromises.readFile(path[, options])#

• path <string> | <Buffer> | <URL> | <FileHandle> 文件名或 FileHandle
• options <Object> | <string>
  • encoding <string> | <null> 默认值: null
  • flag <string> 查看 文件系统 flags 的支持。默认值： 'r'。
  • signal <AbortSignal> 允许中止正在进行的 readFile
• 返回值：<Promise> 以文件内容形式完成。

异步读取整个文件内容。

如果没有指定编码（使用 options.encoding），则数据将作为 <Buffer> 对象返回。否则，数据将是一个字符串。

如果 options 是一个字符串，则它指定编码。

当path是一个目录时，fsPromises.readFile()的行为是平台特定的。在 macOS、Linux 和 Windows 上，promise 将被拒绝并返回错误。在 FreeBSD 上，将返回目录内容的表示。

读取位于运行代码同一目录中的package.json文件的示例

import { readFile } from 'node:fs/promises';
try {
  const filePath = new URL('./package.json', import.meta.url);
  const contents = await readFile(filePath, { encoding: 'utf8' });
  console.log(contents);
} catch (err) {
  console.error(err.message);
}const { readFile } = require('node:fs/promises');
const { resolve } = require('node:path');
async function logFile() {
  try {
    const filePath = resolve('./package.json');
    const contents = await readFile(filePath, { encoding: 'utf8' });
    console.log(contents);
  } catch (err) {
    console.error(err.message);
  }
}
logFile();copy

可以使用<AbortSignal>中止正在进行的readFile。如果请求被中止，返回的 promise 将被拒绝并返回AbortError

import { readFile } from 'node:fs/promises';

try {
  const controller = new AbortController();
  const { signal } = controller;
  const promise = readFile(fileName, { signal });

  // Abort the request before the promise settles.
  controller.abort();

  await promise;
} catch (err) {
  // When a request is aborted - err is an AbortError
  console.error(err);
} copy

中止正在进行的请求不会中止单个操作系统请求，而是中止fs.readFile执行的内部缓冲。

任何指定的<FileHandle>都必须支持读取。

fsPromises.readlink(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> 默认值： 'utf8'
• 返回值：<Promise> 成功时，将使用linkString完成。

读取path所指的符号链接的内容。有关详细信息，请参阅 POSIX readlink(2) 文档。promise 成功时，将使用linkString完成。

可选的options参数可以是指定编码的字符串，也可以是包含指定用于返回的链接路径的字符编码的encoding属性的对象。如果encoding设置为'buffer'，则返回的链接路径将作为<Buffer>对象传递。

fsPromises.realpath(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> 默认值： 'utf8'
• 返回值：<Promise> 成功时，将使用解析后的路径完成。

使用与fs.realpath.native()函数相同的语义确定path的实际位置。

仅支持可以转换为 UTF8 字符串的路径。

可选的options参数可以是指定编码的字符串，也可以是包含指定用于路径的字符编码的encoding属性的对象。如果encoding设置为'buffer'，则返回的路径将作为<Buffer>对象传递。

在 Linux 上，当 Node.js 链接到 musl libc 时，必须将 procfs 文件系统挂载到 /proc 上，才能使此函数正常工作。Glibc 没有此限制。

fsPromises.rename(oldPath, newPath)#

• oldPath <string> | <Buffer> | <URL>
• newPath <string> | <Buffer> | <URL>
• 返回值： <Promise> 成功时以 undefined 履行。

将 oldPath 重命名为 newPath。

fsPromises.rmdir(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • maxRetries <integer> 如果遇到 EBUSY、EMFILE、ENFILE、ENOTEMPTY 或 EPERM 错误，Node.js 会使用线性回退等待时间（每次尝试增加 retryDelay 毫秒）重试操作。此选项表示重试次数。如果 recursive 选项不是 true，则忽略此选项。默认值：0。
  • recursive <boolean> 如果为 true，则执行递归目录删除。在递归模式下，操作会在失败时重试。默认值：false。已弃用。
  • retryDelay <integer> 重试之间等待的时间（毫秒）。如果 recursive 选项不是 true，则忽略此选项。默认值： 100。
• 返回值： <Promise> 成功时以 undefined 履行。

删除由 path 指定的目录。

在文件（而不是目录）上使用 fsPromises.rmdir() 会导致 promise 被拒绝，并在 Windows 上返回 ENOENT 错误，在 POSIX 上返回 ENOTDIR 错误。

要获得类似于 rm -rf Unix 命令的行为，请使用 fsPromises.rm() 以及选项 { recursive: true, force: true }。

fsPromises.rm(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • force <boolean> 如果 path 不存在，当 true 时，将忽略异常。默认值： false。
  • maxRetries <integer> 如果遇到 EBUSY、EMFILE、ENFILE、ENOTEMPTY 或 EPERM 错误，Node.js 将重试操作，每次尝试都会线性退避等待 retryDelay 毫秒。此选项表示重试次数。如果 recursive 选项不是 true，则忽略此选项。默认值： 0。
  • recursive <boolean> 如果 true，则执行递归目录删除。在递归模式下，操作会在失败时重试。默认值： false。
  • retryDelay <integer> 重试之间等待的时间（毫秒）。如果 recursive 选项不是 true，则忽略此选项。默认值： 100。
• 返回值： <Promise> 成功时以 undefined 履行。

删除文件和目录（模拟标准 POSIX rm 实用程序）。

fsPromises.stat(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • bigint <boolean> 返回的 <fs.Stats> 对象中的数值是否应为 bigint。默认值： false。
• 返回：<Promise> 使用给定 path 的 <fs.Stats> 对象来实现。

fsPromises.statfs(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • bigint <boolean> 返回的 <fs.StatFs> 对象中的数值是否应该是 bigint。默认值： false。
• 返回：<Promise> 使用给定 path 的 <fs.StatFs> 对象来实现。

fsPromises.symlink(target, path[, type])#

• target <string> | <Buffer> | <URL>
• path <字符串> | <Buffer> | <URL>
• type <string> | <null> 默认值: null
• 返回值： <Promise> 成功时以 undefined 履行。

创建符号链接。

type 参数仅在 Windows 平台上使用，可以是 'dir'、'file' 或 'junction' 之一。如果 type 参数不是字符串，Node.js 将自动检测 target 类型并使用 'file' 或 'dir'。如果 target 不存在，将使用 'file'。Windows 连接点要求目标路径为绝对路径。当使用 'junction' 时，target 参数将自动规范化为绝对路径。NTFS 卷上的连接点只能指向目录。

fsPromises.truncate(path[, len])#

• path <字符串> | <Buffer> | <URL>
• len <integer> 默认值： 0
• 返回值： <Promise> 成功时以 undefined 履行。

将 path 处内容的长度截断（缩短或扩展）为 len 字节。

fsPromises.unlink(path)#

• path <字符串> | <Buffer> | <URL>
• 返回值： <Promise> 成功时以 undefined 履行。

如果 path 指向符号链接，则删除链接，而不影响该链接指向的文件或目录。如果 path 指向不是符号链接的文件路径，则删除该文件。有关更多详细信息，请参阅 POSIX unlink(2) 文档。

fsPromises.utimes(path, atime, mtime)#

• path <字符串> | <Buffer> | <URL>
• atime <number> | <string> | <Date>
• mtime <number> | <string> | <Date>
• 返回值： <Promise> 成功时以 undefined 履行。

更改由path引用的对象的 文件系统时间戳。

atime 和 mtime 参数遵循以下规则

• 值可以是表示 Unix 纪元时间的数字、Date 或类似 '123456789.0' 的数字字符串。
• 如果值无法转换为数字，或者为 NaN、Infinity 或 -Infinity，则会抛出 Error。

fsPromises.watch(filename[, options])#

• filename <string> | <Buffer> | <URL>
• options <string> | <Object>
  • persistent <boolean> 指示只要正在监视文件，进程是否应该继续运行。默认值： true。
  • recursive <boolean> 指示是否应该监视所有子目录，还是只监视当前目录。这适用于指定目录时，并且仅在支持的平台上（参见 注意事项）。默认值： false。
  • encoding <string> 指定用于传递给侦听器的文件名的字符编码。默认值： 'utf8'。
  • signal <AbortSignal> 一个 <AbortSignal> 用于指示何时应停止监视器。
• 返回值：<AsyncIterator>，包含以下属性的对象
  • eventType <string> 更改类型
  • filename <string> | <Buffer> | <null> 文件名已更改。

返回一个异步迭代器，用于监视 filename 上的更改，其中 filename 是文件或目录。

const { watch } = require('node:fs/promises');

const ac = new AbortController();
const { signal } = ac;
setTimeout(() => ac.abort(), 10000);

(async () => {
  try {
    const watcher = watch(__filename, { signal });
    for await (const event of watcher)
      console.log(event);
  } catch (err) {
    if (err.name === 'AbortError')
      return;
    throw err;
  }
})(); copy

在大多数平台上，'rename' 在目录中出现或消失文件名时发出。

所有针对 fs.watch() 的 注意事项 也适用于 fsPromises.watch()。

fsPromises.writeFile(file, data[, options])#

• file <string> | <Buffer> | <URL> | <FileHandle> 文件名或 FileHandle
• data <string> | <Buffer> | <TypedArray> | <DataView> | <AsyncIterable> | <Iterable> | <Stream>
• options <Object> | <string>
  • encoding <string> | <null> 默认： 'utf8'
  • mode <integer> 默认值: 0o666
  • flag <string> 请参见 文件系统 flags 的支持。默认值： 'w'。
  • flush <boolean> 如果所有数据都成功写入文件，并且 flush 为 true，则使用 filehandle.sync() 来刷新数据。默认值： false。
  • signal <AbortSignal> 允许中止正在进行的 writeFile
• 返回值： <Promise> 成功时以 undefined 履行。

异步将数据写入文件，如果文件已存在，则替换该文件。data 可以是字符串、缓冲区、<AsyncIterable> 或 <Iterable> 对象。

如果 data 是缓冲区，则忽略 encoding 选项。

如果 options 是一个字符串，则它指定编码。

mode 选项仅影响新创建的文件。有关更多详细信息，请参见 fs.open()。

任何指定的 <FileHandle> 都必须支持写入。

在同一个文件上多次使用 fsPromises.writeFile() 而不等待 promise 解决是不安全的。

与 fsPromises.readFile 类似 - fsPromises.writeFile 是一种便利方法，它在内部执行多个 write 调用来写入传递给它的缓冲区。对于性能敏感的代码，请考虑使用 fs.createWriteStream() 或 filehandle.createWriteStream()。

可以使用 <AbortSignal> 取消 fsPromises.writeFile() 操作。取消操作是“尽力而为”，可能仍然会写入部分数据。

import { writeFile } from 'node:fs/promises';
import { Buffer } from 'node:buffer';

try {
  const controller = new AbortController();
  const { signal } = controller;
  const data = new Uint8Array(Buffer.from('Hello Node.js'));
  const promise = writeFile('message.txt', data, { signal });

  // Abort the request before the promise settles.
  controller.abort();

  await promise;
} catch (err) {
  // When a request is aborted - err is an AbortError
  console.error(err);
} copy

中止正在进行的请求不会中止单个操作系统请求，而是中止 fs.writeFile 执行的内部缓冲。

fsPromises.constants#

• <Object>

返回一个包含文件系统操作常用常量的对象。该对象与 fs.constants 相同。有关更多详细信息，请参阅 FS 常量。

回调 API#

回调 API 异步执行所有操作，不会阻塞事件循环，并在完成或错误时调用回调函数。

回调 API 使用底层 Node.js 线程池在事件循环线程之外执行文件系统操作。这些操作不同步或线程安全。在对同一文件执行多个并发修改时，必须小心，否则可能会导致数据损坏。

fs.access(path[, mode], callback)#

• path <字符串> | <Buffer> | <URL>
• mode <整数> 默认值： fs.constants.F_OK
• callback <Function>
  • err <Error>

测试用户对 path 指定的文件或目录的权限。mode 参数是一个可选的整数，它指定要执行的可访问性检查。mode 应该为 fs.constants.F_OK 值，或者由 fs.constants.R_OK、fs.constants.W_OK 和 fs.constants.X_OK 中的任何一个按位或运算组成的掩码（例如 fs.constants.W_OK | fs.constants.R_OK）。查看 文件访问常量 以了解 mode 的可能值。

最后一个参数 callback 是一个回调函数，它将使用可能的错误参数调用。如果任何可访问性检查失败，错误参数将是一个 Error 对象。以下示例检查 package.json 是否存在，以及它是否可读或可写。

import { access, constants } from 'node:fs';

const file = 'package.json';

// Check if the file exists in the current directory.
access(file, constants.F_OK, (err) => {
  console.log(`${file} ${err ? 'does not exist' : 'exists'}`);
});

// Check if the file is readable.
access(file, constants.R_OK, (err) => {
  console.log(`${file} ${err ? 'is not readable' : 'is readable'}`);
});

// Check if the file is writable.
access(file, constants.W_OK, (err) => {
  console.log(`${file} ${err ? 'is not writable' : 'is writable'}`);
});

// Check if the file is readable and writable.
access(file, constants.R_OK | constants.W_OK, (err) => {
  console.log(`${file} ${err ? 'is not' : 'is'} readable and writable`);
}); copy

不要在调用 fs.open()、fs.readFile() 或 fs.writeFile() 之前使用 fs.access() 检查文件的可访问性。这样做会导致竞争条件，因为其他进程可能会在两次调用之间更改文件的状态。相反，用户代码应该直接打开/读取/写入文件，并在文件不可访问时处理引发的错误。

写入（不推荐）

import { access, open, close } from 'node:fs';

access('myfile', (err) => {
  if (!err) {
    console.error('myfile already exists');
    return;
  }

  open('myfile', 'wx', (err, fd) => {
    if (err) throw err;

    try {
      writeMyData(fd);
    } finally {
      close(fd, (err) => {
        if (err) throw err;
      });
    }
  });
}); copy

写入（推荐）

import { open, close } from 'node:fs';

open('myfile', 'wx', (err, fd) => {
  if (err) {
    if (err.code === 'EEXIST') {
      console.error('myfile already exists');
      return;
    }

    throw err;
  }

  try {
    writeMyData(fd);
  } finally {
    close(fd, (err) => {
      if (err) throw err;
    });
  }
}); copy

读取（不推荐）

import { access, open, close } from 'node:fs';
access('myfile', (err) => {
  if (err) {
    if (err.code === 'ENOENT') {
      console.error('myfile does not exist');
      return;
    }

    throw err;
  }

  open('myfile', 'r', (err, fd) => {
    if (err) throw err;

    try {
      readMyData(fd);
    } finally {
      close(fd, (err) => {
        if (err) throw err;
      });
    }
  });
}); copy

读取（推荐）

import { open, close } from 'node:fs';

open('myfile', 'r', (err, fd) => {
  if (err) {
    if (err.code === 'ENOENT') {
      console.error('myfile does not exist');
      return;
    }

    throw err;
  }

  try {
    readMyData(fd);
  } finally {
    close(fd, (err) => {
      if (err) throw err;
    });
  }
}); copy

上面的“不推荐”示例检查可访问性，然后使用文件；“推荐”示例更好，因为它们直接使用文件并处理错误（如果有）。

一般来说，只有在不直接使用文件的情况下才检查文件的可访问性，例如当它的可访问性是来自另一个进程的信号时。

在 Windows 上，目录上的访问控制策略 (ACL) 可能会限制对文件或目录的访问。但是，fs.access() 函数不检查 ACL，因此可能会报告路径可访问，即使 ACL 限制用户读取或写入它。

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

• path <string> | <Buffer> | <URL> | <number> 文件名或文件描述符
• data <string> | <Buffer>
• options <Object> | <string>
  • encoding <string> | <null> 默认： 'utf8'
  • mode <integer> 默认值: 0o666
  • flag <string> 查看 文件系统 flags 的支持。默认值: 'a'。
  • flush <boolean> 如果为 true，则在关闭底层文件描述符之前将其刷新。默认值： false。
• callback <Function>
  • err <Error>

异步地将数据追加到文件，如果文件不存在则创建文件。data 可以是字符串或 <Buffer>。

mode 选项仅影响新创建的文件。有关更多详细信息，请参见 fs.open()。

import { appendFile } from 'node:fs';

appendFile('message.txt', 'data to append', (err) => {
  if (err) throw err;
  console.log('The "data to append" was appended to file!');
}); copy

如果 options 是一个字符串，那么它指定编码

import { appendFile } from 'node:fs';

appendFile('message.txt', 'data to append', 'utf8', callback); copy

path 可以指定为已打开用于追加的数字文件描述符（使用 fs.open() 或 fs.openSync()）。文件描述符不会自动关闭。

import { open, close, appendFile } from 'node:fs';

function closeFd(fd) {
  close(fd, (err) => {
    if (err) throw err;
  });
}

open('message.txt', 'a', (err, fd) => {
  if (err) throw err;

  try {
    appendFile(fd, 'data to append', 'utf8', (err) => {
      closeFd(fd);
      if (err) throw err;
    });
  } catch (err) {
    closeFd(fd);
    throw err;
  }
}); copy

fs.chmod(path, mode, callback)#

• path <字符串> | <Buffer> | <URL>
• mode <string> | <integer>
• callback <Function>
  • err <Error>

异步更改文件的权限。完成回调不会给出除可能的异常之外的其他参数。

有关更多详细信息，请参阅 POSIX chmod(2) 文档。

import { chmod } from 'node:fs';

chmod('my_file.txt', 0o775, (err) => {
  if (err) throw err;
  console.log('The permissions for file "my_file.txt" have been changed!');
}); copy

文件模式#

fs.chmod() 和 fs.chmodSync() 方法中使用的 mode 参数是一个数值位掩码，使用以下常量的逻辑或运算符创建。

构造 mode 的一种更简单的方法是使用三个八进制数字的序列（例如 765）。最左边的数字（示例中的 7）指定文件所有者的权限。中间的数字（示例中的 6）指定组的权限。最右边的数字（示例中的 5）指定其他用户的权限。

例如，八进制值 0o765 表示

• 所有者可以读取、写入和执行该文件。
• 组可以读取和写入该文件。
• 其他用户可以读取和执行该文件。

当使用原始数字来表示文件模式时，任何大于 0o777 的值都可能导致平台特定的行为，这些行为不支持一致地工作。因此，诸如 S_ISVTX、S_ISGID 或 S_ISUID 之类的常量在 fs.constants 中没有公开。

注意事项：在 Windows 上，只能更改写入权限，并且没有实现组、所有者或其他用户的权限之间的区别。

fs.chown(path, uid, gid, callback)#

• path <字符串> | <Buffer> | <URL>
• uid <integer>
• gid <integer>
• callback <Function>
  • err <Error>

异步更改文件的拥有者和组。除了可能的异常之外，不会向完成回调提供任何参数。

有关更多详细信息，请参阅 POSIX chown(2) 文档。

fs.close(fd[, callback])#

• fd <integer>
• callback <Function>
  • err <Error>

关闭文件描述符。完成回调函数不会接收任何参数，除了可能的异常。

对任何当前正在通过其他 fs 操作使用的文件描述符 (fd) 调用 fs.close() 可能会导致未定义的行为。

有关更多详细信息，请参阅 POSIX close(2) 文档。

fs.copyFile(src, dest[, mode], callback)#

• src <string> | <Buffer> | <URL> 要复制的源文件名
• dest <string> | <Buffer> | <URL> 复制操作的目标文件名
• mode <integer> 用于复制操作的修饰符。默认值：0。
• callback <Function>

异步地将 src 复制到 dest。默认情况下，如果 dest 已经存在，它将被覆盖。回调函数不会接收任何参数，除了可能的异常。Node.js 不保证复制操作的原子性。如果在目标文件打开写入后发生错误，Node.js 将尝试删除目标文件。

mode 是一个可选的整数，它指定复制操作的行为。可以创建一个由两个或多个值的按位或运算组成的掩码（例如 fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE）。

• fs.constants.COPYFILE_EXCL: 如果 dest 已经存在，则复制操作将失败。
• fs.constants.COPYFILE_FICLONE: 复制操作将尝试创建写时复制 reflink。如果平台不支持写时复制，则使用回退复制机制。
• fs.constants.COPYFILE_FICLONE_FORCE: 复制操作将尝试创建写时复制 reflink。如果平台不支持写时复制，则操作将失败。

import { copyFile, constants } from 'node:fs';

function callback(err) {
  if (err) throw err;
  console.log('source.txt was copied to destination.txt');
}

// destination.txt will be created or overwritten by default.
copyFile('source.txt', 'destination.txt', callback);

// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.
copyFile('source.txt', 'destination.txt', constants.COPYFILE_EXCL, callback); copy

fs.cp(src, dest[, options], callback)#

• src <string> | <URL> 要复制的源路径。
• dest <string> | <URL> 要复制到的目标路径。
• options <Object>
  • dereference <boolean> 解引用符号链接。默认: false。
  • errorOnExist <boolean> 当 force 为 false 且目标存在时，抛出错误。默认: false。
  • filter <Function> 用于过滤复制的文件/目录的函数。返回 true 以复制项目，返回 false 以忽略它。忽略目录时，其所有内容也将被跳过。也可以返回一个解析为 true 或 false 的 Promise。默认: undefined。
    • src <string> 要复制的源路径。
    • dest <string> 要复制到的目标路径。
    • 返回: <boolean> | <Promise>
  • force <boolean> 覆盖现有文件或目录。如果将此设置为 false 并且目标存在，则复制操作将忽略错误。使用 errorOnExist 选项更改此行为。默认值： true。
  • mode <整数> 用于复制操作的修饰符。默认值： 0。参见 fs.copyFile() 的 mode 标志。
  • preserveTimestamps <boolean> 当 true 时，将保留来自 src 的时间戳。默认值： false。
  • recursive <boolean> 递归复制目录 默认值： false
  • verbatimSymlinks <boolean> 当 true 时，将跳过符号链接的路径解析。默认值： false
• callback <Function>

异步地将整个目录结构从 src 复制到 dest，包括子目录和文件。

当将目录复制到另一个目录时，不支持 glob，行为类似于 cp dir1/ dir2/。

fs.createReadStream(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <string> | <Object>
  • flags <字符串> 参见 文件系统 flags 的支持。默认值： 'r'。
  • encoding <string> 默认值： null
  • fd <整数> | <FileHandle> 默认值： null
  • mode <integer> 默认值: 0o666
  • autoClose <boolean> 默认值： true
  • emitClose <boolean> 默认值： true
  • start <integer>
  • end <integer> 默认值： Infinity
  • highWaterMark <integer> 默认值： 64 * 1024
  • fs <对象> | <空值> 默认值： null
  • signal <AbortSignal> | <空值> 默认值： null
• 返回值： <fs.ReadStream>

与 <stream.Readable> 的 16 KiB 默认 highWaterMark 不同，此方法返回的流的默认 highWaterMark 为 64 KiB。

options 可以包含 start 和 end 值，以从文件中读取字节范围而不是整个文件。start 和 end 都是包含的，从 0 开始计数，允许的值在 [0, Number.MAX_SAFE_INTEGER] 范围内。如果指定了 fd 并且省略了 start 或 start 为 undefined，则 fs.createReadStream() 将从当前文件位置开始顺序读取。encoding 可以是 <Buffer> 接受的任何一个。

如果指定了 fd，ReadStream 将忽略 path 参数，并将使用指定的文件描述符。这意味着不会发出 'open' 事件。fd 应该是阻塞的；非阻塞 fd 应该传递给 <net.Socket>。

如果 fd 指向仅支持阻塞读取的字符设备（例如键盘或声卡），则读取操作在数据可用之前不会完成。这可能会阻止进程退出，并且流无法自然关闭。

默认情况下，流将在销毁后发出 'close' 事件。将 emitClose 选项设置为 false 可以更改此行为。

通过提供 fs 选项，可以覆盖 open、read 和 close 的对应 fs 实现。提供 fs 选项时，需要覆盖 read。如果没有提供 fd，则还需要覆盖 open。如果 autoClose 为 true，则还需要覆盖 close。

import { createReadStream } from 'node:fs';

// Create a stream from some character device.
const stream = createReadStream('/dev/input/event0');
setTimeout(() => {
  stream.close(); // This may not close the stream.
  // Artificially marking end-of-stream, as if the underlying resource had
  // indicated end-of-file by itself, allows the stream to close.
  // This does not cancel pending read operations, and if there is such an
  // operation, the process may still not be able to exit successfully
  // until it finishes.
  stream.push(null);
  stream.read(0);
}, 100); copy

如果 autoClose 为 false，则即使发生错误，文件描述符也不会关闭。应用程序有责任关闭它并确保没有文件描述符泄漏。如果 autoClose 设置为 true（默认行为），则在 'error' 或 'end' 时，文件描述符将自动关闭。

mode 设置文件模式（权限和粘滞位），但前提是文件已创建。

读取长度为 100 字节的文件的最后 10 个字节的示例

import { createReadStream } from 'node:fs';

createReadStream('sample.txt', { start: 90, end: 99 }); copy

如果 options 是一个字符串，则它指定编码。

fs.createWriteStream(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <string> | <Object>
  • flags <string> 请参阅 文件系统 flags 的支持。默认值： 'w'。
  • encoding <string> 默认值： 'utf8'
  • fd <整数> | <FileHandle> 默认值： null
  • mode <integer> 默认值: 0o666
  • autoClose <boolean> 默认值： true
  • emitClose <boolean> 默认值： true
  • start <integer>
  • fs <对象> | <空值> 默认值： null
  • signal <AbortSignal> | <空值> 默认值： null
  • highWaterMark <number> 默认值： 16384
  • flush <boolean> 如果为 true，则在关闭底层文件描述符之前将其刷新。默认值： false。
• 返回：<fs.WriteStream>

options 还可以包含 start 选项，以允许在文件开头后的某个位置写入数据，允许的值在 [0, Number.MAX_SAFE_INTEGER] 范围内。修改文件而不是替换文件可能需要将 flags 选项设置为 r+ 而不是默认的 w。encoding 可以是 <Buffer> 接受的任何一种。

如果 autoClose 设置为 true（默认行为），则在 'error' 或 'finish' 时，文件描述符将自动关闭。如果 autoClose 为 false，则即使发生错误，文件描述符也不会关闭。应用程序有责任关闭它并确保没有文件描述符泄漏。

默认情况下，流将在销毁后发出 'close' 事件。将 emitClose 选项设置为 false 可以更改此行为。

通过提供 fs 选项，可以覆盖 open、write、writev 和 close 的对应 fs 实现。覆盖 write() 而不覆盖 writev() 会降低性能，因为某些优化（_writev()）将被禁用。提供 fs 选项时，需要至少覆盖 write 或 writev 之一。如果没有提供 fd 选项，则还需要覆盖 open。如果 autoClose 为 true，则还需要覆盖 close。

与 <fs.ReadStream> 一样，如果指定了 fd，<fs.WriteStream> 将忽略 path 参数，并将使用指定的 文件描述符。这意味着不会发出 'open' 事件。fd 应该是阻塞的；非阻塞 fd 应该传递给 <net.Socket>。

如果 options 是一个字符串，则它指定编码。

fs.exists(path, callback)#

• path <字符串> | <Buffer> | <URL>
• callback <Function>
  • exists <boolean>

通过检查文件系统来测试给定路径是否存在。然后使用 true 或 false 调用 callback 参数。

import { exists } from 'node:fs';

exists('/etc/passwd', (e) => {
  console.log(e ? 'it exists' : 'no passwd!');
}); copy

此回调的参数与其他 Node.js 回调不一致。 通常，Node.js 回调的第一个参数是 err 参数，后面可以选择其他参数。fs.exists() 回调只有一个布尔参数。这是推荐使用 fs.access() 而不是 fs.exists() 的原因之一。

不建议使用 fs.exists() 检查文件是否存在，然后再调用 fs.open()、fs.readFile() 或 fs.writeFile()。这样做会引入竞争条件，因为其他进程可能会在两次调用之间更改文件的状态。相反，用户代码应该直接打开/读取/写入文件，并处理如果文件不存在而引发的错误。

写入（不推荐）

import { exists, open, close } from 'node:fs';

exists('myfile', (e) => {
  if (e) {
    console.error('myfile already exists');
  } else {
    open('myfile', 'wx', (err, fd) => {
      if (err) throw err;

      try {
        writeMyData(fd);
      } finally {
        close(fd, (err) => {
          if (err) throw err;
        });
      }
    });
  }
}); copy

写入（推荐）

import { open, close } from 'node:fs';
open('myfile', 'wx', (err, fd) => {
  if (err) {
    if (err.code === 'EEXIST') {
      console.error('myfile already exists');
      return;
    }

    throw err;
  }

  try {
    writeMyData(fd);
  } finally {
    close(fd, (err) => {
      if (err) throw err;
    });
  }
}); copy

读取（不推荐）

import { open, close, exists } from 'node:fs';

exists('myfile', (e) => {
  if (e) {
    open('myfile', 'r', (err, fd) => {
      if (err) throw err;

      try {
        readMyData(fd);
      } finally {
        close(fd, (err) => {
          if (err) throw err;
        });
      }
    });
  } else {
    console.error('myfile does not exist');
  }
}); copy

读取（推荐）

import { open, close } from 'node:fs';

open('myfile', 'r', (err, fd) => {
  if (err) {
    if (err.code === 'ENOENT') {
      console.error('myfile does not exist');
      return;
    }

    throw err;
  }

  try {
    readMyData(fd);
  } finally {
    close(fd, (err) => {
      if (err) throw err;
    });
  }
}); copy

上面的“不推荐”示例检查是否存在，然后使用文件；“推荐”示例更好，因为它们直接使用文件并处理错误（如果有）。

一般来说，只有在不直接使用文件的情况下才检查文件是否存在，例如当文件的存在是来自另一个进程的信号时。

fs.fchmod(fd, mode, callback)#

• fd <integer>
• mode <string> | <integer>
• callback <Function>
  • err <Error>

设置文件的权限。除了可能的异常之外，不会向完成回调传递其他参数。

有关更多详细信息，请参阅 POSIX fchmod(2) 文档。

fs.fchown(fd, uid, gid, callback)#

• fd <integer>
• uid <integer>
• gid <integer>
• callback <Function>
  • err <Error>

设置文件的所有者。除了可能的异常之外，不会向完成回调提供任何参数。

有关更多详细信息，请参阅 POSIX fchown(2) 文档。

fs.fdatasync(fd, callback)#

• fd <integer>
• callback <Function>
  • err <Error>

强制所有当前与文件关联的排队 I/O 操作进入操作系统的同步 I/O 完成状态。有关详细信息，请参阅 POSIX fdatasync(2) 文档。除了可能的异常之外，不会向完成回调提供任何参数。

fs.fstat(fd[, options], callback)#

• fd <integer>
• options <Object>
  • bigint <boolean> 返回的 <fs.Stats> 对象中的数值是否应为 bigint。默认值： false。
• callback <Function>
  • err <Error>
  • stats <fs.Stats>

使用文件描述符的 <fs.Stats> 调用回调。

有关更多详细信息，请参阅 POSIX fstat(2) 文档。

fs.fsync(fd, callback)#

• fd <integer>
• callback <Function>
  • err <Error>

请求将打开文件描述符的所有数据刷新到存储设备。具体实现取决于操作系统和设备。有关更多详细信息，请参阅 POSIX fsync(2) 文档。除了可能的异常之外，不会向完成回调提供任何参数。

fs.ftruncate(fd[, len], callback)#

• fd <integer>
• len <integer> 默认值： 0
• callback <Function>
  • err <Error>

截断文件描述符。除了可能的异常之外，不会向完成回调提供任何参数。

有关更多详细信息，请参阅 POSIX ftruncate(2) 文档。

如果文件描述符引用的文件大于 len 字节，则文件中将仅保留前 len 字节。

例如，以下程序仅保留文件的前四个字节

import { open, close, ftruncate } from 'node:fs';

function closeFd(fd) {
  close(fd, (err) => {
    if (err) throw err;
  });
}

open('temp.txt', 'r+', (err, fd) => {
  if (err) throw err;

  try {
    ftruncate(fd, 4, (err) => {
      closeFd(fd);
      if (err) throw err;
    });
  } catch (err) {
    closeFd(fd);
    if (err) throw err;
  }
}); copy

如果文件以前小于 len 字节，则会扩展它，并且扩展部分将填充空字节 ('\0')

如果 len 为负数，则将使用 0。

fs.futimes(fd, atime, mtime, callback)#

• fd <integer>
• atime <number> | <string> | <Date>
• mtime <number> | <string> | <Date>
• callback <Function>
  • err <Error>

更改由提供的文件描述符引用的对象的 文件系统时间戳。请参阅 fs.utimes()。

fs.lchmod(path, mode, callback)#

• path <字符串> | <Buffer> | <URL>
• mode <integer>
• callback <Function>
  • err <Error> | <AggregateError>

更改符号链接的权限。除了可能的异常之外，不会向完成回调提供任何参数。

此方法仅在 macOS 上实现。

有关更多详细信息，请参阅 POSIX lchmod(2) 文档。

fs.lchown(path, uid, gid, callback)#

• path <字符串> | <Buffer> | <URL>
• uid <integer>
• gid <integer>
• callback <Function>
  • err <Error>

设置符号链接的所有者。除了可能的异常之外，不会向完成回调提供任何参数。

有关更多详细信息，请参阅 POSIX lchown(2) 文档。

fs.lutimes(path, atime, mtime, callback)#

• path <字符串> | <Buffer> | <URL>
• atime <number> | <string> | <Date>
• mtime <number> | <string> | <Date>
• callback <Function>
  • err <Error>

以与 fs.utimes() 相同的方式更改文件的访问时间和修改时间，区别在于，如果路径引用符号链接，则不会取消引用链接：而是更改符号链接本身的时间戳。

除了可能的异常之外，不会向完成回调提供任何参数。

fs.link(existingPath, newPath, callback)#

• existingPath <string> | <Buffer> | <URL>
• newPath <string> | <Buffer> | <URL>
• callback <Function>
  • err <Error>

从 existingPath 到 newPath 创建一个新的链接。有关更多详细信息，请参阅 POSIX link(2) 文档。除了可能的异常之外，不会向完成回调提供任何参数。

fs.lstat(path[, options], callback)#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • bigint <boolean> 返回的 <fs.Stats> 对象中的数值是否应为 bigint。默认值： false。
• callback <Function>
  • err <Error>
  • stats <fs.Stats>

检索由路径引用的符号链接的 <fs.Stats>。回调获取两个参数 (err, stats)，其中 stats 是一个 <fs.Stats> 对象。lstat() 与 stat() 相同，区别在于如果 path 是一个符号链接，则会对链接本身进行 stat 操作，而不是它所引用的文件。

有关更多详细信息，请参阅 POSIX lstat(2) 文档。

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

• path <字符串> | <Buffer> | <URL>
• options <Object> | <integer>
  • recursive <boolean> 默认值： false
  • mode <string> | <integer> 在 Windows 上不支持。默认值： 0o777。
• callback <Function>
  • err <Error>
  • path <string> | <undefined> 仅当使用 recursive 设置为 true 创建目录时才存在。

异步创建目录。

回调会提供一个可能的异常，如果 recursive 为 true，则会提供第一个创建的目录路径 (err[, path])。如果 recursive 为 true 但没有创建目录（例如，如果它之前已创建），则 path 仍然可以为 undefined。

可选的 options 参数可以是一个整数，指定 mode（权限和粘性位），也可以是一个对象，该对象具有 mode 属性和 recursive 属性，指示是否应创建父目录。当 path 是一个已存在的目录时调用 fs.mkdir() 仅在 recursive 为 false 时会导致错误。如果 recursive 为 false 且目录存在，则会发生 EEXIST 错误。

import { mkdir } from 'node:fs';

// Create ./tmp/a/apple, regardless of whether ./tmp and ./tmp/a exist.
mkdir('./tmp/a/apple', { recursive: true }, (err) => {
  if (err) throw err;
}); copy

在 Windows 上，即使使用递归，在根目录上使用 fs.mkdir() 也会导致错误。

import { mkdir } from 'node:fs';

mkdir('/', { recursive: true }, (err) => {
  // => [Error: EPERM: operation not permitted, mkdir 'C:\']
}); copy

有关更多详细信息，请参阅 POSIX mkdir(2) 文档。

fs.mkdtemp(prefix[, options], callback)#

• prefix <string> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> 默认值： 'utf8'
• callback <Function>
  • err <Error>
  • directory <string>

创建一个唯一的临时目录。

生成六个随机字符，附加到所需的 prefix 后面，以创建一个唯一的临时目录。由于平台不一致，请避免在 prefix 中使用尾随的 X 字符。某些平台（尤其是 BSD）可能会返回超过六个随机字符，并将 prefix 中的尾随 X 字符替换为随机字符。

创建的目录路径作为字符串传递给回调的第二个参数。

可选的 options 参数可以是一个指定编码的字符串，或者是一个包含 encoding 属性的对象，该属性指定要使用的字符编码。

import { mkdtemp } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';

mkdtemp(join(tmpdir(), 'foo-'), (err, directory) => {
  if (err) throw err;
  console.log(directory);
  // Prints: /tmp/foo-itXde2 or C:\Users\...\AppData\Local\Temp\foo-itXde2
}); copy

fs.mkdtemp() 方法会将六个随机选择的字符直接附加到 prefix 字符串。例如，给定一个目录 /tmp，如果要创建 位于 /tmp 内部的临时目录，则 prefix 必须以平台特定的路径分隔符（require('node:path').sep）结尾。

import { tmpdir } from 'node:os';
import { mkdtemp } from 'node:fs';

// The parent directory for the new temporary directory
const tmpDir = tmpdir();

// This method is *INCORRECT*:
mkdtemp(tmpDir, (err, directory) => {
  if (err) throw err;
  console.log(directory);
  // Will print something similar to `/tmpabc123`.
  // A new temporary directory is created at the file system root
  // rather than *within* the /tmp directory.
});

// This method is *CORRECT*:
import { sep } from 'node:path';
mkdtemp(`${tmpDir}${sep}`, (err, directory) => {
  if (err) throw err;
  console.log(directory);
  // Will print something similar to `/tmp/abc123`.
  // A new temporary directory is created within
  // the /tmp directory.
}); copy

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

• path <字符串> | <Buffer> | <URL>
• flags <string> | <number> 请参阅 文件系统 flags 的支持。默认值: 'r'。
• mode <string> | <integer> 默认值： 0o666（可读可写）
• callback <Function>
  • err <Error>
  • fd <integer>

异步文件打开。有关更多详细信息，请参阅 POSIX open(2) 文档。

mode 设置文件模式（权限和粘滞位），但前提是文件已创建。在 Windows 上，只能操作写入权限；请参阅 fs.chmod()。

回调获取两个参数 (err, fd)。

某些字符 (< > : " / \ | ? *) 在 Windows 下是保留的，如 命名文件、路径和命名空间 中所述。在 NTFS 下，如果文件名包含冒号，Node.js 将打开一个文件系统流，如 此 MSDN 页面 中所述。

基于 fs.open() 的函数也表现出这种行为：fs.writeFile()、fs.readFile() 等。

fs.openAsBlob(path[, options])#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • type <string> Blob 的可选 MIME 类型。
• 返回值：<Promise> 成功后将使用 <Blob> 完成。

返回一个 <Blob>，其数据由给定文件支持。

在创建 <Blob> 之后，不得修改文件。任何修改都将导致读取 <Blob> 数据失败，并出现 DOMException 错误。在创建 Blob 时以及在每次读取之前，对文件进行同步状态操作，以检测文件数据是否已在磁盘上修改。

import { openAsBlob } from 'node:fs';

const blob = await openAsBlob('the.file.txt');
const ab = await blob.arrayBuffer();
blob.stream();const { openAsBlob } = require('node:fs');

(async () => {
  const blob = await openAsBlob('the.file.txt');
  const ab = await blob.arrayBuffer();
  blob.stream();
})();copy

fs.opendir(path[, options], callback)#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • encoding <string> | <null> 默认： 'utf8'
  • bufferSize <number> 从目录读取时内部缓冲的目录条目数。较高的值会导致更好的性能，但内存使用量也会更高。**默认值：** 32
  • recursive <boolean> 默认值： false
• callback <Function>
  • err <Error>
  • dir <fs.Dir>

异步打开目录。有关更多详细信息，请参阅 POSIX opendir(3) 文档。

创建一个 <fs.Dir>，其中包含所有用于从目录读取和清理目录的进一步函数。

encoding 选项在打开目录和后续读取操作时设置 path 的编码。

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

• fd <integer>
• buffer <Buffer> | <TypedArray> | <DataView> 将写入数据的缓冲区。
• offset <integer> 在 buffer 中写入数据的起始位置。
• length <integer> 要读取的字节数。
• position <integer> | <bigint> | <null> 指定从文件中的哪个位置开始读取。如果 position 为 null 或 -1，则将从当前文件位置读取数据，并且文件位置将更新。如果 position 是一个非负整数，则文件位置将保持不变。
• callback <Function>
  • err <Error>
  • bytesRead <integer>
  • buffer <Buffer>

从 fd 指定的文件中读取数据。

回调将给出三个参数，(err, bytesRead, buffer)。

如果文件没有同时修改，则当读取的字节数为零时，将到达文件末尾。

如果此方法被调用为其 util.promisify() 版本，它将返回一个包含 bytesRead 和 buffer 属性的 Object 的 Promise。

fs.read(fd[, options], callback)#

• fd <integer>
• options <Object>
  • buffer <Buffer> | <TypedArray> | <DataView> 默认值： Buffer.alloc(16384)
  • offset <integer> 默认值： 0
  • length <integer> 默认值： buffer.byteLength - offset
  • position <整数> | <bigint> | <null> 默认值： null
• callback <Function>
  • err <Error>
  • bytesRead <integer>
  • buffer <Buffer>

类似于 fs.read() 函数，此版本接受一个可选的 options 对象。如果未指定 options 对象，它将使用上述值作为默认值。

fs.read(fd, buffer[, options], callback)#

• fd <integer>
• buffer <Buffer> | <TypedArray> | <DataView> 将写入数据的缓冲区。
• options <Object>
  • offset <integer> 默认值： 0
  • length <integer> 默认值： buffer.byteLength - offset
  • position <整数> | <bigint> 默认值： null
• callback <Function>
  • err <Error>
  • bytesRead <integer>
  • buffer <Buffer>

类似于 fs.read() 函数，此版本接受一个可选的 options 对象。如果未指定 options 对象，它将使用上述值作为默认值。

fs.readdir(path[, options], callback)#

• path <字符串> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> 默认值： 'utf8'
  • withFileTypes <boolean> 默认值： false
  • recursive <布尔值> 如果为 true，则递归读取目录的内容。在递归模式下，它将列出所有文件、子文件和目录。默认值： false。
• callback <Function>
  • err <Error>
  • files <字符串数组> | <Buffer 数组> | <fs.Dirent 数组>

读取目录的内容。回调函数接收两个参数 `(err, files)`，其中 `files` 是一个包含目录中所有文件名的数组，不包括 `'.'` 和 `'..' `。

有关更多详细信息，请参阅 POSIX readdir(3) 文档。

可选的 `options` 参数可以是一个指定编码的字符串，或者是一个包含 `encoding` 属性的对象，该属性指定用于传递给回调函数的文件名的字符编码。如果 `encoding` 设置为 `'buffer'`，则返回的文件名将作为 <Buffer> 对象传递。

如果 `options.withFileTypes` 设置为 `true`，则 `files` 数组将包含 <fs.Dirent> 对象。

fs.readFile(path[, options], callback)#

• path <string> | <Buffer> | <URL> | <integer> 文件名或文件描述符
• options <Object> | <string>
  • encoding <string> | <null> 默认值: null
  • flag <string> 查看 文件系统 flags 的支持。默认值： 'r'。
  • signal <AbortSignal> 允许中止正在进行的 readFile
• callback <Function>
  • err <Error> | <AggregateError>
  • data <string> | <Buffer>

异步读取整个文件内容。

import { readFile } from 'node:fs';

readFile('/etc/passwd', (err, data) => {
  if (err) throw err;
  console.log(data);
}); copy

回调函数传递两个参数 `(err, data)`，其中 `data` 是文件的内容。

如果没有指定编码，则返回原始缓冲区。

如果 options 是一个字符串，那么它指定编码

import { readFile } from 'node:fs';

readFile('/etc/passwd', 'utf8', callback); copy

当路径是目录时，`fs.readFile()` 和 fs.readFileSync() 的行为是平台特定的。在 macOS、Linux 和 Windows 上，将返回错误。在 FreeBSD 上，将返回目录内容的表示。

import { readFile } from 'node:fs';

// macOS, Linux, and Windows
readFile('<directory>', (err, data) => {
  // => [Error: EISDIR: illegal operation on a directory, read <directory>]
});

//  FreeBSD
readFile('<directory>', (err, data) => {
  // => null, <data>
}); copy

可以使用 `AbortSignal` 中止正在进行的请求。如果请求被中止，则回调函数将使用 `AbortError` 调用。

import { readFile } from 'node:fs';

const controller = new AbortController();
const signal = controller.signal;
readFile(fileInfo[0].name, { signal }, (err, buf) => {
  // ...
});
// When you want to abort the request
controller.abort(); copy

fs.readFile() 函数缓冲整个文件。为了最大程度地减少内存成本，在可能的情况下，优先使用 `fs.createReadStream()` 进行流式传输。

中止正在进行的请求不会中止单个操作系统请求，而是中止fs.readFile执行的内部缓冲。

文件描述符#

1. 任何指定的文件描述符都必须支持读取。
2. 如果将文件描述符指定为 `path`，则不会自动关闭它。
3. 读取将从当前位置开始。例如，如果文件已经包含'Hello World'，并且使用文件描述符读取了六个字节，那么使用相同文件描述符调用fs.readFile()将返回'World'，而不是'Hello World'。

性能注意事项#

fs.readFile()方法异步地将文件内容一次读取到内存中，允许事件循环在每个块之间切换。这使得读取操作对可能正在使用底层libuv线程池的其他活动的影响较小，但也意味着将完整文件读取到内存中需要更长的时间。

额外的读取开销在不同的系统上可能会有很大的差异，并且取决于正在读取的文件类型。如果文件类型不是普通文件（例如管道），并且Node.js无法确定实际的文件大小，则每次读取操作将加载64 KiB的数据。对于普通文件，每次读取将处理512 KiB的数据。

对于需要尽可能快地读取文件内容的应用程序，最好直接使用fs.read()，并让应用程序代码自己管理读取文件的完整内容。

Node.js GitHub问题#25741提供了更多信息，以及对不同Node.js版本中fs.readFile()在多种文件大小下的性能的详细分析。

fs.readlink(path[, options], callback)#

• path <字符串> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> 默认值： 'utf8'
• callback <Function>
  • err <Error>
  • linkString <string> | <Buffer>

读取path所指的符号链接的内容。回调函数接收两个参数(err, linkString)。

有关更多详细信息，请参阅POSIX readlink(2) 文档。

可选的options参数可以是一个字符串，指定编码，也可以是一个包含encoding属性的对象，用于指定传递给回调函数的链接路径的字符编码。如果encoding设置为'buffer'，则返回的链接路径将作为<Buffer>对象传递。

fs.readv(fd, buffers[, position], callback)#

• fd <integer>
• buffers <ArrayBufferView[]>
• position <整数> | <null> 默认值: null
• callback <Function>
  • err <Error>
  • bytesRead <integer>
  • buffers <ArrayBufferView[]>

从 fd 指定的文件中读取数据，并使用 readv() 写入 ArrayBufferView 数组。

position 是从文件开头开始读取数据的偏移量。如果 typeof position !== 'number'，则将从当前位置读取数据。

回调函数将接收三个参数：err、bytesRead 和 buffers。bytesRead 是从文件中读取的字节数。

如果此方法以其 util.promisify() 版本调用，它将返回一个包含 bytesRead 和 buffers 属性的 Object 的 Promise。

fs.realpath(path[, options], callback)#

• path <字符串> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> 默认值： 'utf8'
• callback <Function>
  • err <Error>
  • resolvedPath <字符串> | <Buffer>

通过解析 .、.. 和符号链接来异步计算规范路径。

规范路径不一定是唯一的。硬链接和绑定挂载可以通过多个路径名公开文件系统实体。

此函数的行为类似于 realpath(3)，但有一些例外。

1. 在不区分大小写的文件系统上不执行大小写转换。

2. 符号链接的最大数量与平台无关，通常（远）高于本机 realpath(3) 实现支持的数量。

callback 获取两个参数 (err, resolvedPath)。可以使用 process.cwd 来解析相对路径。

仅支持可以转换为 UTF8 字符串的路径。

可选的 options 参数可以是指定编码的字符串，也可以是包含 encoding 属性的对象，该属性指定传递给回调的路径使用的字符编码。如果 encoding 设置为 'buffer'，则返回的路径将作为 <Buffer> 对象传递。

如果 path 解析为套接字或管道，则该函数将返回该对象的系统相关名称。

fs.realpath.native(path[, options], callback)#

• path <字符串> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> 默认值： 'utf8'
• callback <Function>
  • err <Error>
  • resolvedPath <字符串> | <Buffer>

异步 realpath(3).

callback 获取两个参数 (err, resolvedPath)。

仅支持可以转换为 UTF8 字符串的路径。

可选的 options 参数可以是指定编码的字符串，也可以是包含 encoding 属性的对象，该属性指定传递给回调的路径使用的字符编码。如果 encoding 设置为 'buffer'，则返回的路径将作为 <Buffer> 对象传递。

在 Linux 上，当 Node.js 链接到 musl libc 时，必须将 procfs 文件系统挂载到 /proc 上，才能使此函数正常工作。Glibc 没有此限制。

fs.rename(oldPath, newPath, callback)#

• oldPath <string> | <Buffer> | <URL>
• newPath <string> | <Buffer> | <URL>
• callback <Function>
  • err <Error>

异步地将 oldPath 处的文件重命名为 newPath 提供的路径名。如果 newPath 已经存在，它将被覆盖。如果 newPath 处存在目录，则会引发错误。除了可能的异常之外，不会向完成回调提供其他参数。

另请参见：rename(2).

import { rename } from 'node:fs';

rename('oldFile.txt', 'newFile.txt', (err) => {
  if (err) throw err;
  console.log('Rename complete!');
}); copy

fs.rmdir(path[, options], callback)#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • maxRetries <integer> 如果遇到 EBUSY、EMFILE、ENFILE、ENOTEMPTY 或 EPERM 错误，Node.js 会使用线性回退等待时间（每次尝试增加 retryDelay 毫秒）重试操作。此选项表示重试次数。如果 recursive 选项不是 true，则忽略此选项。默认值：0。
  • recursive <boolean> 如果为 true，则执行递归目录删除。在递归模式下，操作会在失败时重试。默认值：false。已弃用。
  • retryDelay <integer> 重试之间等待的时间（毫秒）。如果 recursive 选项不是 true，则忽略此选项。默认值： 100。
• callback <Function>
  • err <Error>

异步 rmdir(2)。除了可能的异常之外，不会向完成回调提供其他参数。

在文件（而不是目录）上使用 fs.rmdir() 会导致 Windows 上的 ENOENT 错误和 POSIX 上的 ENOTDIR 错误。

要获得类似于 rm -rf Unix 命令的行为，请使用 fs.rm() 以及选项 { recursive: true, force: true }。

fs.rm(path[, options], callback)#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • force <boolean> 如果 path 不存在，当 true 时，将忽略异常。默认值： false。
  • maxRetries <integer> 如果遇到 EBUSY、EMFILE、ENFILE、ENOTEMPTY 或 EPERM 错误，Node.js 将重试操作，每次尝试都会线性退避等待 retryDelay 毫秒。此选项表示重试次数。如果 recursive 选项不是 true，则忽略此选项。默认值： 0。
  • recursive <boolean> 如果为 true，则执行递归删除。在递归模式下，操作会在失败时重试。默认值： false。
  • retryDelay <integer> 重试之间等待的时间（毫秒）。如果 recursive 选项不是 true，则忽略此选项。默认值： 100。
• callback <Function>
  • err <Error>

异步删除文件和目录（以标准 POSIX rm 实用程序为模型）。除了可能的异常之外，不会向完成回调提供任何参数。

fs.stat(path[, options], callback)#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • bigint <boolean> 返回的 <fs.Stats> 对象中的数值是否应为 bigint。默认值： false。
• callback <Function>
  • err <Error>
  • stats <fs.Stats>

异步 stat(2)。回调获取两个参数 (err, stats)，其中 stats 是一个 <fs.Stats> 对象。

如果发生错误，err.code 将是 常见系统错误 之一。

fs.stat() 遵循符号链接。使用 fs.lstat() 查看链接本身。

不建议使用 fs.stat() 在调用 fs.open()、fs.readFile() 或 fs.writeFile() 之前检查文件是否存在。相反，用户代码应直接打开/读取/写入文件，并处理在文件不可用时引发的错误。

要检查文件是否存在而不进行后续操作，建议使用 fs.access()。

例如，给定以下目录结构

- txtDir
-- file.txt
- app.js copy

下一个程序将检查给定路径的统计信息

import { stat } from 'node:fs';

const pathsToCheck = ['./txtDir', './txtDir/file.txt'];

for (let i = 0; i < pathsToCheck.length; i++) {
  stat(pathsToCheck[i], (err, stats) => {
    console.log(stats.isDirectory());
    console.log(stats);
  });
} copy

结果输出将类似于

true
Stats {
  dev: 16777220,
  mode: 16877,
  nlink: 3,
  uid: 501,
  gid: 20,
  rdev: 0,
  blksize: 4096,
  ino: 14214262,
  size: 96,
  blocks: 0,
  atimeMs: 1561174653071.963,
  mtimeMs: 1561174614583.3518,
  ctimeMs: 1561174626623.5366,
  birthtimeMs: 1561174126937.2893,
  atime: 2019-06-22T03:37:33.072Z,
  mtime: 2019-06-22T03:36:54.583Z,
  ctime: 2019-06-22T03:37:06.624Z,
  birthtime: 2019-06-22T03:28:46.937Z
}
false
Stats {
  dev: 16777220,
  mode: 33188,
  nlink: 1,
  uid: 501,
  gid: 20,
  rdev: 0,
  blksize: 4096,
  ino: 14214074,
  size: 8,
  blocks: 8,
  atimeMs: 1561174616618.8555,
  mtimeMs: 1561174614584,
  ctimeMs: 1561174614583.8145,
  birthtimeMs: 1561174007710.7478,
  atime: 2019-06-22T03:36:56.619Z,
  mtime: 2019-06-22T03:36:54.584Z,
  ctime: 2019-06-22T03:36:54.584Z,
  birthtime: 2019-06-22T03:26:47.711Z
} copy

fs.statfs(path[, options], callback)#

• path <字符串> | <Buffer> | <URL>
• options <Object>
  • bigint <boolean> 返回的 <fs.StatFs> 对象中的数值是否应该是 bigint。默认值： false。
• callback <Function>
  • err <Error>
  • stats <fs.StatFs>

异步 statfs(2)。返回有关包含 path 的已挂载文件系统的信息。回调获取两个参数 (err, stats)，其中 stats 是一个 <fs.StatFs> 对象。

如果发生错误，err.code 将是 常见系统错误 之一。

fs.symlink(target, path[, type], callback)#

• target <string> | <Buffer> | <URL>
• path <字符串> | <Buffer> | <URL>
• type <string> | <null> 默认值: null
• callback <Function>
  • err <Error>

创建名为 path 的链接，指向 target。除了可能的异常之外，不会向完成回调提供任何参数。

有关更多详细信息，请参阅 POSIX symlink(2) 文档。

type 参数仅在 Windows 上可用，在其他平台上会被忽略。它可以设置为 'dir'、'file' 或 'junction'。如果 type 参数不是字符串，Node.js 将自动检测 target 类型并使用 'file' 或 'dir'。如果 target 不存在，将使用 'file'。Windows 连接点要求目标路径为绝对路径。使用 'junction' 时，target 参数将自动规范化为绝对路径。NTFS 卷上的连接点只能指向目录。

相对目标相对于链接的父目录。

import { symlink } from 'node:fs';

symlink('./mew', './mewtwo', callback); copy

上面的示例创建了一个符号链接 mewtwo，它指向同一目录中的 mew

$ tree .
.
├── mew
└── mewtwo -> ./mew copy

fs.truncate(path[, len], callback)#

• path <字符串> | <Buffer> | <URL>
• len <integer> 默认值： 0
• callback <Function>
  • err <Error> | <AggregateError>

截断文件。除了可能的异常之外，不会向完成回调提供任何参数。文件描述符也可以作为第一个参数传递。在这种情况下，将调用 fs.ftruncate()。

import { truncate } from 'node:fs';
// Assuming that 'path/file.txt' is a regular file.
truncate('path/file.txt', (err) => {
  if (err) throw err;
  console.log('path/file.txt was truncated');
});const { truncate } = require('node:fs');
// Assuming that 'path/file.txt' is a regular file.
truncate('path/file.txt', (err) => {
  if (err) throw err;
  console.log('path/file.txt was truncated');
});copy

传递文件描述符已弃用，将来可能会导致抛出错误。

有关更多详细信息，请参阅 POSIX truncate(2) 文档。

fs.unlink(path, callback)#

• path <字符串> | <Buffer> | <URL>
• callback <Function>
  • err <Error>

异步删除文件或符号链接。除了可能的异常之外，不会向完成回调提供任何参数。

import { unlink } from 'node:fs';
// Assuming that 'path/file.txt' is a regular file.
unlink('path/file.txt', (err) => {
  if (err) throw err;
  console.log('path/file.txt was deleted');
}); copy

fs.unlink() 不会在目录上工作，无论是否为空。要删除目录，请使用 fs.rmdir().

有关更多详细信息，请参阅 POSIX unlink(2) 文档。

fs.unwatchFile(filename[, listener])#

• filename <string> | <Buffer> | <URL>
• listener <Function> 可选，先前使用 fs.watchFile() 附加的监听器

停止监视 filename 上的更改。如果指定了 listener，则仅删除该特定监听器。否则，将删除所有监听器，有效地停止监视 filename。

使用未被监视的文件名调用 fs.unwatchFile() 是一个无操作，而不是错误。

使用 fs.watch() 比 fs.watchFile() 和 fs.unwatchFile() 更有效。fs.watch() 应在可能的情况下代替 fs.watchFile() 和 fs.unwatchFile() 使用。

fs.utimes(path, atime, mtime, callback)#

• path <字符串> | <Buffer> | <URL>
• atime <number> | <string> | <Date>
• mtime <number> | <string> | <Date>
• callback <Function>
  • err <Error>

更改由path引用的对象的 文件系统时间戳。

atime 和 mtime 参数遵循以下规则

• 值可以是表示以秒为单位的 Unix 时间戳的数字、Date 对象或类似 '123456789.0' 的数字字符串。
• 如果值无法转换为数字，或者为 NaN、Infinity 或 -Infinity，则会抛出 Error。

fs.watch(filename[, options][, listener])#