Synchronous API

2024年10月14日

柏拉文

越努力，越幸运

一、access(path[, mode])

认识

access(path[, mode]) 测试用户对 path 指定的文件或目录的权限。 mode 参数是可选的整数，指定要执行的可访问性检查。

使用规范

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

语法

const error = fs.accessSync(path,mode);

path: string|buffer|url
mode: number 默认值: fs.constants.F_OK
- fs.constants.F_OK: 是否存在
- fs.constants.R_OK: 是否可读
- fs.constants.W_OK: 是否可写
- fs.constants.W_OK | fs.constants.R_OK: 是否可读可写

返回值

如果任何可访问性检查失败，将抛出 Error。否则，该方法将返回 undefined。

场景

const Fs = require("fs");

const error = Fs.accessSync("./test.js", Fs.constants.R_OK | Fs.constants.W_OK);
if (error) {
  console.log(error);
}

回调方式

语法

fs.access(file,mode,(error)=>{
  console.log(error)
})

file: string|buffer|url
mode: number 默认值: fs.constants.F_OK
- fs.constants.F_OK: 是否存在
- fs.constants.R_OK: 是否可读
- fs.constants.W_OK: 是否可写
- fs.constants.W_OK | fs.constants.R_OK: 是否可读可写
callback: function

场景

检测当前目录中是否存在该文件

const Fs = require("fs");

Fs.access('./test.js',Fs.constants.F_OK,(error)=>{
  console.log('error',error) // error null 表示文件存在
});

检查文件是否可读

const Fs = require("fs");

Fs.access('./test.js',Fs.constants.R_OK,(error)=>{
  console.log('error',error) // error null
});

检查文件是否可写

const Fs = require("fs");

Fs.access('./test.js',Fs.constants.W_OK,(error)=>{
  console.log('error',error) // error null
});

检查文件是否可读可写

const Fs = require("fs");

Fs.access('./test.js',Fs.constants.W_OK | Fs.constants.R_OK,(error)=>{
  console.log('error',error) // error null
});

Promise 方式

语法

await access(path:string|buffer|url,mode:number)

path: string|buffer|url
mode: number 默认值: fs.constants.F_OK 。mode 应该是值fs.constants.F_OK 或由 fs.constants.R_OK、fs.constants.W_OK 和 fs.constants. X_OK 中的任何一个
- fs.constants.F_OK: 是否存在
- fs.constants.R_OK: 是否可读
- fs.constants.W_OK: 是否可写
- fs.constants.X_OK: 是否可读可写

场景

const Fs = require("fs");

async function access() {
  let filehandle = null;
  try {
    await Fs.promises.access("./test.js",Fs.constants.F_OK);
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

access();

appendFile(data[, options])

appendFile() 用于在现有文件中异步追加新数据，或者如果该文件不存在，则首先创建该文件，然后将给定数据追加到该文件中。

使用规范

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

同步方式

语法

fs.appendFileSync(path,data,{
  encoding:string|null,
  mode:number,
  flag:string
});

path: string|buffer|url|number
data: string|buffer
encoding: string|null 默认值: 'utf8'
mode: number 默认值: 0o666
flag: string 默认值: 'a'
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。

场景

const Fs = require("fs");

Fs.appendFileSync("./test.js", "我不想不想长大", {
  encoding: "utf8",
  flag: "a",
});

回调方式

语法

fs.appendFile(path,data,{
  encoding:string|null,
  mode:number,
  flag:string,
},(error)=>{
  console.log(error)
});

path: string|buffer|url|number
data: string|buffer
encoding: string|null 默认值: 'utf8'
mode: number 默认值: 0o666
flag: string 默认值: 'a'。
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。

返回值

undefined

场景

const Fs = require("fs");

Fs.appendFile(
  "./test.js",
  "越努力，越幸运",
  {
    encoding: "utf8",
  },
  (error) => {
    console.log(error);
  }
);

Promise 方式

语法

await fs.promises.appendFile(path:string|buffer|url|fileHandle,data:string|buffer,{
  encoding: string|null,
  mode: number,
  flag: string
});

path: string|buffer|url|fileHandle
data: string|buffer
encoding: string|null 默认值: 'utf8'
mode: number 默认值: 0o666
flag: string 默认值: 'a'。
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。

返回值

undefined

场景

const Fs = require("fs");

async function appendFile() {
  let filehandle = null;
  try {
    await Fs.promises.appendFile("./test.js","哈哈哈哈哈",{
      encoding:"utf8"
    });
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

appendFile();

FileHandle 类方式

语法

filehandle.appendFile(data: string|buffer|typeArray|dataView|asyncIterable|stream|iterable,options: {
    encoding: string|null 
})

encoding: string|null, 默认值为 "utf8"

场景

const Fs = require('fs');

async function append(path,content){
    let filehandle = null;
    try{
        filehandle = await Fs.promises.open(path,mode='a');
        await filehandle.appendFile(content);
    }catch(error){
        console.log(error);
    }finally{
        await filehandle?.close();
    }
}

append('./test.js','哈哈哈');

chmod(mode)

chmod 更改文件的权限。

同步方式

语法

fs.chmodSync(path,mode);

path: string|buffer|url
mode: string|number
- fs.constants.S_IRUSR: 0o400 所有者可读取
- fs.constants.S_IWUSR: 0o200 所有者可写入
- fs.constants.S_IXUSR: 0o100 所有者可执行/搜索
- fs.constants.S_IRGRP: 0o40 群组可读取
- fs.constants.S_IWGRP: 0o20 群组可写入
- fs.constants.S_IXGRP: 0o10 群组可执行/搜索
- fs.constants.S_IROTH: 0o4 其他人可读取
- fs.constants.S_IWOTH: 0o2 其他人可写入
- fs.constants.S_IXOTH: 0o1 其他人可执行/搜索
- 0oA(左边八进制: 表示文件所有者的权限)B(中间八进制: 表示群组的权限)C(右边八进制: 指定其他人的权限),八进制数字含义如下:
  - 7: 可读、可写和可执行
  - 6: 可读和可写
  - 5: 可读和可执行
  - 4: 只读
  - 3: 可写和可执行
  - 2: 只写
  - 1: 只可执行
  - 0: 无权限
  - 0o765: 所有者可以读取、写入、以及执行文件。群组可以读取和写入文件。其他人可以读取和执行文件。

场景

回调方式

语法

Fs.chmod(path,mode,(error)=>{
  console.log(error);
})

path: string|buffer|url
mode: string|number
- fs.constants.S_IRUSR: 0o400 所有者可读取
- fs.constants.S_IWUSR: 0o200 所有者可写入
- fs.constants.S_IXUSR: 0o100 所有者可执行/搜索
- fs.constants.S_IRGRP: 0o40 群组可读取
- fs.constants.S_IWGRP: 0o20 群组可写入
- fs.constants.S_IXGRP: 0o10 群组可执行/搜索
- fs.constants.S_IROTH: 0o4 其他人可读取
- fs.constants.S_IWOTH: 0o2 其他人可写入
- fs.constants.S_IXOTH: 0o1 其他人可执行/搜索
- 0oA(左边八进制: 表示文件所有者的权限)B(中间八进制: 表示群组的权限)C(右边八进制: 指定其他人的权限),八进制数字含义如下:
  - 7: 可读、可写和可执行
  - 6: 可读和可写
  - 5: 可读和可执行
  - 4: 只读
  - 3: 可写和可执行
  - 2: 只写
  - 1: 只可执行
  - 0: 无权限
  - 0o765: 所有者可以读取、写入、以及执行文件。群组可以读取和写入文件。其他人可以读取和执行文件。
callback: function

场景

const Fs = require("fs");

Fs.chmod("./test",0o775,(error)=>{
  if(error){
    console.log(error)
  }
})

Promise 方式

语法

await fs.promises.chmod(path,mode);

path: string|buffer|url
mode: string|number
- fs.constants.S_IRUSR: 0o400 所有者可读取
- fs.constants.S_IWUSR: 0o200 所有者可写入
- fs.constants.S_IXUSR: 0o100 所有者可执行/搜索
- fs.constants.S_IRGRP: 0o40 群组可读取
- fs.constants.S_IWGRP: 0o20 群组可写入
- fs.constants.S_IXGRP: 0o10 群组可执行/搜索
- fs.constants.S_IROTH: 0o4 其他人可读取
- fs.constants.S_IWOTH: 0o2 其他人可写入
- fs.constants.S_IXOTH: 0o1 其他人可执行/搜索
- 0oA(左边八进制: 表示文件所有者的权限)B(中间八进制: 表示群组的权限)C(右边八进制: 指定其他人的权限),八进制数字含义如下:
  - 7: 可读、可写和可执行
  - 6: 可读和可写
  - 5: 可读和可执行
  - 4: 只读
  - 3: 可写和可执行
  - 2: 只写
  - 1: 只可执行
  - 0: 无权限
  - 0o765: 所有者可以读取、写入、以及执行文件。群组可以读取和写入文件。其他人可以读取和执行文件。

FileHandle 类方式

语法

await fileHandle.chmod(mode)

mode: string|number
- fs.constants.S_IRUSR: 0o400 所有者可读取
- fs.constants.S_IWUSR: 0o200 所有者可写入
- fs.constants.S_IXUSR: 0o100 所有者可执行/搜索
- fs.constants.S_IRGRP: 0o40 群组可读取
- fs.constants.S_IWGRP: 0o20 群组可写入
- fs.constants.S_IXGRP: 0o10 群组可执行/搜索
- fs.constants.S_IROTH: 0o4 其他人可读取
- fs.constants.S_IWOTH: 0o2 其他人可写入
- fs.constants.S_IXOTH: 0o1 其他人可执行/搜索
- 0oA(左边八进制: 表示文件所有者的权限)B(中间八进制: 表示群组的权限)C(右边八进制: 指定其他人的权限),八进制数字含义如下:
  - 7: 可读、可写和可执行
  - 6: 可读和可写
  - 5: 可读和可执行
  - 4: 只读
  - 3: 可写和可执行
  - 2: 只写
  - 1: 只可执行
  - 0: 无权限
  - 0o765: 所有者可以读取、写入、以及执行文件。群组可以读取和写入文件。其他人可以读取和执行文件。

chown(path,uid,gid)

chown(path,uid,gid) 更改文件的所有权。

同步方式

语法

fs.chownSync(path,uid,gid);

path: string|buffer|url
uid: number
gid: number

回调方式

语法

fs.chown(path,uid,gid,(error)=>{
  if(error){
    console.log(error)
  }
})

path: string|buffer|url
uid: number
gid: number
callback: function

场景

Promise 方式

语法

await fs.promises.chown(path:string|buffer|url,uid:number,gid:number);

path: string|buffer|url
uid: number
gid: number

返回值

undefined

FileHandle 类方式

语法

await fileHandle.chown(uid:number,gid:number);

uid: number
gid: number

返回值

undefined

close()

close() 等待句柄上的任何未决操作完成后，关闭文件句柄。

同步方式

语法

fs.closeSync(fd);

fd: number 文件描述符

回调方式

语法

fs.close(fd,(error)=>{
  if(error){
    console.log(error);
  }
})

fd: number 文件描述符
callback: function

场景

FileHandle 类方式

语法

const Fs = require('fs');

async function close(){
    let filehandle;
    try{
        filehandle = await Fs.promise.open('test.js','r');
    }catch(error){
        console.log(error);
    }finally{
        await filehandle?.close();
    }
}

copyFile(src,dest[,mode])

copyFile(src, dest[, mode]) 异步地将 src 复制到 dest。默认情况下，如果 dest 已经存在，则会被覆盖。

同步方式

语法

fs.copyFileSync(src,desc,mode);

src: string|buffer|url 要复制的源文件名
dest: string|buffer|url 复制操作的目标文件名
mode: number 复制操作的修饰符。默认值: 0。mode 是可选的整数，用于指定复制操作的行为。可以创建由两个或多个值的按位或组成的掩码
- fs.constants.COPYFILE_EXCL: 如果 dest 已经存在，则复制操作将失败。
- fs.constants.COPYFILE_FICLONE: 复制操作将尝试创建写时复制引用链接。如果平台不支持写时复制，则使用后备复制机制。
- fs.constants.COPYFILE_FICLONE_FORCE: 复制操作将尝试创建写时复制引用链接。如果平台不支持写时复制，则该操作将失败。
- fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE:

场景

创建或者覆盖

const Fs = require("fs");

Fs.copyFileSync("./test.js", "./testCopy.js");

创建或者操作失败

const Fs = require("fs");

Fs.copyFileSync("./test.js", "./testCopy.js", Fs.constants.COPYFILE_EXCL);

回调方式

语法

fs.copyFile(src,dest,mode,(error)=>{
  if(error){
    console.log(error);
  }
})

src: string|buffer|url 要复制的源文件名
dest: string|buffer|url 复制操作的目标文件名
mode: number 复制操作的修饰符。默认值: 0。mode 是可选的整数，用于指定复制操作的行为。可以创建由两个或多个值的按位或组成的掩码
- fs.constants.COPYFILE_EXCL: 如果 dest 已经存在，则复制操作将失败。
- fs.constants.COPYFILE_FICLONE: 复制操作将尝试创建写时复制引用链接。如果平台不支持写时复制，则使用后备复制机制。
- fs.constants.COPYFILE_FICLONE_FORCE: 复制操作将尝试创建写时复制引用链接。如果平台不支持写时复制，则该操作将失败。
- fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE:
callback: function

场景

如果dest不存在或者dest已经存在，那么直接创建或者覆盖

const Fs = require("fs");

Fs.copyFile("./test.js","./testCopy.js",(error)=>{
  if(error){
    console.log(error);
  }
})

如果dest已经存在，则复制操作将失败

const Fs = require("fs");

Fs.copyFile("./test.js","./testCopy.js",Fs.constants.COPYFILE_EXCL,(error)=>{
  if(error){
    console.log(error);
  }
})

Promise 方式

语法

await fs.promises.copyFile(src:string|buffer|url,dest:string|buffer|url,mode:number)

src: string|buffer|url 要复制的源文件名
dest: string|buffer|url 复制操作的目标文件名
mode: number 指定复制操作行为的可选修饰符。可以创建由两个或多个值的按位或组成的掩码（例如 fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE）默认值: 0。
- fs.constants.COPYFILE_EXCL: 如果 dest 已经存在，则复制操作将失败。
- fs.constants.COPYFILE_FICLONE: 复制操作将尝试创建写时复制引用链接。如果平台不支持写时复制，则使用后备复制机制。
- fs.constants.COPYFILE_FICLONE_FORCE: 复制操作将尝试创建写时复制引用链接。如果平台不支持写时复制，则该操作将失败。

返回值

undefined

场景

const Fs = require("fs");

async function copyFile() {
  let filehandle = null;
  try {
    await Fs.promises.copyFile("./test.js","./testCopy.js");
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

copyFile();

cp(src,dest[,options])

cp(src,dest[,options]) 将整个目录结构从 src 异步地复制到 dest，包括子目录和文件。

同步方式

语法

fs.cpSync(src,dest,{
  dereference: boolean,
  errorOnExist: boolean,
  filter: function,
  force: boolean,
  preserveTimestamps: boolean,
  recursive: boolean,
  verbatimSymlinks: boolean
});

src: string|url 要复制的源路径。
dest: string|url 要复制到的目标路径。
dereference: boolean 取消引用符号链接。默认值: false。
errorOnExist: boolean 当 force 为 false 且目标存在时，则抛出错误。默认值: false。
filter: function 过滤复制文件/目录的函数。返回 true 则复制条目，返回 false 则忽略它。也可以返回解决为 true 或 false 的 Promise 默认值: undefined。
force: boolean 覆盖现有的文件或目录。如果将此设置为 false 并且目标存在，则复制操作将忽略错误。使用 errorOnExist 选项更改此行为。默认值: true。
preserveTimestamps: boolean 当为 true 时，则 src 的时间戳将被保留。默认值: false。
recursive: boolean 递归地复制目录默认值: false
verbatimSymlinks: boolean 当为 true 时，则符号链接的路径解析将被跳过。默认值: false

场景

const Fs = require("fs");

Fs.cpSync("./test", "./testNew", {
  recursive: true,
});

回调方式

语法

fs.cp(src,dest,{
  dereference: boolean,
  errorOnExist: boolean,
  filter: function,
  force: boolean,
  preserveTimestamps: boolean,
  recursive: boolean,
  verbatimSymlinks: boolean
},(error)=>{
  if(error){
    console.log(error);
  }
})

dereference: boolean 取消引用符号链接。默认值: false。
errorOnExist: boolean 当 force 为 false 且目标存在时，则抛出错误。默认值: false。
filter: function 过滤复制文件/目录的函数。返回 true 则复制条目，返回 false 则忽略它。也可以返回解决为 true 或 false 的 Promise 默认值: undefined。
force: boolean 覆盖现有的文件或目录。如果将此设置为 false 并且目标存在，则复制操作将忽略错误。使用 errorOnExist 选项更改此行为。默认值: true。
preserveTimestamps: boolean 当为 true 时，则 src 的时间戳将被保留。默认值: false。
recursive: boolean 递归地复制目录默认值: false
verbatimSymlinks: boolean 当为 true 时，则符号链接的路径解析将被跳过。默认值: false

场景

const Fs = require("fs");

Fs.cp(
  "../test",
  "../testCopy",
  {
    force: true,
    recursive: true,
  },
  (error) => {
    if (error) {
      console.log(error);
    }
  }
);

Promise 方式

语法

await fs.promises.cp(src:string|url,dest:string|url,{
  dereference: boolean,
  errorOnExist: boolean,
  filter: function,
  force: boolean,
  preserveTimestamps: boolean,
  recursive: boolean 
  verbatimSymlinks: boolean
})

dereference: boolean 取消引用符号链接。默认值: false。
errorOnExist: boolean 当 force 为 false 且目标存在时，则抛出错误。默认值: false。
filter: function 过滤复制文件/目录的函数。返回 true 则复制条目，返回 false 则忽略它。也可以返回解决为 true 或 false 的 Promise 默认值: undefined。
force: boolean 覆盖现有的文件或目录。如果将此设置为 false 并且目标存在，则复制操作将忽略错误。使用 errorOnExist 选项更改此行为。默认值: true。
preserveTimestamps: boolean 当为 true 时，则 src 的时间戳将被保留。默认值: false。
recursive: boolean 递归地复制目录默认值: false
verbatimSymlinks: boolean 当为 true 时，则符号链接的路径解析将被跳过。默认值: false

返回值

场景

const Fs = require("fs");

async function cp() {
  let filehandle = null;
  try {
    await Fs.promises.cp("/Users/zhangwenqiang/Desktop/practice/Node/node-api","/Users/zhangwenqiang/Desktop/practice/Node/node-api-copy");
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

cp();

createReadStream([options])

回调方式

语法

const readStream = fs.createReadStream(path,{
  flags: string,
  encoding: string,
  fd: number|fileHandle,
  mode: number,
  autoClose: boolean,
  emitClose: boolean,
  start: number,
  end: number,
  highWaterMark: number,
  fs: object|null
});

path: string|buffer|url
flags: string, 默认值: 'r'。
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。
encoding: string,
fd: number|fileHandle,
mode: number,
autoClose: boolean,
emitClose: boolean,
start: number,
end: number,
highWaterMark: number,
fs: object|null

返回值

返回fs.ReadStream

场景

const Fs = require("fs");

function handleReadStream(readStream) {
  return new Promise((resolve, reject) => {
    readStream.on("open", () => {
      console.log("open");
    });
    readStream.on("data", (chunk) => {
      console.log("data", chunk);
    });
    readStream.on("error", (error) => {
      console.log("error", error);
      reject(error);
    });
    readStream.on("close", () => {
      console.log("close");
      resolve();
    });
    readStream.on("end", () => {
      console.log("end");
      readStream.close();
    });
  });
}

const readStream = Fs.createReadStream("./test.js", {
  end: 10,
  encoding: "utf8",
});
handleReadStream(readStream);

FileHandle 类方式

语法

const readStream = filehandle.createReadStream({
    encoding:string, 
    autoClose:boolean, 
    emitClose:boolean,
    start:number, 
    end:number, 
    highWaterMark:number
})

encoding: string, 默认值为 null
autoClose: boolean, 默认值为 true
emitClose: boolean, 默认值为 true
start: number
end: number, 默认值为 Infinity
highWaterMark: number 默认值为 64*1024

返回值

返回Fs.ReadStream

场景

const Fs = require("fs");

function handleReadStream(readStream) {
  return new Promise((resolve, reject) => {
    readStream.on("open", () => {
      console.log("open");
    });
    readStream.on("data", (chunk) => {
      console.log("data", chunk);
    });
    readStream.on("error", (error) => {
      console.log("error", error);
      reject(error)
    });
    readStream.on("close", () => {
      console.log("close");
      resolve();
    });
    readStream.on("end", () => {
      console.log("end");
      readStream.close();
    });
  });
}

async function createReadStream() {
  let filehandle = null;
  try {
    filehandle = await Fs.promises.open("./test.js");
    const readStream = await filehandle.createReadStream({
      start: 0,
      encoding: "utf8",
    });
    await handleReadStream(readStream)
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

createReadStream();

createWriteStream(path[, options])

回调方式

语法

const writeStream = fs.createWriteStream(path,{
  flags:string,
  encoding:string,
  fd:number|fileHandle,
  mode:number,
  autoClose:boolean,
  emitClose:boolean,
  start:number,
  fs:object|null
});

path:string|buffer|url
flags:string, 默认值: 'w'。
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。
encoding:string, 默认值: 'utf8'
fd:number|fileHandle, 默认值: null
mode:number, 默认值: 0o666
autoClose:boolean, 默认值: true
emitClose:boolean, 默认值: true
start:number,
fs:object|null 默认值: null

场景

无论之前是否存在文件，直接写入并替换

const Fs = require("fs");

function handleWriteStream(writeStream) {
  return new Promise((resolve, reject) => {
    writeStream.on("open", () => {
      console.log("open");
      writeStream.write("哈哈哈哈哈哈哈");
    });
    writeStream.on("data", (chunk) => {
      console.log("data", chunk);
    });
    writeStream.on("error", (error) => {
      console.log("error", error);
      reject(error)
    });
    writeStream.on("close", () => {
      console.log("close");
      resolve();
    });
    writeStream.on("end", () => {
      console.log("end");
      writeStream.close();
    });
  });
}
const writeStream = Fs.createWriteStream("./test.js",{
  flags:"w",
  encoding:"utf8"
});
handleWriteStream(writeStream);

如果之前存在文件，那么在原有的内容上修改

const Fs = require("fs");

function handleWriteStream(writeStream) {
  return new Promise((resolve, reject) => {
    writeStream.on("open", () => {
      console.log("open");
      writeStream.write("嘻嘻嘻");
    });
    writeStream.on("data", (chunk) => {
      console.log("data", chunk);
    });
    writeStream.on("error", (error) => {
      console.log("error", error);
      reject(error)
    });
    writeStream.on("close", () => {
      console.log("close");
      resolve();
    });
    writeStream.on("end", () => {
      console.log("end");
      writeStream.close();
    });
  });
}
const writeStream = Fs.createWriteStream("./test.js",{
  flags:"r+",
  encoding:"utf8",
  start:8
});
handleWriteStream(writeStream);

datasync()

datasync() 将与文件关联的所有当前排队的I/O操作强制为操作系统的同步I/O完成状态。

exists()

exists() 如果路径存在则返回 true，否则返回 false。

同步方式

语法

fs.existsSync(path);

path: string|buffer|url

返回值

返回一个boolean,如果路径存在则返回 true，否则返回 false。

场景

const Fs = require("fs");

const isExists = Fs.existsSync("./test");
console.log(isExists);

fchmod(fd, mode, callback)

fchmod(fd, mode, callback) 设置文件的权限。

同步方式

语法

fs.fchmodSync(fd,mode);

fd: number
mode: string|number

回调方式

语法

fs.fchmod(fd,mode,(error)=>{
  console.log(error);
})

fd: number
mode: string|number
callback: function

fchown(fd, uid, gid, callback)

fchown(fd, uid, gid, callback) 设置文件的所有者

同步方式

语法

fs.fchownSync(fd, uid, gid);

fd: number
uid: number
gid: number

回调方式

语法

fs.fchown(fd,uid,gid,(error)=>{
  console.log(error);
})

fd: number
uid: number
gid: number
callback: function

fd

fd 对象管理的数字文件描述符。

fdatasync(fd, callback)

fdatasync(fd, callback) 将与文件关联的所有当前排队的 I/O 操作强制为操作系统的同步 I/O 完成状态。

同步方式

语法

fs.fdatasyncSync(fd)

fd: number

回调方式

语法

fs.fdatasync(fd,(error)=>{
  console.log(error);
});

fd: number
callback: function

fstat(fd[, options], callback)

fstat(fd[, options], callback) 使用文件描述符的 fs.Stats 调用回调。

同步方式

语法

fs.fstatSync(fd,{
  bigint: boolean
})

fd: number
bigint: boolean 返回的 fs.Stats 对象中的数值是否应为 bigint。默认值: false。

Promise 方式

语法

fs.fstat(fd,{
  bigint: boolean
},(error,stats)=>{
  if(error){
    console.log(error);
    return 
  }
  console.log(stats);
});

fd: number
bigint: boolean 返回的 fs.Stats 对象中的数值是否应为 bigint。默认值: false。
callback: function

fsync(fd, callback)

fsync(fd, callback) 请求将打开文件描述符的所有数据刷新到存储设备。具体实现是操作系统和设备特定的。

同步方式

语法

fs.fsyncSync(fd);

fd: number

回调方式

语法

fs.fsync(fd,(error)=>{
  if(error){
    console.log(error);
  }
});

fd: number
callback: function

ftruncate(fd[, len], callback)

ftruncate(fd[, len], callback) 截断文件描述符。

同步方式

语法

fs.ftruncateSync(fd,len);

fd: number
len: number 默认值: 0

回调方式

语法

fs.ftruncate(fd,len, (error)=>{
  console.log(error);
})

fd: number
len: number 默认值: 0

场景

const Fs = require("fs");

Fs.open("./test.js","r+",(error,fd)=>{
  if(error){
    console.log(error);
    return 
  }
  try{ 
    Fs.ftruncate(fd,4,(error_inner)=>{
      if(error_inner){
        console.log(error_inner);
        return 
      }
    });
  }catch(error){
    console.log(error);
  }finally{
    Fs.close(fd);
  }
})

futimes(fd, atime, mtime, callback)

futimes(fd, atime, mtime, callback) 更改提供的文件描述符引用的对象的文件系统时间戳。

同步方式

语法

fs.futimesSync(fd, atime, mtime)

fd: number
atime: number|string|date
mtime: number|string|date
callback: function

回调方式

语法

fs.futimes(fd,atime,mtime,(error)=>{
  if(error){
    console.log(error);
  }
});

fd: number
atime: number|string|date
mtime: number|string|date
callback: function

lchmod(path, mode, callback)

lchmod(path, mode, callback) 更改符号链接的权限。

同步方式

语法

fs.lchmodSync(path, mode)

path: string|buffer|url
mode: number
callback: function

回调方式

语法

fs.lchmod(path,mode,(error)=>{
  console.log(error);
});

path: string|buffer|url
mode: number
callback: function

lchown(path, uid, gid)

lchown(path, uid, gid) 更改符号链接上的所有权

同步方式

语法

fs.lchownSync(path, uid, gid)

path: string|buffer|url
uid: number
gid: number
callback: function

回调方式

语法

fs.lchown(path,uid,gid,(error)=>{
  console.log(error);
});

path: string|buffer|url
uid: number
gid: number
callback: function

Promise 方式

语法

await fs.promises.lchown(path:string|buffer|url,uid:number,gid:number)

path: string | Buffer | URL
uid: number
gid: number

lutimes(path, atime, mtime)

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

同步方式

语法

fs.lutimesSync(path, atime, mtime)

path: string|buffer|url
atime: number|string|date
mtime: number|string|date
callback: function

回调方式

语法

fs.lutimes(path,atime,mtime,(error)=>{
  console.log(error);
});

path: string|buffer|url
atime: number|string|date
mtime: number|string|date
callback: function

Promise 方式

语法

await fs.promises.lutimes(path:string|buffer|url,atime:number|string|date,mtime:number|string|date)

path: string | Buffer | URL
atime: number | string | Date
mtime: number | string | Date

返回值

undefined

link(existingPath, newPath)

link(existingPath, newPath) 创建从 existingPath 到 newPath 的新链接。

同步方式

语法

fs.linkSync(existingPath, newPath)

existingPath: string|buffer|url
newPath: string|buffer|url

回调方式

语法

fs.link(existingPath,newPath,(error)=>{
  console.log(error);
});

existingPath: string|buffer|url
newPath: string|buffer|url
callback: function

Promise 方式

语法

await fs.promises.link(existingPath:string|buffer|url,newPath:string|buffer|url);

existingPath: string | Buffer | URL
newPath: string | Buffer | URL

返回值

undefined

lstat(path[, options])

lstat(path[, options]) 等效于 fsPromises.stat()，除非 path 指向符号链接，在这种情况下，被统计的是链接本身，而不是其所引用的文件。

同步方式

语法

fs.lstatSync(path[, options])

path: string|buffer|url
bigint: boolean 返回的 fs.Stats 对象中的数值是否应为 bigint。默认值: false。
throwIfNoEntry: boolean 如果文件系统条目不存在，是否会抛出异常，而不是返回 undefined。默认值: true。

返回值

返回 fs.Stats

回调方式

语法

fs.lstat(path,{
  bigint: boolean
},(error,stats)=>{
  if(error){
    console.log(error);
    return;
  }
  console.log(stats);
});

path: string|buffer|url
bigint: boolean 返回的 fs.Stats 对象中的数值是否应为 bigint。默认值: false。
callback: function

Promise 方式

语法

const stat = fs.promises.lstat(path:string|buffer|url,{
  bigint: boolean
})

path: string|buffer|url
bigint: boolean 返回的 <fs.Stats> 对象中的数值是否应为 bigint。默认值: false。

返回值

返回<Promise> 使用给定的符号链接 path 的 <fs.Stats>对象履行。

mkdir(path[, options])

mkdir(path[, options]) 异步地创建目录。

同步方式

语法

fs.mkdirSync(path,{
  recursive: boolean,
  mode: string|number 
})

path: string|buffer|url
recursive: boolean 默认值: false
mode: string|number 默认值: 0o777

返回值

返回 undefined 或创建的第一个目录路径（如果 recursive 为 true）

场景

const Fs = require("fs");

const result = Fs.mkdirSync("./testNew/testNew/testNew",{
    recursive:true
});
console.log(result);

回调方式

语法

fs.mkdir(path,{
  recursive: boolean,
  mode: string|number 
},(error,path)=>{
  if(error){
    console.log(error);
    return 
  }
  console.log(path);
});

path: string|buffer|url
recursive: boolean 默认值: false
mode: string|number 默认值: 0o777。
callback: function

场景

const Fs = require("fs");

Fs.mkdir(
  "../test/test/test",
  {
    recursive: true,
  },
  (error, path) => {
    if (error) {
      console.log(error);
      return;
    }
    console.log(path);
  }
);

Promise 方式

语法

await fs.promises.mkdir(path:string|buffer|url,{
  recursive: boolean,
  mode: string|number 
})

path: string|buffer|url
recursive: boolean 默认值: false
mode: string|number Windows 上不支持。默认值: 0o777。

返回值

返回<Promise>成功后，如果 recursive 为 false，则使用 undefined 履行；如果 recursive 为 true，则使用创建的第一个目录路径履行。

场景

const Fs = require("fs");

async function mkdir() {
  let filehandle = null;
  try {
    await Fs.promises.mkdir("testFather/testSon",{
      recursive:true
    });
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

mkdir();

mkdtemp(prefix[, options])

mkdtemp(prefix[, options])& 创建唯一的临时目录。通过在所提供的 prefix 的末尾附加六个随机字符来生成唯一的目录名称。由于平台的不一致，请避免在 prefix 中尾随 X 字符。某些平台，尤其是 BSD，可能返回六个以上的随机字符，并将 prefix 中的尾随 X 字符替换为随机字符。

同步方式

语法

fs.mkdtempSync(prefix,{
  encoding: string 
})

prefix: string
encoding: string 默认值: 'utf8'

返回值

返回 string 返回创建的目录路径。

回调方式

语法

fs.mkdtemp(prefix,{
  encoding:string,
},(error,directory)=>{
  if(error){
    console.log(error);
    return
  }
  console.log(directory);
});

prefix: string
encoding: string 默认值: 'utf8'
callback: function

Promise 方式

语法

const result = await fs.promises.mkdtemp(prefix,{
  encoding: string
})

prefix: string
encoding: string 默认值: 'utf8'

返回值

返回<Promise>使用包含新创建的临时目录的文件系统路径的字符串来履行。

open(path, flags[, mode])

open(path, flags[, mode]) 打开 FileHandle。

同步方式

语法

fs.openSync(path,flags,mode);

path: string|buffer|url
flags: string|number 默认值: 'r'
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。
mode: string|number 默认值: 0o666
- O_RDONLY: 指示打开文件以进行只读访问的标志。
- O_WRONLY: 指示打开文件以进行只写访问的标志。
- O_RDWR: 指示打开文件以进行读写访问的标志。
- O_CREAT: 如果文件不存在则指示创建文件的标志。
- O_EXCL: 如果设置了 O_CREAT 标志并且文件已经存在，则指示打开文件应该失败的标志。
- O_NOCTTY: 标志表示如果路径标识一个终端设备，打开路径不应导致该终端成为进程的控制终端（如果进程还没有一个）。
- O_TRUNCZ: 标志表示如果文件存在并且是一个普通文件，并且该文件被成功打开以进行写访问，则其长度应被截断为零。
- O_APPEND 指示数据将追加到文件末尾的标志。
- O_DIRECTORY 如果路径不是目录，则表示打开应该失败的标志。
- O_NOATIME 指示对文件系统的读取访问的标志将不再导致与文件关联的 atime 信息的更新。此标志仅在 Linux 操作系统上可用。
- O_NOFOLLOW: 如果路径是符号链接，则表示打开应该失败的标志。
- O_SYNC 指示文件为同步 I/O 打开的标志，写操作等待文件完整性。
- O_DSYNC 指示文件为同步 I/O 打开的标志，写操作等待数据完整性。
- O_SYMLINK 指示打开符号链接本身而不是它指向的资源的标志。
- O_DIRECT 设置后，将尝试最小化文件 I/O 的缓存影响。
- O_NONBLOCK 指示在可能的情况下以非阻塞模式打开文件的标志。
- UV_FS_O_FILEMAP 设置后，将使用内存文件映射来访问文件。此标志仅在 Windows 操作系统上可用。在其他操作系统上，此标志被忽略。

返回值

返回 number 返回表示文件描述符的整数。

场景

const Fs = require("fs");

const fd = Fs.openSync("./test.js", "r");
console.log(fd);

回调方式

语法

fs.open(path,flags,mode,(error,fd)=>{
  if(error){
    console.log(error);
    return 
  }
  console.log(fd);
});

path: string|buffer|url
flags: 默认值: 'r'。
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。
mode: string|number 默认值: 0o666 （可读可写）
- O_RDONLY: 指示打开文件以进行只读访问的标志。
- O_WRONLY: 指示打开文件以进行只写访问的标志。
- O_RDWR: 指示打开文件以进行读写访问的标志。
- O_CREAT: 如果文件不存在则指示创建文件的标志。
- O_EXCL: 如果设置了 O_CREAT 标志并且文件已经存在，则指示打开文件应该失败的标志。
- O_NOCTTY: 标志表示如果路径标识一个终端设备，打开路径不应导致该终端成为进程的控制终端（如果进程还没有一个）。
- O_TRUNCZ: 标志表示如果文件存在并且是一个普通文件，并且该文件被成功打开以进行写访问，则其长度应被截断为零。
- O_APPEND 指示数据将追加到文件末尾的标志。
- O_DIRECTORY 如果路径不是目录，则表示打开应该失败的标志。
- O_NOATIME 指示对文件系统的读取访问的标志将不再导致与文件关联的 atime 信息的更新。此标志仅在 Linux 操作系统上可用。
- O_NOFOLLOW: 如果路径是符号链接，则表示打开应该失败的标志。
- O_SYNC 指示文件为同步 I/O 打开的标志，写操作等待文件完整性。
- O_DSYNC 指示文件为同步 I/O 打开的标志，写操作等待数据完整性。
- O_SYMLINK 指示打开符号链接本身而不是它指向的资源的标志。
- O_DIRECT 设置后，将尝试最小化文件 I/O 的缓存影响。
- O_NONBLOCK 指示在可能的情况下以非阻塞模式打开文件的标志。
- UV_FS_O_FILEMAP 设置后，将使用内存文件映射来访问文件。此标志仅在 Windows 操作系统上可用。在其他操作系统上，此标志被忽略。
callback: function

返回值

返回 number 返回表示文件描述符的整数。

场景

const Fs = require("fs");

Fs.open("./test.js", "r", (error, fd) => {
  if (error) {
    console.log(error);
    return;
  }
  console.log(fd);
});

Promise 方式

语法

const fileHandle = await fs.promises.open(path:string|buffer|url,flags:string|number,mode:string|number);

path: string|buffer|url
flags: string|number 默认值: 'r' 。文件系统标志:
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。
mode: string|number 如果创建文件，则设置文件模式（权限和粘性位）。默认值: 0o666 （可读可写）
- O_RDONLY: 指示打开文件以进行只读访问的标志。
- O_WRONLY: 指示打开文件以进行只写访问的标志。
- O_RDWR: 指示打开文件以进行读写访问的标志。
- O_CREAT: 如果文件不存在则指示创建文件的标志。
- O_EXCL: 如果设置了 O_CREAT 标志并且文件已经存在，则指示打开文件应该失败的标志。
- O_NOCTTY: 标志表示如果路径标识一个终端设备，打开路径不应导致该终端成为进程的控制终端（如果进程还没有一个）。
- O_TRUNCZ: 标志表示如果文件存在并且是一个普通文件，并且该文件被成功打开以进行写访问，则其长度应被截断为零。
- O_APPEND 指示数据将追加到文件末尾的标志。
- O_DIRECTORY 如果路径不是目录，则表示打开应该失败的标志。
- O_NOATIME 指示对文件系统的读取访问的标志将不再导致与文件关联的 atime 信息的更新。此标志仅在 Linux 操作系统上可用。
- O_NOFOLLOW: 如果路径是符号链接，则表示打开应该失败的标志。
- O_SYNC 指示文件为同步 I/O 打开的标志，写操作等待文件完整性。
- O_DSYNC 指示文件为同步 I/O 打开的标志，写操作等待数据完整性。
- O_SYMLINK 指示打开符号链接本身而不是它指向的资源的标志。
- O_DIRECT 设置后，将尝试最小化文件 I/O 的缓存影响。
- O_NONBLOCK 指示在可能的情况下以非阻塞模式打开文件的标志。
- UV_FS_O_FILEMAP 设置后，将使用内存文件映射来访问文件。此标志仅在 Windows 操作系统上可用。在其他操作系统上，此标志被忽略。

返回值

返回Promise使用FileHandle对象履行。

FileHandle {
  _events: [Object: null prototype] {},
  _eventsCount: 0,
  _maxListeners: undefined,
  close: [Function: close],
  [Symbol(kCapture)]: false,
  [Symbol(kHandle)]: FileHandle {},
  [Symbol(kFd)]: 20,
  [Symbol(kRefs)]: 1,
  [Symbol(kClosePromise)]: null
}

场景

const Fs = require("fs");

async function open() {
  let filehandle = null;
  try {
    let filehandle = await Fs.promises.open("./test.js");
    console.log(filehandle)
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

open();

opendir(path[, options])

opendir(path[, options]) 异步地打开目录进行迭代扫描。

同步方式

语法

fs.opendirSync(path,{
  encoding: string|null,
  bufferSize: number 
})

path: string|buffer|url
encoding: string|null 默认值: 'utf8'
bufferSize: number 当从目录读取时，在内部缓冲的目录条目数。值越大，性能越好，但内存使用率越高。默认值: 32

返回值

返回 fs.Dir

场景

const Fs = require("fs");

const dir = Fs.opendirSync("./test", {
  encoding: "utf8",
});
console.log(dir);

回调方式

语法

fs.opendir(path,{
  encoding: string|null,
  bufferSize: number 
},(error,dir)=>{
  if(error){
    console.log(error);
    return 
  }
  console.log(dir);
});

场景

const Fs = require("fs");

Fs.opendir(
  "../test",
  {
    encoding: "utf8",
  },
  (error, dir) => {
    if (error) {
      console.log(error);
      return;
    }
    console.log(dir);
  }
);

Promise 方式

语法

const result = await fs.promises.opendir(path:string|buffer|url,{
  encoding: string|null,
  bufferSize: number 
});

path: string|buffer|url
encoding: string|null 默认值: 'utf8'
bufferSize: number 当从目录读取时，在内部缓冲的目录条目数。值越大，性能越好，但内存使用率越高。默认值: 32

返回值

返回Promise使用fs.Dir履行。

Dir {
  [Symbol(kDirHandle)]: DirHandle {},
  [Symbol(kDirBufferedEntries)]: [],
  [Symbol(kDirPath)]: '../',
  [Symbol(kDirClosed)]: false,
  [Symbol(kDirOperationQueue)]: null,
  [Symbol(kDirOptions)]: { bufferSize: 32, encoding: 'utf8' },
  [Symbol(kDirReadPromisified)]: [Function: bound [kDirReadImpl]],
  [Symbol(kDirClosePromisified)]: [Function: bound close]
}

场景

const Fs = require("fs");

async function opendir() {
  try {
    let result = await Fs.promises.opendir("../");
    for await (const dirent of result){
      console.log(dirent.name)
    }
  } catch (error) {
    console.log(error);
  }
}

opendir();

read()

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

同步方式

语法: fs.readSync() 有多个重载函数，如下所示:

fs.readSync(fd, buffer, offset, length,position)
- 语法
```
const bytesRead = fs.readSync(fd, buffer, offset, length,position);
```
  - fd: number
  - buffer: buffer|typedArray|dataView 数据将写入的缓冲区
  - offset: number 要写入数据的 buffer 中的位置
  - length: number 读取的字节数
  - position: number|bigint|null 指定从文件中开始读取的位置。如果 position 为 null 或 -1 ，则将从当前文件位置读取数据，并更新文件位置。如果 position 是整数，则文件位置将保持不变。
- 返回值
  
  返回 number , 返回 bytesRead 的数量。
fs.readSync(fd, buffer, options)
- 语法
```
const bytesRead = fs.readSync(fd, buffer,{
  offset: number,
  length: number,
  position: number|bigint|null
});
```
  - fd: number
  - buffer: buffer|typedArray|dataView 数据将写入的缓冲区默认值: Buffer.alloc(16384)
  - offset: number 要写入数据的 buffer 中的位置默认值: 0
  - length: number 读取的字节数默认值: buffer.byteLength - offset
  - position: number|bigint|null 指定从文件中开始读取的位置。如果 position 为 null 或 -1 ，则将从当前文件位置读取数据，并更新文件位置。如果 position 是整数，则文件位置将保持不变。默认值: null
- 返回值
  
  返回 number , 返回 bytesRead 的数量。

回调方式

语法: fs.read() 有多个重载函数，如下所示:

read(fd, buffer, offset, length, position, callback)
- 语法:
```
fs.read(fd, buffer, offset, length, position,(error,bytesRead,buffer)=>{

});
```
  - fd: number
  - buffer: buffer|typedArray|dataView 数据将写入的缓冲区
  - offset: number 要写入数据的 buffer 中的位置
  - length: number 读取的字节数
  - position: number|bigint|null 指定从文件中开始读取的位置。如果 position 为 null 或 -1 ，则将从当前文件位置读取数据，并更新文件位置。如果 position 是整数，则文件位置将保持不变。
  - callback: function
read(fd[, options], callback)
- 语法
```
fs.read(fd,{
  buffer:buffer|typedArray|dataView,
  offset:number,
  length:number,
  position:number|bigint|null 
},(error,bytesRead,buffer)=>{

});
```
  - fd: number
  - buffer: buffer|typedArray|dataView 数据将写入的缓冲区默认值: Buffer.alloc(16384)
  - offset: number 要写入数据的 buffer 中的位置默认值: 0
  - length: number 读取的字节数默认值: buffer.byteLength - offset
  - position: number|bigint|null 指定从文件中开始读取的位置。如果 position 为 null 或 -1 ，则将从当前文件位置读取数据，并更新文件位置。如果 position 是整数，则文件位置将保持不变。默认值: null
  - callback: function
read(fd, buffer[, options], callback)
- 语法
```
fs.read(fd,buffer,{
  offset:number,
  length:number,
  position:number|bigint 
},(error,bytesRead,buffer)=>{

});
```
  - fd:
  - buffer: buffer|typedArray|dataView 数据将写入的缓冲区
  - offset: number 要写入数据的 buffer 中的位置默认值: 0
  - length: number 读取的字节数默认值: buffer.byteLength - offset
  - position: number|bigint|null 指定从文件中开始读取的位置。如果 position 为 null 或 -1 ，则将从当前文件位置读取数据，并更新文件位置。如果 position 是整数，则文件位置将保持不变。默认值: null
  - callback: function

FileHandle 类方式

语法: filehandle.read() 有多个重载函数，如下所示:

filehandle.read(buffer, offset, length, position)
- 语法:
```
const result = await filehandle.read(buffer,offset,length,position)
```
  - buffer: buffer|typeArray|dataView 将填充读取的文件数据的缓冲区
  - offset: number 缓冲区中开始填充的位置
  - length: number 读取的字节数
  - position: number|null 从文件开始读取数据的位置如果为 null，则将从当前文件位置读取数据，并将更新该位置。如果 position 是整数，则当前文件位置将保持不变。
- 返回值: 返回: <Promise> 成功时将使用具有以下两个属性的对象履行
```
result = {
    bytesRead: number 读取的字节数 
    buffer: buffer|typeArray|dataView 对传入的 buffer 参数的引用
}
```
filehandle.read([options])
- 语法:
```
const = await filehandle.read({
    offset: number,
    length: number,
    position: number
})
```
  - offset: number 缓冲区中开始填充的位置。默认值: 0
  - length: number 读取的字节数。默认值: buffer.byteLength - offset
  - position: number 从文件开始读取数据的位置。如果为 null，则将从当前文件位置读取数据，并将更新该位置。如果 position 是整数，则当前文件位置将保持不变。默认值:: null
- 返回值: 返回: <Promise> 成功时将使用具有以下两个属性的对象履行
```
result = {
    bytesRead: number 读取的字节数 
    buffer: buffer|typeArray|dataView 对传入的 buffer 参数的引用
}
```
filehandle.read(buffer[, options])
- 语法:
```
const = await filehandle.read(buffer,{
    offset: number,
    length: number,
    position: number
})
```
  - offset: number 缓冲区中开始填充的位置。默认值: 0
  - length: number 读取的字节数。默认值: buffer.byteLength - offset
  - position: number 从文件开始读取数据的位置。如果为 null，则将从当前文件位置读取数据，并将更新该位置。如果 position 是整数，则当前文件位置将保持不变。默认值:: null
- 返回值: 返回: <Promise> 成功时将使用具有以下两个属性的对象履行
```
result = {
    bytesRead: number 读取的字节数 
    buffer: buffer|typeArray|dataView 对传入的 buffer 参数的引用
}
```

场景

const Fs = require("fs");

async function read() {
  let filehandle = null;
  try {
    filehandle = await Fs.promises.open("./test.js");
    const result = await filehandle.read();
    console.log(result)
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

read();

readableWebStream()

readableWebStream() 返回可用于读取文件数据的ReadableStream。

FileHandle 类方式

语法

const readableStream = await filehandle.readableWebStream();

场景

const Fs = require("fs");

async function readableWebStream() {
  let filehandle = null;
  try {
    filehandle = await Fs.promises.open("./");
    const readableStream = await filehandle.readableWebStream();
    console.log(readableStream)
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

readableWebStream();

readdir(path[, options])

readdir(path[, options]) 读取目录的内容。

同步方式

语法

const list = fs.readdirSync(path,{
  encoding: string,
  withFileTypes: boolean 
})

path: string|buffer|url
encoding: string 默认值: 'utf8'
withFileTypes: boolean 默认值: false

返回值

读取目录的内容。

场景

const Fs = require("fs");

const list = Fs.readdirSync('./koa-views/',{
    encoding:"utf8"
});
console.log(list);

回调方式

语法

fs.readdir(path,{
  encoding:string,
  withFileTypes: boolean 
},(error,files)=>{

});

path: string|buffer|url
encoding: string 默认值: 'utf8'
withFileTypes: boolean 默认值: false
callback: function

场景

const Fs = require("fs");

Fs.readdir(
  "../node-api",
  {
    encoding: "utf8",
  },
  (error, files) => {
    if (error) {
      console.log(error);
      return;
    }
    console.log(files); // [ 'fs.js', 'path.js', 'test.js', 'testCopy.js', 'testFather' ]
  }
);

Promise 方式

语法

const result = await fs.promises.readdir(path:string|buffer|url,{
  encoding:string, 
  withFileTypes: boolean
})

path: string|buffer|url
encoding: string, 默认值: 'utf8'
withFileTypes: boolean 默认值: false

返回值

返回Promise使用目录中文件的名称数组（不包括 '.' 和 '..'）履行。

[ 'node-api', 'node-basics-server' ]

场景

const Fs = require("fs");

async function readdir() {
  try {
    let result = await Fs.promises.readdir("../");
    console.log(result)
  } catch (error) {
    console.log(error);
  }
}

readdir();

readFile(options)

readFile(options) 异步地读取文件的全部内容。

同步方式

语法

cosnt content = fs.readFileSync(path,{
  encoding: string|null,
  flag: string
})

path: string|buffer|url|number
encoding: string|null 默认值: null
flag: string 默认值: 'r'。
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。

返回值

返回 path 的内容。

场景

const Fs = require("fs");

const content = Fs.readFileSync("./test.js", {
  encoding: "utf8",
});
console.log(content);

回调方式

语法

fs.readFile(path,{
  encoding:string|null,
  flag:string,
  signal:abortSignal
},(error,data)=>{

});

path: string|buffer|url|number
encoding: string|null 默认值: null
flag: string 默认值: 'r'。
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。
signal: abortSignal 允许中止正在进行的读取文件
callback: function

场景

const Fs = require("fs");

Fs.readFile(
  "./test.js",
  {
    encoding: "utf8",
    flog: "r",
  },
  (error, data) => {
    if (error) {
      console.log(error);
      return;
    }
    console.log(data);
  }
);

Promise 方式

语法

const content = await fs.promises.readFile(path:string|buffer|url|fileHandle,{
  encoding: string|null ,
  flag: string,
  signal: abortSignal
})

encoding: string|null
flag: string 默认值: 'r'。文件系统标志:
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。
signal: 允许中止正在进行的读取文件

返回值

返回Promise使用文件的内容履行

场景

const Fs = require("fs");

async function readFile() {
  try {
    let content = await Fs.promises.readFile("./test.js",{
      encoding:"utf8",
      flag:"r"
    });
    console.log(content)
  } catch (error) {
    console.log(error);
  }
}

readFile();

FileHandle 类方式

语法

const content = await filehandle.readFile({
  encoding:string|null,
  signal: abortSignal
});

encoding: string|null 默认值为 null
signal: abortSignal 允许中止正在进行的读取文件

返回值

返回<Promise> 成功读取时将使用文件内容履行。如果未指定编码（使用 options.encoding），则数据作为 <Buffer> 对象返回。否则，数据将为字符串。

场景

const Fs = require("fs");

async function readFile() {
  let filehandle = null;
  try {
    filehandle = await Fs.promises.open("./test.js");
    const content = await filehandle.readFile({
      encoding: "utf8",
    });
    console.log(content);
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

readFile();

readlink(path[, options])

readlink(path[, options]) 读取 path 引用的符号链接的内容。

同步方式

语法

const str = fs.readlinkSync(path,{
  encoding: string 
});

path: string|buffer|url
encoding: string 默认值: 'utf8'

返回值

返回符号链接的字符串值。

回调方式

语法

fs.readlink(path,{
  encoding: string
},(error,linkString)=>{

});

path: string|buffer|url
encoding: string 默认值: 'utf8'
callback: function

Promise 方式

语法

const linkString = await fs.promises.readlink(path:string|buffer|url,{
  encoding: string 
})

path: string|buffer|url
encoding: string 默认值: 'utf8'

返回值

返回Promise成功时将使用linkString履行。

场景

realpath(path[, options])

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

同步方式

语法

const str = fs.readvSync(path,position)

path: string|buffer|url
encoding: string 默认值: 'utf8'

返回值

返回 string , 返回解析的路径名。

回调方式

语法

fs.realpath(path,{
  encoding: string
},(error,resolvedPath)=>{

});

path: string|buffer|url
encoding: string 默认值: 'utf8'
callback: function

Promise 方式

语法

const result = fs.promises.realpath(path:string|object,{
  encoding:string 
});

path: string|object
encoding: string 默认值: 'utf8'

返回值

返回Promise成功时将使用解析的路径履行。

场景

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

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

同步方式

语法

const result = fs.realpathSync.native(path,{
  encoding: string 
})

path: string|buffer|url
encoding: string 默认值: 'utf8'

返回值

返回 stgring|buffer

回调方式

语法

fs.realpath.native(path,{
  encoding:string
},(error,resolvePath)=>{

});

path: string|buffer|url
encoding: string 默认值: 'utf8'
callback: function

readv(buffers[, position])

同步方式

语法

const num = fs.readvSync(fd, buffers, position);

fd: number
buffers: arrayBufferView[]
position: number|null 默认值: null

返回值

返回 number , 返回读取的字节数

回调方式

语法

fs.readv(fd,buffers,position,(error,bytesRead,buffers)=>{

});

fd: number
buffers: arrayBufferView[]
position: number|null 默认值: null
callback: function

FileHandle 类方式

语法

const result = await filehandle.readv(buffers,position);

buffers: buffer[]|typeArray[]|dataView[]
position: number|null 要从中读取数据的文件的开头偏移量。如果 position 不是 number，则将从当前位置读取数据。默认值: null

返回值

返回: <Promise> 成功时将使用包含以下两个属性的对象履行：

result = {
  bytesRead: number 读取的字节数,
  buffers: buffer[]|typedArray[]|dataView[] 该属性包含对 buffers 输入的引用。
}

场景

rename(oldPath, newPath)

rename(oldPath, newPath) 将 oldPath 重命名为 newPath。

同步方式

语法

fs.renameSync(oldPath, newPath);

oldPath: string|buffer|url
newPath: string|buffer|url

场景

const Fs = require("fs");

Fs.renameSync('./test.js','./testNew.js');

回调方式

语法

fs.rename(oldPath,newPath,(error)=>{

});

oldPath: string|buffer|url
newPath: string|buffer|url
callback: function

场景

const Fs = require("fs");

Fs.rename("./test.js", "./testNew.js", (error) => {
  if (error) {
    console.log(error);
  }
});

Promise 方式

语法

await fs.promises.rename(oldPath:string|buffer|url,newPath:string|buffer|url);

oldPath
newPath

返回值

undefined

场景

const Fs = require("fs");

async function rename() {
  try {
    await Fs.promises.rename("./testNew.js","./test.js");
  } catch (error) {
    console.log(error);
  }
}

rename();

rmdir(path[, options])

rmdir(path[, options]) 删除由 path 标识的目录。

同步方式

语法

fs.rmdirSync(path,{
  maxRetries: number,
  recursive: boolean,
  retryDelay: number 
})

path: string|buffer|url
maxRetries: number 如果遇到 EBUSY、EMFILE、ENFILE、ENOTEMPTY 或 EPERM 错误，Node.js 将在每次尝试时以 retryDelay 毫秒的线性退避等待时间重试该操作。此选项表示重试次数。如果 recursive 选项不为 true，则忽略此选项。默认值: 0。
recursive: boolean 如果为 true，则执行递归目录删除。在递归模式下，操作将在失败时重试。默认值: false。已弃用。
retryDelay: number 重试之间等待的时间（以毫秒为单位）。如果 recursive 选项不为 true，则忽略此选项。默认值: 100。

场景

const Fs = require("fs");

Fs.rmdirSync("./test", {
  maxretries: 0,
});

回调方式

语法

fs.rmdir(path,{
  maxRetries: number,
  recursive: boolean,
  retryDelay: number 
},(error)=>{

});

path: string|buffer|url
maxRetries: number 如果遇到 EBUSY、EMFILE、ENFILE、ENOTEMPTY 或 EPERM 错误，Node.js 将在每次尝试时以 retryDelay 毫秒的线性退避等待时间重试该操作。此选项表示重试次数。如果 recursive 选项不为 true，则忽略此选项。默认值: 0。
recursive: boolean 如果为 true，则执行递归目录删除。在递归模式下，操作将在失败时重试。默认值: false。已弃用。
retryDelay: number 重试之间等待的时间（以毫秒为单位）。如果 recursive 选项不为 true，则忽略此选项。默认值: 100。

场景

const Fs = require("fs");

Fs.rmdir(
  "../test",
  {
    maxRetries: 0,
  },
  (error) => {
    if (error) {
      console.log(error);
    }
  }
);

Promise 方式

语法

await fs.promises.rmdir(path:string|buffer|url,{
  maxRetries: number,
  recursive: boolean,
  retryDelay: number
});

maxRetries: number 如果遇到 EBUSY、EMFILE、ENFILE、ENOTEMPTY 或 EPERM 错误，Node.js 将在每次尝试时以 retryDelay 毫秒的线性退避等待时间重试该操作。此选项表示重试次数。如果 recursive 选项不为 true，则忽略此选项。默认值: 0。
recursive: boolean 如果为 true，则执行递归目录删除。在递归模式下，操作将在失败时重试。默认值: false。已弃用。
retryDelay: number 重试之间等待的时间（以毫秒为单位）。如果 recursive 选项不为 true，则忽略此选项。默认值: 100。

返回值

undefined

场景

const Fs = require("fs");

async function rmdir() {
  try {
    await Fs.promises.rmdir("../test");
  } catch (error) {
    console.log(error);
  }
}

rmdir();

rm(path[, options])

rm(path[, options]) 删除文件和目录

同步方式

语法

fs.rmSync(path,{
  force: boolean,
  maxRetries: number,
  recursive: boolean,
  retryDelay: number
})

path: string|buffer|url,
force: boolean 当为 true 时，如果 path 不存在，则异常将被忽略。默认值: false。
maxRetries: number 如果遇到 EBUSY、EMFILE、ENFILE、ENOTEMPTY 或 EPERM 错误，Node.js 将在每次尝试时以 retryDelay 毫秒的线性退避等待时间重试该操作。此选项表示重试次数。如果 recursive 选项不为 true，则忽略此选项。默认值: 0。
recursive: boolean 如果为 true，则执行递归目录删除。在递归模式下，操作将在失败时重试。默认值: false。
retryDelay: number 重试之间等待的时间（以毫秒为单位）。如果 recursive 选项不为 true，则忽略此选项。默认值: 100。

场景

const Fs = require("fs");

Fs.rmSync("./test", {
  force: true,
  recursive: true,
});

回调方式

语法

fs.rm(path,{
  force: boolean,
  maxRetries: number,
  recursive: boolean,
  retryDelay: number
});

path: string|buffer|url,
force: boolean 当为 true 时，如果 path 不存在，则异常将被忽略。默认值: false。
maxRetries: number 如果遇到 EBUSY、EMFILE、ENFILE、ENOTEMPTY 或 EPERM 错误，Node.js 将在每次尝试时以 retryDelay 毫秒的线性退避等待时间重试该操作。此选项表示重试次数。如果 recursive 选项不为 true，则忽略此选项。默认值: 0。
recursive: boolean 如果为 true，则执行递归目录删除。在递归模式下，操作将在失败时重试。默认值: false。
retryDelay: number 重试之间等待的时间（以毫秒为单位）。如果 recursive 选项不为 true，则忽略此选项。默认值: 100。
callback: function

场景

const Fs = require("fs");

Fs.rm(
  "../test",
  {
    recursive: true,
  },
  (error) => {
    if (error) {
      console.log(error);
    }
  }
);

Promise 方式

语法

await fs.promises.rm(path:string|buffer|url,{
  force: boolean,
  maxRetries: number,
  recursive: boolean,
  retryDelay: number
});

force: boolean 当为 true 时，如果 path 不存在，则异常将被忽略。默认值: false。
maxRetries: number 如果遇到 EBUSY、EMFILE、ENFILE、ENOTEMPTY 或 EPERM 错误，Node.js 将在每次尝试时以 retryDelay 毫秒的线性退避等待时间重试该操作。此选项表示重试次数。如果 recursive 选项不为 true，则忽略此选项。默认值: 0。
recursive: boolean 如果为 true，则执行递归目录删除。在递归模式下，操作将在失败时重试。默认值: false。
retryDelay: number 重试之间等待的时间（以毫秒为单位）。如果 recursive 选项不为 true，则忽略此选项。默认值: 100。

返回值

undefined

场景

const Fs = require("fs");

async function rm() {
  try {
    await Fs.promises.rm("../test",{
      force:true,
      recursive:true
    });
  } catch (error) {
    console.log(error);
  }
}

rm();

stat([options])

stat([options]) 检查文件是否存在

使用规范

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

同步方式

语法

const stat = fs.statSync(path,{
  bigint: boolean,
  throwIfNoEntry: boolean
})

path: string|buffer|url
bigint: boolean 返回的 fs.Stats 对象中的数值是否应为 bigint。默认值: false。
throwIfNoEntry: boolean 如果文件系统条目不存在，是否会抛出异常，而不是返回 undefined。默认值: true。

返回值

返回 fs.Stats

场景

const Fs = require("fs");

const stat = Fs.statSync("./test", {
  throwIfNoEntry: false,
});
console.log(stat);

回调方式

语法

fs.stat(path,{
  bigint: boolean 
},(error,stats)=>{

});

path: string|buffer|url
bigint: boolean 返回的fs.Stats对象中的数值是否应为 bigint。默认值: false。
callback: function

场景

const Fs = require("fs");

Fs.stat(
  "./test.js",
  {
    bigint: false,
  },
  (error, stats) => {
    if (error) {
      console.log(error);
      return;
    }
    console.log(stats);
  }
);

Promise 方式

语法

const stat = await fs.promises.stat(path:string|buffer|url,{
  bigint:boolean
})

path: string|buffer|url
bigint: boolean 返回的fs.Stats对象中的数值是否应为 bigint。默认值: false。

返回值

返回Promise使用给定的path的fs.Stats对象履行。

Stats {
  dev: 16777232,
  mode: 33188,
  nlink: 1,
  uid: 501,
  gid: 20,
  rdev: 0,
  blksize: 4096,
  ino: 2174149,
  size: 72,
  blocks: 8,
  atimeMs: 1655028642221.7344,
  mtimeMs: 1655020710206.682,
  ctimeMs: 1655028641414.5247,
  birthtimeMs: 1654940042254.748,
  atime: 2022-06-12T10:10:42.222Z,
  mtime: 2022-06-12T07:58:30.207Z,
  ctime: 2022-06-12T10:10:41.415Z,
  birthtime: 2022-06-11T09:34:02.255Z
}

场景

const Fs = require("fs");

async function stat() {
  try {
    const stat = await Fs.promises.stat("./test.js");
    console.log(stat)
  } catch (error) {
    console.log(error);
  }
}

stat();

FileHandle 类方式

语法

const result = await filehandle.stat({
  bigint: boolean
})

bigint: boolean 返回的 <fs.Stats> 对象中的数值是否应为 bigint。默认值: false。

返回值

result = {
  dev: 16777232,
  mode: 33188,
  nlink: 1,
  uid: 501,
  gid: 20,
  rdev: 0,
  blksize: 4096,
  ino: 2174149,
  size: 8,
  blocks: 8,
  atimeMs: 1654941879637.67,
  mtimeMs: 1654941878015.2808,
  ctimeMs: 1654941878015.2808,
  birthtimeMs: 1654940042254.748,
  atime: 2022-06-11T10:04:39.638Z,
  mtime: 2022-06-11T10:04:38.015Z,
  ctime: 2022-06-11T10:04:38.015Z,
  birthtime: 2022-06-11T09:34:02.255Z
}

场景

const Fs = require("fs");

async function stat() {
  let filehandle = null;
  try {
    filehandle = await Fs.promises.open("./test.js");
    const result = await filehandle.stat();
    console.log(result);
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

stat();

symlink(target, path[, type])

symlink(target, path[, type]) 创建符号链接。

同步方式

语法

fs.symlinkSync(target, path, type)

target: string|buffer|url
path: string|buffer|url
type: string 默认值: 'file'
- dir
- file
- junction

回调方式

语法

fs.symlink(target,path,type,(error)=>{

});

target: string|buffer|url
path: string|buffer|url
type: string 默认值: 'file'
- dir
- file
- junction
callback: function

Promise

语法

await fs.promises.symlink(target:string|buffer|url,path:string|buffer|url,type:string)

target: string|buffer|url
path: string|buffer|url
type: string 默认值: 'file'
- dir
- file
- junction

返回值

undefined

sync()

sync() 请求将打开文件描述符的所有数据刷新到存储设备。

FileHandle 类方式

语法

await filehandle.sync()

返回值

undefined

truncate(len)

truncate(len) 截断文件。如果文件大于 len 个字节，则仅前 len 个字节将保留在文件中。

同步方式

语法

fs.truncateSync(path,len)

path: string|buffer|url
len: number 默认值: 0

场景

const Fs = require("fs");

Fs.truncateSync("./test.js", 10);

回调方式

语法

fs.truncate(path,len,(error)=>{

});

path: string|buffer|url
len: number 默认值: 0
callback: function

场景

const Fs = require("fs");

Fs.truncate("./test.js", 10, (error) => {
  if (error) {
    console.log(error);
  }
});

Promise 方式

语法

await fs.promises.truncate(path:string|buffer|url,len:number);

path: string|buffer|url
len: number 默认值: 0

场景

const Fs = require("fs");

async function truncate() {
  try {
    await Fs.promises.truncate("./test.js",5);
  } catch (error) {
    console.log(error);
  }
}

truncate();

FileHandle 类方式

语法

await filehandle.truncate(len:number);

len: number 默认值: 0

场景

const Fs = require("fs");

async function truncate() {
  let filehandle = null;
  try {
    filehandle = await Fs.promises.open("./test.js","r+");
    await filehandle.truncate(2);
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

truncate();

unlink(path)

unlink(path) 如果 path 指向符号链接，则删除该链接，但不影响链接所指向的文件或目录。如果 path 指向的文件路径不是符号链接，则删除文件。

同步方式

语法

fs.unlinkSync(path)

path: string|buffer|url

回调方式

语法

fs.unlink(path,(error)=>{

});

path: string|buffer|url
callback: function

Promise 方式

语法

await fs.promises.unlink(path:string|buffer|url)

path: string|buffer|url

返回值

undefined

unwatchFile(filename[, listener])

unwatchFile(filename[, listener]) 停止监视 filename 的变化。如果指定了 listener，则仅删除该特定监听器。否则，所有监听器都将被删除，从而有效地停止监视 filename。使用未被监视的文件名调用 fs.unwatchFile() 是空操作，而不是错误。

使用规范

使用 fs.watch() 比 fs.watchFile() 和 fs.unwatchFile() 更高效。应尽可能使用 fs.watch() 而不是 fs.watchFile() 和 fs.unwatchFile()。

回调方式

语法

fs.unwatchFile(filename,listener);

filename: string|buffer|url
listener: function 先前使用 fs.watchFile() 附加的监听器

utimes(atime, mtime)

utimes(atime, mtime) 更改 <FileHandle> 引用的对象的文件系统时间戳，然后在成功时不带参数解决promise 。

同步方式

语法

fs.utimesSync(path, atime, mtime)

path: string|buffer|url
atime: number|string|date
mtime: number|string|date

回调方式

语法

fs.utimes(path,atime,mtime,(error)=>{

});

path: string|buffer|url
atime: number|string|date
mtime: number|string|date
callback: function

Promise 方式

语法

await fs.promises.utimes(path:string|buffer|url,atime:number|string|date,mtime:number|string|date);

path: string|buffer|url
atime: number|string|date
mtime: number|string|date

返回值

undefined

FileHandle 类方式

语法

const promise = await filehandle.utimes(atime:number|string|date,mtime:number|string|date)

atime: number|string|date
mtime: number|string|date

watch(filename[, options])

watch(filename[, options]) 返回异步迭代器，其监视 filename 上的更改，其中 filename 是文件或目录。

危险

使用 fs.watch() 比 fs.watchFile 和 fs.unwatchFile 更高效。应尽可能使用 fs.watch 而不是 fs.watchFile 和 fs.unwatchFile。

回调方式

语法

fs.watch(filename,{
  persistent: boolean,
  recursive: boolean,
  encoding: string,
  signal: abortSignal
},(eventType,filename)=>{

});

filename: string|buffer|url
persistent: boolean 指示只要正在监视文件，进程是否应继续运行。默认值: true。
recursive: boolean 指示是应监视所有子目录，还是仅监视当前目录。这在指定目录时适用，并且仅在受支持的平台上有效（请参见注意事项）。默认值: false。
encoding: string 指定用于传给监听器的文件名的字符编码。默认值: 'utf8'。
signal: abortSignal 用于指示监视器何时应停止的abortSignal。
listener: function|undefined 默认值: undefined
- eventType: string
- filename: string|buffer

返回值

返回fs.FSWatcher

场景

const Fs = require("fs");

const watcher = Fs.watch(
  "./test.js",
  {
    persistent: true,
    encoding: "utf8",
  },
  (eventType, filename) => {
    console.log(eventType, filename);
  }
);
console.log(watcher);

Promise 方式

语法

asyncIterator = await fs.promises.watch(filename:string|buffer|url,{
  persistent: boolean,
  recursive: boolean,
  encoding: string,
  signal: abortSignal
})

persistent: boolean 指示只要正在监视文件，进程是否应继续运行。默认值: true。
recursive: boolean 指示是应监视所有子目录，还是仅监视当前目录。这在指定目录时适用，并且仅在受支持的平台上有效（请参见注意事项）。默认值: false。
encoding: string 指定用于传给监听器的文件名的字符编码。默认值: 'utf8'。
signal: abortSignal 用于指示监视器何时应停止的abortSignal。

返回值

返回asyncIterator具有以下属性的对象:

eventType: string 变更类型
filename string|buffer 变更的文件的名称。

场景

const Fs = require("fs");

async function watch() {
  try {
    const asyncIterator = await Fs.promises.watch("./test.js");
    for await (const event of asyncIterator){
      console.log(event)
    }
  } catch (error) {
    console.log(error);
  }
}

watch();

watchFile(filename[, options], listener)

watchFile(filename[, options], listener) 监视 filename 的变化。每次访问文件时都会调用回调 listener。

回调方式

语法

fs.watchFile(filename,{
  bigint:boolean,
  persistent: boolean,
  interval: number
},(current,previous)=>{

});

filename: string|buffer|url
bigint: boolean 默认值: false
persistent: boolean 默认值: true
interval: 默认值: 5007
current: fs.Status
previous: fs.Status

返回值

返回fs.StatWatcher

场景

const Fs = require("fs");

const watcher = Fs.watchFile(
  "./test.js",
  {
    persistent: true,
  },
  (current, previous) => {
    console.log(current);
    console.log(previous);
  }
);
console.log(watcher);

write()

write() 将内容写入文件。

同步方式

语法 fs.writeSync() 有多个重载函数，如下所示:

fs.writeSync(fd, buffer, offset, length, position)
- 语法
```
fs.writeSync(fd, buffer, offset,length,position)
```
  - fd: number
  - buffer: buffer|typedArray|dataView
  - offset: number 要开始写入数据的 buffer 的起始位置。
  - length: number 要从 buffer 写入的字节数。
  - position: number|null 要写入来自 buffer 的数据的文件的开头偏移量。如果 position 不是 number，则数据将被写入当前位置。
fs.writeSync(fd, buffer[, options])
- 语法
```
fs.write(fd,buffer,{
  offset:number,
  length:number,
  position:number
});
```
  - fd: number
  - buffer: buffer|typedArray|dataView
  - offset: number 要开始写入数据的 buffer 的起始位置。默认值: 0
  - length: number 要从 buffer 写入的字节数。默认值: buffer.byteLength - offset
  - position: number|null 要写入来自 buffer 的数据的文件的开头偏移量。如果 position 不是 number，则数据将被写入当前位置。默认值: null
fs.writeSync(fd, string[, position[, encoding]])
- 语法
```
fs.write(fd,string,position,encoding);
```
  - fd: number
  - string: string
  - position: number|null 要写入来自 string 的数据的文件的开头偏移量。如果 position 不是 number，则数据将写入当前位置。默认值: null
  - encoding: string 预期的字符串编码。默认值: 'utf8'

回调方式

语法: fs.write() 有多个重载函数，如下所示:

fs.write(fd, buffer, offset[, length[, position]], callback)
- 语法
```
fs.write(fd, buffer, offset,length,position,(error,bytesWritten,buffer)=>{

})
```
  - fd: number
  - buffer: buffer|typedArray|dataView
  - offset: number 要开始写入数据的 buffer 的起始位置。
  - length: number 要从 buffer 写入的字节数。
  - position: number|null 要写入来自 buffer 的数据的文件的开头偏移量。如果 position 不是 number，则数据将被写入当前位置。
  - callback: function
fs.write(fd, buffer[, options], callback)
- 语法
```
fs.write(fd,buffer,{
  offset:number,
  length:number,
  position:number
},(error,bytesWritten,buffer)=>{

});
```
  - fd: number
  - buffer: buffer|typedArray|dataView
  - offset: number 要开始写入数据的 buffer 的起始位置。默认值: 0
  - length: number 要从 buffer 写入的字节数。默认值: buffer.byteLength - offset
  - position: number|null 要写入来自 buffer 的数据的文件的开头偏移量。如果 position 不是 number，则数据将被写入当前位置。默认值: null
  - callback: function
fs.write(fd, string[, position[, encoding]], callback)
- 语法
```
fs.write(fd,string,position,encoding,(error,written,string)=>{

});
```
  - fd: number
  - string: string
  - position: number|null 要写入来自 string 的数据的文件的开头偏移量。如果 position 不是 number，则数据将写入当前位置。默认值: null
  - encoding: string 预期的字符串编码。默认值: 'utf8'
  - callback: function

FileHandle 类方式

语法: filehandle.write() 有多个重载函数，如下所示:

filehandle.write(buffer, offset[, length[, position]])
- 语法
```
await filehandle.write(buffer:buffer|typedArray|dataView,offset:number,length:number,position:number|null);
```
  - buffer: buffer|typedArray|dataView
  - offset: number 要开始写入数据的 buffer 的起始位置。
  - length: number 要从 buffer 写入的字节数。
  - position: number|null 要写入来自 buffer 的数据的文件的开头偏移量。如果 position 不是 number，则数据将被写入当前位置。
- 返回值: 返回 promise
filehandle.write(buffer[, options])
- 语法
```
await filehandle.write(buffer:buffer|typedArray|dataView,{
  offset:number,
  length:number,
  position:number
});
```
  - buffer: buffer|typedArray|dataView
  - offset: number 要开始写入数据的 buffer 的起始位置。默认值: 0
  - length: number 要从 buffer 写入的字节数。默认值: buffer.byteLength - offset
  - position: number|null 要写入来自 buffer 的数据的文件的开头偏移量。如果 position 不是 number，则数据将被写入当前位置。默认值: null
- 返回值: 返回 promise
filehandle.write(string[, position[, encoding]])
- 语法
```
await filehandle.write(string:string,position:number|null,encoding:string);
```
  - string: string
  - position: number|null 要写入来自 string 的数据的文件的开头偏移量。如果 position 不是 number，则数据将写入当前位置。默认值: null
  - encoding: string 预期的字符串编码。默认值: 'utf8'

场景

const Fs = require("fs");

async function write() {
  let filehandle = null;
  try {
    filehandle = await Fs.promises.open("./test.js",4);
    await filehandle.write("这是一个很寂寞的天，下着有些伤心的雨！",);
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

write();

writeFile(data,options)

writeFile(data,options) 异步地将数据写入文件，如果文件已经存在，则替换该文件。 data 可以是字符串、缓冲区、<AsyncIterable>、或 <Iterable> 对象。成功时不带参数解决 promise。

同步方式

语法

fs.writeFileSync(file,data,{
  encoding:string|null,
  mode:integer,
  flag:string,
  signal:abortSignal
});

file: string|buffer|url|fileHandle
data: string|buffer|typeArray|dataView|asyncIterable|iterable|stream
encoding: string|null 默认值: 'utf8'
mode: number 默认值: 0o666
flag: string 默认值: 'w'。文件系统标志:
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。
signal: 允许中止正在进行的写入文件

场景

覆盖

const Fs = require("fs");

Fs.writeFileSync("./test.js", "还好还好", {
  encoding: "utf8",
  flag: "w",
});

追加

const Fs = require("fs");

Fs.writeFileSync("./test.js", "还好还好", {
  encoding: "utf8",
  flag: "a+",
});

回调方式

语法

fs.writeFile(file,data,{
  encoding:string|null,
  mode:integer,
  flag:string,
  signal:abortSignal
},(error)=>{

});

file: string|buffer|url|fileHandle
data: string|buffer|typeArray|dataView|asyncIterable|iterable|stream
encoding: string|null 默认值: 'utf8'
mode: number 默认值: 0o666
flag: string 默认值: 'w'。文件系统标志:
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。
signal: 允许中止正在进行的写入文件

场景

覆盖

const Fs = require("fs");

Fs.writeFile("./test.js", "哈哈哈哈哈哈哈", (error) => {
  if (error) {
    console.log(error);
  }
});

追加

const Fs = require("fs");

Fs.writeFile(
  "./test.js",
  "哈哈哈哈哈哈哈嘻嘻嘻嘻嘻",
  {
    flag: "a+",
  },
  (error) => {
    if (error) {
      console.log(error);
    }
  }
);

Promise 方式

语法

await fs.promises.writeFile(file:string|buffer|url|fileHandle,data:string|buffer|typeArray|dataView|asyncIterable|iterable|stream,{
  encoding:string|null,
  mode:integer,
  flag:string,
  signal:abortSignal
})

file: string|buffer|url|fileHandle
data: string|buffer|typeArray|dataView|asyncIterable|iterable|stream
encoding: string|null 默认值: 'utf8'
mode: number 默认值: 0o666
flag: string 默认值: 'w'。文件系统标志:
- a: 打开文件进行追加。如果文件不存在，则创建该文件。
- ax: 类似于 'a' 但如果路径存在则失败。
- a+: 打开文件进行读取和追加。如果文件不存在，则创建该文件。
- ax+: 类似于 'a+' 但如果路径存在则失败。
- as: 以同步模式打开文件进行追加。如果文件不存在，则创建该文件。
- as+: 以同步模式打开文件进行读取和追加。如果文件不存在，则创建该文件。
- r: 打开文件进行读取。如果文件不存在，则会发生异常。
- r+: 打开文件进行读写。如果文件不存在，则会发生异常。
- rs+: 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存。
- w: 打开文件进行写入。创建（如果它不存在）或截断（如果它存在）该文件。
- wx: 类似于 'w' 但如果路径存在则失败。
- w+: 打开文件进行读写。创建（如果它不存在）或截断（如果它存在）该文件。
- wx+: 类似于 'w+' 但如果路径存在则失败。
signal: 允许中止正在进行的写入文件

返回值

undefined

场景

const Fs = require("fs");

async function writeFile() {
  try {
    await Fs.promises.writeFile("./test.js","我不想不想长大！",{
      encoding:"utf8"
    });
  } catch (error) {
    console.log(error);
  }
}

writeFile();

FileHandle 类方式

语法

await filehandle.writeFile(data:string|buffer|typedArray|dataView|asyncIterable|stream,{
  encoding:string|null 
})

encoding: string|null 当 data 为字符串时的预期字符编码。默认值: 'utf8'

场景

const Fs = require("fs");

async function writeFile() {
  let filehandle = null;
  try {
    filehandle = await Fs.promises.open("./test.js","w");
    await filehandle.writeFile("这是一个很寂寞的天，下着有些伤心的雨！",);
  } catch (error) {
    console.log(error);
  } finally {
    await filehandle?.close();
  }
}

writeFile();

writev(buffers[, position])

writev(buffers[, position]) 将 <ArrayBufferView> 的数组写入文件。

同步方式

语法

const num = fs.writevSync(fd, buffers,position)

fd: number
buffers: buffer[]|typedArray[]|dataView[]
position: number|null 要写入来自 buffers 的数据的文件的开头偏移量。如果 position 不是 number，则数据将被写入当前位置。默认值: null

返回值

返回 number 写入的字节数

回调方式

语法

fs.writev(fd,buffers,position,(error,bytesWritten,buffers)=>{

});

fd: number
buffers: buffer[]|typedArray[]|dataView[]
position: number|null 要写入来自 buffers 的数据的文件的开头偏移量。如果 position 不是 number，则数据将被写入当前位置。默认值: null
callback: function

FileHandle 类方式

语法

await filehandle.writev(buffers: buffer[]|typedArray[]|dataView[],position:number|null);

buffers: buffer[]|typedArray[]|dataView[]
position: number|null 要写入来自 buffers 的数据的文件的开头偏移量。如果 position 不是 number，则数据将被写入当前位置。默认值: null

参考资料

Node.js 中文网

一、access(path[, mode])​

认识​

语法​

回调方式​

Promise 方式​

appendFile(data[, options])​

同步方式​

回调方式​

Promise 方式​

FileHandle 类方式​

chmod(mode)​

同步方式​

回调方式​

Promise 方式​

FileHandle 类方式​

chown(path,uid,gid)​

同步方式​

回调方式​

Promise 方式​

FileHandle 类方式​

close()​

同步方式​

回调方式​

FileHandle 类方式​

copyFile(src,dest[,mode])​

同步方式​

回调方式​

Promise 方式​

cp(src,dest[,options])​

同步方式​

回调方式​

Promise 方式​

createReadStream([options])​

回调方式​

FileHandle 类方式​

createWriteStream(path[, options])​

回调方式​

datasync()​

exists()​

同步方式​

fchmod(fd, mode, callback)​

同步方式​

回调方式​

fchown(fd, uid, gid, callback)​

同步方式​

回调方式​

fd​

fdatasync(fd, callback)​

同步方式​

回调方式​

fstat(fd[, options], callback)​

同步方式​

Promise 方式​

fsync(fd, callback)​

同步方式​

回调方式​

ftruncate(fd[, len], callback)​

同步方式​

回调方式​

futimes(fd, atime, mtime, callback)​

同步方式​

回调方式​

lchmod(path, mode, callback)​

同步方式​

回调方式​

lchown(path, uid, gid)​

同步方式​

回调方式​

Promise 方式​

lutimes(path, atime, mtime)​

同步方式​

回调方式​

Promise 方式​

link(existingPath, newPath)​

同步方式​

回调方式​

Promise 方式​

lstat(path[, options])​

同步方式​

回调方式​

一、access(path[, mode])

认识

语法

回调方式

Promise 方式

appendFile(data[, options])

同步方式

回调方式

Promise 方式

FileHandle 类方式

chmod(mode)

同步方式

回调方式

Promise 方式

FileHandle 类方式

chown(path,uid,gid)

同步方式

回调方式

Promise 方式

FileHandle 类方式

close()

同步方式

回调方式

FileHandle 类方式

copyFile(src,dest[,mode])

同步方式

回调方式

Promise 方式

cp(src,dest[,options])

同步方式

回调方式

Promise 方式

createReadStream([options])

回调方式

FileHandle 类方式

createWriteStream(path[, options])

回调方式

datasync()

exists()

同步方式

fchmod(fd, mode, callback)

同步方式

回调方式

fchown(fd, uid, gid, callback)

同步方式

回调方式

fd

fdatasync(fd, callback)

同步方式

回调方式

fstat(fd[, options], callback)

同步方式

Promise 方式

fsync(fd, callback)

同步方式

回调方式

ftruncate(fd[, len], callback)

同步方式

回调方式

futimes(fd, atime, mtime, callback)

同步方式

回调方式

lchmod(path, mode, callback)

同步方式

回调方式

lchown(path, uid, gid)

同步方式

回调方式

Promise 方式

lutimes(path, atime, mtime)

同步方式

回调方式

Promise 方式

link(existingPath, newPath)

同步方式

回调方式

Promise 方式

lstat(path[, options])

同步方式

回调方式