Node.js v14.20.0 文档


目录

fs 文件系统#

中英对照

fs 模块能够以标准 POSIX 函数为模型的方式与文件系统进行交互。



Promise 的示例#

中英对照

基于 promise 的操作会返回一个当异步操作完成时被履行的 promise。


回调的示例#

中英对照

回调的形式将完成回调函数作为其最后一个参数并且异步地调用该操作。 传给完成回调的参数取决于方法,但是第一个参数始终预留用于异常。 如果操作成功地完成,则第一个参数为 nullundefined


同步的示例#

中英对照

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


Promise 的 API#

中英对照

fs/promises API 提供了返回 promise 的异步的文件系统方法。

FileHandle#

中英对照

<FileHandle> 对象是数字文件描述符的对象封装。

filehandle.appendFile(data[, options])#

中英对照

    filehandle.writeFile() 的别名。

    filehandle.chmod(mode)#

    中英对照

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

      filehandle.chown(uid, gid)#

      中英对照

        更改文件的所有权。 chown(2) 的封装。

        filehandle.close()#

        中英对照

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

          
          
          filehandle.datasync()#

          中英对照

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

            filehandle.fd#

            中英对照

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

              中英对照

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

                filehandle.read([options])#

                中英对照

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

                  filehandle.readFile(options)#

                  中英对照

                    异步地读取文件的全部内容。

                    filehandle.readv(buffers[, position])#

                    中英对照

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

                      filehandle.stat([options])#

                      中英对照

                        filehandle.sync()#

                        中英对照

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

                          filehandle.truncate(len)#

                          中英对照

                            截断文件。

                            
                            

                            filehandle.utimes(atime, mtime)#

                            中英对照

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

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

                              中英对照

                                buffer 写入文件。

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

                                  中英对照

                                    string 写入文件。 如果 string 不是字符串,则 promise 使用错误拒绝。

                                      filehandle.writeFile(data, options)#

                                      中英对照

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

                                        filehandle.writev(buffers[, position])#

                                        中英对照

                                          <ArrayBufferView> 的数组写入文件。

                                            fsPromises.access(path[, mode])#

                                            中英对照

                                              测试用户对 path 指定的文件或目录的权限。 mode 参数是可选的整数,指定要执行的可访问性检查。 查看文件访问的常量以获取可能的 mode 值。 可以创建由两个或多个值的按位或组成的掩码(例如 fs.constants.W_OK | fs.constants.R_OK)。

                                              
                                              

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

                                              中英对照

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

                                                fsPromises.chmod(path, mode)#

                                                中英对照

                                                  更改文件的权限。

                                                  fsPromises.chown(path, uid, gid)#

                                                  中英对照

                                                    更改文件的所有权。

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

                                                    中英对照

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

                                                      
                                                      

                                                      fsPromises.lchmod(path, mode)#

                                                      中英对照

                                                        更改符号链接的权限。

                                                        fsPromises.lchown(path, uid, gid)#

                                                        中英对照

                                                          更改符号链接上的所有权。

                                                          fsPromises.lutimes(path, atime, mtime)#

                                                          中英对照

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

                                                            fsPromises.link(existingPath, newPath)#

                                                            中英对照

                                                              创建从 existingPathnewPath 的新链接。 有关更多详细信息,请参阅 POSIX link(2) 文档。

                                                              fsPromises.lstat(path[, options])#

                                                              中英对照

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

                                                                fsPromises.mkdir(path[, options])#

                                                                中英对照

                                                                  异步地创建目录。

                                                                  fsPromises.mkdtemp(prefix[, options])#

                                                                  中英对照

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

                                                                    
                                                                    

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

                                                                    中英对照

                                                                      打开 <FileHandle>

                                                                      fsPromises.opendir(path[, options])#

                                                                      中英对照

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

                                                                        
                                                                        

                                                                        fsPromises.readdir(path[, options])#

                                                                        中英对照

                                                                          读取目录的内容。

                                                                          
                                                                          

                                                                          fsPromises.readFile(path[, options])#

                                                                          中英对照

                                                                            异步地读取文件的全部内容。

                                                                            
                                                                            

                                                                            fsPromises.readlink(path[, options])#

                                                                            中英对照

                                                                              读取 path 引用的符号链接的内容。 有关更多详细信息,请参阅 POSIX readlink(2) 文档。 成功时使用 linkString 解决 promise。

                                                                              fsPromises.realpath(path[, options])#

                                                                              中英对照

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

                                                                                fsPromises.rename(oldPath, newPath)#

                                                                                中英对照

                                                                                  oldPath 重命名为 newPath

                                                                                  fsPromises.rmdir(path[, options])#

                                                                                  中英对照

                                                                                    删除由 path 标识的目录。

                                                                                    fsPromises.rm(path[, options])#

                                                                                    中英对照

                                                                                      删除文件和目录(在标准 POSIX rm 实用工具上建模)。

                                                                                      fsPromises.stat(path[, options])#

                                                                                      中英对照

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

                                                                                        中英对照

                                                                                          创建符号链接。

                                                                                          fsPromises.truncate(path[, len])#

                                                                                          中英对照

                                                                                            path 上的内容截断(缩短或延长长度)到 len 个字节。

                                                                                            fsPromises.unlink(path)#

                                                                                            中英对照

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

                                                                                              fsPromises.utimes(path, atime, mtime)#

                                                                                              中英对照

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

                                                                                                  fsPromises.watch(filename[, options])#

                                                                                                  中英对照

                                                                                                    返回异步迭代器,其监视 filename 上的更改,其中 filename 是文件或目录。

                                                                                                    
                                                                                                    

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

                                                                                                    中英对照

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

                                                                                                      
                                                                                                      

                                                                                                      回调的 API#

                                                                                                      中英对照

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

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

                                                                                                      中英对照

                                                                                                        测试用户对 path 指定的文件或目录的权限。 mode 参数是可选的整数,指定要执行的可访问性检查。 查看文件访问的常量以获取可能的 mode 值。 可以创建由两个或多个值的按位或组成的掩码(例如 fs.constants.W_OK | fs.constants.R_OK)。

                                                                                                        
                                                                                                        

                                                                                                        
                                                                                                        

                                                                                                        
                                                                                                        

                                                                                                        
                                                                                                        

                                                                                                        
                                                                                                        

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

                                                                                                        中英对照

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

                                                                                                          
                                                                                                          

                                                                                                          
                                                                                                          

                                                                                                          
                                                                                                          

                                                                                                          fs.chmod(path, mode, callback)#

                                                                                                          中英对照

                                                                                                            异步地更改文件的权限。 除了可能的异常之外,没有为完成回调提供任何参数。

                                                                                                            
                                                                                                            
                                                                                                            文件的模式#

                                                                                                            中英对照

                                                                                                            fs.chmod()fs.chmodSync() 方法中使用的 mode 参数是使用以下常量的逻辑或创建的数字位掩码:

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

                                                                                                              中英对照

                                                                                                                异步地更改文件的所有者和群组。 除了可能的异常之外,没有为完成回调提供任何参数。

                                                                                                                fs.close(fd[, callback])#

                                                                                                                中英对照

                                                                                                                  关闭文件描述符。 除了可能的异常之外,没有为完成回调提供任何参数。

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

                                                                                                                  中英对照

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

                                                                                                                      
                                                                                                                      

                                                                                                                      fs.createReadStream(path[, options])#

                                                                                                                      中英对照

                                                                                                                        与可读流的 16 kb 默认 highWaterMark 不同,此方法返回的流的默认 highWaterMark 为 64 kb。

                                                                                                                        
                                                                                                                        

                                                                                                                        
                                                                                                                        

                                                                                                                        fs.createWriteStream(path[, options])#

                                                                                                                        中英对照

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

                                                                                                                          fs.exists(path, callback)#

                                                                                                                          中英对照

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

                                                                                                                            
                                                                                                                            

                                                                                                                            
                                                                                                                            

                                                                                                                            
                                                                                                                            

                                                                                                                            
                                                                                                                            

                                                                                                                            
                                                                                                                            

                                                                                                                            fs.fchmod(fd, mode, callback)#

                                                                                                                            中英对照

                                                                                                                              设置文件的权限。 除了可能的异常之外,没有为完成回调提供任何参数。

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

                                                                                                                              中英对照

                                                                                                                                设置文件的所有者。 除了可能的异常之外,没有为完成回调提供任何参数。

                                                                                                                                fs.fdatasync(fd, callback)#

                                                                                                                                中英对照

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

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

                                                                                                                                  中英对照

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

                                                                                                                                    fs.fsync(fd, callback)#

                                                                                                                                    中英对照

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

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

                                                                                                                                      中英对照

                                                                                                                                        截断文件描述符。 除了可能的异常之外,没有为完成回调提供任何参数。

                                                                                                                                        
                                                                                                                                        

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

                                                                                                                                        中英对照

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

                                                                                                                                          fs.lchmod(path, mode, callback)#

                                                                                                                                          中英对照

                                                                                                                                            更改符号链接的权限。 除了可能的异常之外,没有为完成回调提供任何参数。

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

                                                                                                                                            中英对照

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

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

                                                                                                                                              中英对照

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

                                                                                                                                                fs.link(existingPath, newPath, callback)#

                                                                                                                                                中英对照

                                                                                                                                                  创建从 existingPathnewPath 的新链接。 有关更多详细信息,请参阅 POSIX link(2) 文档。 除了可能的异常之外,没有为完成回调提供任何参数。

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

                                                                                                                                                  中英对照

                                                                                                                                                    获取路径引用的符号链接的 <fs.Stats>。 回调有两个参数 (err, stats),其中 stats<fs.Stats> 对象。 lstat()stat() 相同,除了如果 path 是符号链接,则被统计的是链接本身,而不是它引用的文件。

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

                                                                                                                                                    中英对照

                                                                                                                                                      异步地创建目录。

                                                                                                                                                      
                                                                                                                                                      

                                                                                                                                                      
                                                                                                                                                      

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

                                                                                                                                                      中英对照

                                                                                                                                                        创建唯一的临时目录。

                                                                                                                                                        
                                                                                                                                                        

                                                                                                                                                        
                                                                                                                                                        

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

                                                                                                                                                        中英对照

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

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

                                                                                                                                                          中英对照

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

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

                                                                                                                                                            中英对照

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

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

                                                                                                                                                              中英对照

                                                                                                                                                                fs.read() 函数类似,此版本采用可选的 options 对象。 如果未指定 options 对象,则默认使用上述值。

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

                                                                                                                                                                中英对照

                                                                                                                                                                  读取目录的内容。 回调有两个参数 (err, files),其中 files 是目录中文件名的数组,不包括 '.''..'

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

                                                                                                                                                                  中英对照

                                                                                                                                                                    异步地读取文件的全部内容。

                                                                                                                                                                    
                                                                                                                                                                    

                                                                                                                                                                    
                                                                                                                                                                    

                                                                                                                                                                    
                                                                                                                                                                    

                                                                                                                                                                    
                                                                                                                                                                    

                                                                                                                                                                    文件描述符#

                                                                                                                                                                    中英对照

                                                                                                                                                                      性能考量#

                                                                                                                                                                      中英对照

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

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

                                                                                                                                                                      中英对照

                                                                                                                                                                        读取 path 引用的符号链接的内容。 回调有两个参数 (err, linkString)

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

                                                                                                                                                                        中英对照

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

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

                                                                                                                                                                          中英对照

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

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

                                                                                                                                                                              中英对照

                                                                                                                                                                                异步的 realpath(3)

                                                                                                                                                                                fs.rename(oldPath, newPath, callback)#

                                                                                                                                                                                中英对照

                                                                                                                                                                                  oldPath 处的文件异步重命名为作为 newPath 提供的路径名。 如果 newPath 已经存在,则它将被覆盖。 如果 newPath 是目录,则会引发错误。 除了可能的异常之外,没有为完成回调提供任何参数。

                                                                                                                                                                                  
                                                                                                                                                                                  

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

                                                                                                                                                                                  中英对照

                                                                                                                                                                                    异步的 rmdir(2)。 除了可能的异常之外,没有为完成回调提供任何参数。

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

                                                                                                                                                                                    中英对照

                                                                                                                                                                                      异步地删除文件和目录(以标准 POSIX rm 实用工具为模型)。 除了可能的异常之外,没有为完成回调提供任何参数。

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

                                                                                                                                                                                      中英对照

                                                                                                                                                                                        异步的 stat(2)。 回调有两个参数 (err, stats),其中 stats<fs.Stats> 对象。

                                                                                                                                                                                        
                                                                                                                                                                                        

                                                                                                                                                                                        
                                                                                                                                                                                        

                                                                                                                                                                                        
                                                                                                                                                                                        

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

                                                                                                                                                                                        中英对照

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

                                                                                                                                                                                          
                                                                                                                                                                                          

                                                                                                                                                                                          
                                                                                                                                                                                          

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

                                                                                                                                                                                          中英对照

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

                                                                                                                                                                                            
                                                                                                                                                                                            

                                                                                                                                                                                            fs.unlink(path, callback)#

                                                                                                                                                                                            中英对照

                                                                                                                                                                                              异步地删除文件或符号链接。 除了可能的异常之外,没有为完成回调提供任何参数。

                                                                                                                                                                                              
                                                                                                                                                                                              

                                                                                                                                                                                              fs.unwatchFile(filename[, listener])#

                                                                                                                                                                                              中英对照

                                                                                                                                                                                                停止监视 filename 的变化。 如果指定了 listener,则仅删除该特定监听器。 否则,所有监听器都将被删除,从而有效地停止监视 filename

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

                                                                                                                                                                                                中英对照

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

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

                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                      监视 filename 的变化,其中 filename 是文件或目录。

                                                                                                                                                                                                      注意事项#

                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                      fs.watch API 跨平台并非 100% 一致,并且在某些情况下不可用。

                                                                                                                                                                                                      可用性#

                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                      此功能取决于底层操作系统提供了一种通知文件系统更改的方法。

                                                                                                                                                                                                        索引节点#

                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                        在 Linux 和 macOS 系统上,fs.watch() 解析索引节点的路径并监视索引节点。 如果监视路径被删除并重新创建,则会为其分配一个新的索引节点。 监视将触发删除事件,但将继续监视原始索引节点。 不会发出新索引节点的事件。 这是预期的行为。

                                                                                                                                                                                                        文件名参数#

                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                        仅在 Linux、macOS、Windows 和 AIX 上支持在回调中提供 filename 参数。 即使在支持的平台上,也不能保证始终提供 filename。 因此,不要假设回调中总是提供 filename 参数,如果它为 null,则有一些回退逻辑。

                                                                                                                                                                                                        
                                                                                                                                                                                                        

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

                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                          监视 filename 的变化。 每次访问文件时都会调用回调 listener

                                                                                                                                                                                                          
                                                                                                                                                                                                          

                                                                                                                                                                                                            fs.write(fd, buffer[, offset[, length[, position]]], callback)#

                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                              buffer 写入 fd 指定的文件。

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

                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                string 写入 fd 指定的文件。 如果 string 不是字符串,或者不是具有自有的 toString 函数属性的对象,则会抛出异常。

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

                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                  file 是文件名时,将数据异步地写入文件,如果文件已存在则替换该文件。 data 可以是字符串或缓冲区。

                                                                                                                                                                                                                  
                                                                                                                                                                                                                  

                                                                                                                                                                                                                  
                                                                                                                                                                                                                  

                                                                                                                                                                                                                  
                                                                                                                                                                                                                  

                                                                                                                                                                                                                  将 fs.writeFile() 与文件描述符一起使用#

                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                  file 是文件描述符时,其行为几乎与直接调用 fs.write() 相同,例如:

                                                                                                                                                                                                                  
                                                                                                                                                                                                                  

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

                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                    使用 writev()ArrayBufferView 数组写入 fd 指定的文件。

                                                                                                                                                                                                                    同步的 API#

                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                    同步的 API 同步地执行所有操作,阻塞事件循环,直到操作完成或失败。

                                                                                                                                                                                                                    fs.accessSync(path[, mode])#

                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                      同步地测试用户对 path 指定的文件或目录的权限。 mode 参数是可选的整数,指定要执行的可访问性检查。 查看文件访问的常量以获取可能的 mode 值。 可以创建由两个或多个值的按位或组成的掩码(例如 fs.constants.W_OK | fs.constants.R_OK)。

                                                                                                                                                                                                                      
                                                                                                                                                                                                                      

                                                                                                                                                                                                                      fs.appendFileSync(path, data[, options])#

                                                                                                                                                                                                                      中英对照

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

                                                                                                                                                                                                                        
                                                                                                                                                                                                                        

                                                                                                                                                                                                                        
                                                                                                                                                                                                                        

                                                                                                                                                                                                                        
                                                                                                                                                                                                                        

                                                                                                                                                                                                                        fs.chmodSync(path, mode)#

                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                          有关详细信息,请参阅此 API 的异步版本的文档:fs.chmod()

                                                                                                                                                                                                                          fs.chownSync(path, uid, gid)#

                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                            同步地更改文件的所有者和群组。 返回 undefined。 这是 fs.chown() 的同步版本。

                                                                                                                                                                                                                            fs.closeSync(fd)#

                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                              关闭文件描述符。 返回 undefined

                                                                                                                                                                                                                              fs.copyFileSync(src, dest[, mode])#

                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                同步地复制 srcdest。 默认情况下,如果 dest 已经存在,则会被覆盖。 返回 undefined。 Node.js 不保证复制操作的原子性。 如果在打开目标文件进行写入后发生错误,Node.js 将尝试删除目标文件。

                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                  fs.existsSync(path)#

                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                    如果路径存在则返回 true,否则返回 false

                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                    fs.fchmodSync(fd, mode)#

                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                      设置文件的权限。 返回 undefined

                                                                                                                                                                                                                                      fs.fchownSync(fd, uid, gid)#

                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                        设置文件的所有者。 返回 undefined

                                                                                                                                                                                                                                        fs.fdatasyncSync(fd)#

                                                                                                                                                                                                                                        中英对照

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

                                                                                                                                                                                                                                          fs.fstatSync(fd[, options])#

                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                            获取文件描述符的 <fs.Stats>

                                                                                                                                                                                                                                            fs.fsyncSync(fd)#

                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                              请求将打开文件描述符的所有数据刷新到存储设备。 具体实现是操作系统和设备特定的。 有关更多详细信息,请参考 POSIX fsync(2) 文档。 返回 undefined

                                                                                                                                                                                                                                              fs.ftruncateSync(fd[, len])#

                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                截断文件描述符。 返回 undefined

                                                                                                                                                                                                                                                fs.futimesSync(fd, atime, mtime)#

                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                  fs.futimes() 的同步版本。 返回 undefined

                                                                                                                                                                                                                                                  fs.lchmodSync(path, mode)#

                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                    更改符号链接的权限。 返回 undefined

                                                                                                                                                                                                                                                    fs.lchownSync(path, uid, gid)#

                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                      设置路径的所有者。 返回 undefined

                                                                                                                                                                                                                                                      fs.lutimesSync(path, atime, mtime)#

                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                        更改 path 引用的符号链接的文件系统时间戳。 返回 undefined,或在参数不正确或操作失败时抛出异常。 这是 fs.lutimes() 的同步版本。

                                                                                                                                                                                                                                                        fs.linkSync(existingPath, newPath)#

                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                          创建从 existingPathnewPath 的新链接。 有关更多详细信息,请参阅 POSIX link(2) 文档。 返回 undefined

                                                                                                                                                                                                                                                          fs.lstatSync(path[, options])#

                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                            获取 path 引用的符号链接的 <fs.Stats>

                                                                                                                                                                                                                                                            fs.mkdirSync(path[, options])#

                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                              同步地创建目录。 返回 undefined 或创建的第一个目录路径(如果 recursivetrue)。 这是 fs.mkdir() 的同步版本。

                                                                                                                                                                                                                                                              fs.mkdtempSync(prefix[, options])#

                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                返回创建的目录路径。

                                                                                                                                                                                                                                                                fs.opendirSync(path[, options])#

                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                  同步地打开目录。 参见 opendir(3)

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

                                                                                                                                                                                                                                                                  中英对照

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

                                                                                                                                                                                                                                                                    fs.readdirSync(path[, options])#

                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                      读取目录的内容。

                                                                                                                                                                                                                                                                      fs.readFileSync(path[, options])#

                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                        返回 path 的内容。

                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                        fs.readlinkSync(path[, options])#

                                                                                                                                                                                                                                                                        中英对照

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

                                                                                                                                                                                                                                                                          fs.readSync(fd, buffer, offset, length, position)#

                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                            返回 bytesRead 的数量。

                                                                                                                                                                                                                                                                            fs.readSync(fd, buffer, [options])#

                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                              返回 bytesRead 的数量。

                                                                                                                                                                                                                                                                              fs.readvSync(fd, buffers[, position])#

                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                有关详细信息,请参阅此 API 的异步版本的文档:fs.readv()

                                                                                                                                                                                                                                                                                fs.realpathSync(path[, options])#

                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                  返回解析的路径名。

                                                                                                                                                                                                                                                                                  fs.realpathSync.native(path[, options])#

                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                    同步的 realpath(3)

                                                                                                                                                                                                                                                                                    fs.renameSync(oldPath, newPath)#

                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                      将文件从 oldPath 重命名为 newPath。 返回 undefined

                                                                                                                                                                                                                                                                                      fs.rmdirSync(path[, options])#

                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                        同步的 rmdir(2)。 返回 undefined

                                                                                                                                                                                                                                                                                        fs.rmSync(path[, options])#

                                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                                          同步删除文件和目录(以标准 POSIX rm 实用工具为模型)。 返回 undefined

                                                                                                                                                                                                                                                                                          fs.statSync(path[, options])#

                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                            获取路径的 <fs.Stats>

                                                                                                                                                                                                                                                                                            fs.symlinkSync(target, path[, type])#

                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                              返回 undefined

                                                                                                                                                                                                                                                                                              fs.truncateSync(path[, len])#

                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                截断文件。 返回 undefined。 文件描述符也可以作为第一个参数传入。 在这种情况下,fs.ftruncateSync() 被调用。

                                                                                                                                                                                                                                                                                                fs.unlinkSync(path)#

                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                  同步的 unlink(2)。 返回 undefined

                                                                                                                                                                                                                                                                                                  fs.utimesSync(path, atime, mtime)#

                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                    返回 undefined

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

                                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                                      返回 undefined

                                                                                                                                                                                                                                                                                                      fs.writeSync(fd, buffer[, offset[, length[, position]]])#

                                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                                        有关详细信息,请参阅此 API 的异步版本的文档:fs.write(fd, buffer...)

                                                                                                                                                                                                                                                                                                        fs.writeSync(fd, string[, position[, encoding]])#

                                                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                                                          有关详细信息,请参阅此 API 的异步版本的文档:fs.write(fd, string...)

                                                                                                                                                                                                                                                                                                          fs.writevSync(fd, buffers[, position])#

                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                            有关详细信息,请参阅此 API 的异步版本的文档:fs.writev()

                                                                                                                                                                                                                                                                                                            公共对象#

                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                            公共对象由所有文件系统 API 变体(promise、回调和同步)共享。

                                                                                                                                                                                                                                                                                                            fs.Dir#

                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                            表示目录流的类。

                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                            dir.close()#

                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                              异步地关闭目录的底层资源句柄。 后续读取将导致错误。

                                                                                                                                                                                                                                                                                                              dir.close(callback)#

                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                                异步地关闭目录的底层资源句柄。 后续读取将导致错误。

                                                                                                                                                                                                                                                                                                                dir.closeSync()#

                                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                                同步地关闭目录的底层资源句柄。 后续读取将导致错误。

                                                                                                                                                                                                                                                                                                                dir.path#

                                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                                  提供给 fs.opendir()fs.opendirSync()fsPromises.opendir() 的此目录的只读路径。

                                                                                                                                                                                                                                                                                                                  dir.read()#

                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                    通过 readdir(3) 异步地读取下一个目录条目作为 <fs.Dirent>

                                                                                                                                                                                                                                                                                                                    dir.read(callback)#

                                                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                                                      通过 readdir(3) 异步地读取下一个目录条目作为 <fs.Dirent>

                                                                                                                                                                                                                                                                                                                      dir.readSync()#

                                                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                                                        同步地读取下一个目录条目作为 <fs.Dirent>。 有关更多详细信息,请参阅 POSIX readdir(3) 文档。

                                                                                                                                                                                                                                                                                                                        dir[Symbol.asyncIterator]()#

                                                                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                                                                          异步地遍历目录,直到读取了所有条目。 有关更多详细信息,请参考 POSIX readdir(3) 文档。

                                                                                                                                                                                                                                                                                                                          fs.Dirent#

                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                          目录条目的表示,可以是目录中的文件或子目录,通过从 <fs.Dir> 读取返回。 目录条目是文件名和文件类型对的组合。

                                                                                                                                                                                                                                                                                                                          dirent.isBlockDevice()#

                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                            如果 <fs.Dirent> 对象描述块设备,则返回 true

                                                                                                                                                                                                                                                                                                                            dirent.isCharacterDevice()#

                                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                                              如果 <fs.Dirent> 对象描述字符设备,则返回 true

                                                                                                                                                                                                                                                                                                                              dirent.isDirectory()#

                                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                                                如果 <fs.Dirent> 对象描述文件系统目录,则返回 true

                                                                                                                                                                                                                                                                                                                                dirent.isFIFO()#

                                                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                                                  如果 <fs.Dirent> 对象描述先进先出 (FIFO) 管道,则返回 true

                                                                                                                                                                                                                                                                                                                                  dirent.isFile()#

                                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                                    如果 <fs.Dirent> 对象描述常规文件,则返回 true

                                                                                                                                                                                                                                                                                                                                    dirent.isSocket()#

                                                                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                                                                      如果 <fs.Dirent> 对象描述套接字,则返回 true

                                                                                                                                                                                                                                                                                                                                      dirent.isSymbolicLink()#

                                                                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                                                                        如果 <fs.Dirent> 对象描述符号链接,则返回 true

                                                                                                                                                                                                                                                                                                                                        dirent.name#

                                                                                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                                                                                          <fs.Dirent> 对象引用的文件名。 该值的类型由传给 fs.readdir()fs.readdirSync()options.encoding 决定。

                                                                                                                                                                                                                                                                                                                                          fs.FSWatcher#

                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                            成功调用 fs.watch() 方法将返回新的 <fs.FSWatcher> 对象。

                                                                                                                                                                                                                                                                                                                                            'change' 事件#

                                                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                                                              当监视的目录或文件中的某些内容发生更改时触发。 在 fs.watch() 中查看更多详细信息。

                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              'close' 事件#

                                                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                                                              当监视器停止监视变化时触发。 关闭的 <fs.FSWatcher> 对象在事件句柄中不再可用。

                                                                                                                                                                                                                                                                                                                                              'error' 事件#

                                                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                                                                在监视文件时发生错误时触发。 出错的 <fs.FSWatcher> 对象在事件句柄中不再可用。

                                                                                                                                                                                                                                                                                                                                                watcher.close()#

                                                                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                                                                停止监视给定 <fs.FSWatcher> 上的更改。 一旦停止,<fs.FSWatcher> 对象就不再可用。

                                                                                                                                                                                                                                                                                                                                                watcher.ref()#

                                                                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                                                                  调用时,只要 <fs.FSWatcher> 处于活动状态,就请求 Node.js 事件循环不退出。 多次调用 watcher.ref() 将不起作用。

                                                                                                                                                                                                                                                                                                                                                  watcher.unref()#

                                                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                                                    调用时,活动的 <fs.FSWatcher> 对象不需要 Node.js 事件循环保持活动状态。 如果没有其他活动保持事件循环运行,则进程可能会在调用 <fs.FSWatcher> 对象的回调之前退出。 多次调用 watcher.unref() 将不起作用。

                                                                                                                                                                                                                                                                                                                                                    fs.StatWatcher#

                                                                                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                                                                                      成功调用 fs.watchFile() 方法将返回新的 <fs.StatWatcher> 对象。

                                                                                                                                                                                                                                                                                                                                                      watcher.ref()#

                                                                                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                                                                                        调用时,只要 <fs.StatWatcher> 处于活动状态,就请求 Node.js 事件循环不退出。 多次调用 watcher.ref() 将不起作用。

                                                                                                                                                                                                                                                                                                                                                        watcher.unref()#

                                                                                                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                                                                                                          调用时,活动的 <fs.StatWatcher> 对象不需要 Node.js 事件循环保持活动状态。 如果没有其他活动保持事件循环运行,则进程可能会在调用 <fs.StatWatcher> 对象的回调之前退出。 多次调用 watcher.unref() 将不起作用。

                                                                                                                                                                                                                                                                                                                                                          fs.ReadStream#

                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                            <fs.ReadStream> 的实例是使用 fs.createReadStream() 函数创建和返回的。

                                                                                                                                                                                                                                                                                                                                                            'close' 事件#

                                                                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                                                                            <fs.ReadStream> 的底层文件描述符已关闭时触发。

                                                                                                                                                                                                                                                                                                                                                            'open' 事件#

                                                                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                                                                              <fs.ReadStream> 的文件描述符被打开时触发。

                                                                                                                                                                                                                                                                                                                                                              'ready' 事件#

                                                                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                                                                              <fs.ReadStream> 准备好使用时触发。

                                                                                                                                                                                                                                                                                                                                                              readStream.bytesRead#

                                                                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                                                                                到目前为止已读取的字节数。

                                                                                                                                                                                                                                                                                                                                                                readStream.path#

                                                                                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                                                                                  流正在读取的文件的路径,如 fs.createReadStream() 的第一个参数中所指定。 如果 path 作为字符串传入,则 readStream.path 将是字符串。 如果 path 作为 <Buffer> 传入,则 readStream.path 将是 <Buffer>

                                                                                                                                                                                                                                                                                                                                                                  readStream.pending#

                                                                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                                                                    如果底层文件尚未打开,即在触发 'ready' 事件之前,则此属性为 true

                                                                                                                                                                                                                                                                                                                                                                    fs.Stats#

                                                                                                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                                                                                                    <fs.Stats> 对象提供有关文件的信息。

                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    stats.isBlockDevice()#

                                                                                                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                                                                                                      如果 <fs.Stats> 对象描述块设备,则返回 true

                                                                                                                                                                                                                                                                                                                                                                      stats.isCharacterDevice()#

                                                                                                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                                                                                                        如果 <fs.Stats> 对象描述字符设备,则返回 true

                                                                                                                                                                                                                                                                                                                                                                        stats.isDirectory()#

                                                                                                                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                                                                                                                          如果 <fs.Stats> 对象描述文件系统目录,则返回 true

                                                                                                                                                                                                                                                                                                                                                                          stats.isFIFO()#

                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                            如果 <fs.Stats> 对象描述先进先出 (FIFO) 管道,则返回 true

                                                                                                                                                                                                                                                                                                                                                                            stats.isFile()#

                                                                                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                                                                                              如果 <fs.Stats> 对象描述常规文件,则返回 true

                                                                                                                                                                                                                                                                                                                                                                              stats.isSocket()#

                                                                                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                                                                                                如果 <fs.Stats> 对象描述套接字,则返回 true

                                                                                                                                                                                                                                                                                                                                                                                stats.isSymbolicLink()#

                                                                                                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                                                                                                  如果 <fs.Stats> 对象描述符号链接,则返回 true

                                                                                                                                                                                                                                                                                                                                                                                  stats.dev#

                                                                                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                                                                                    包含文件的设备的数字标识符。

                                                                                                                                                                                                                                                                                                                                                                                    stats.ino#

                                                                                                                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                                                                                                                      文件的文件系统特定的索引节点编号。

                                                                                                                                                                                                                                                                                                                                                                                      stats.mode#

                                                                                                                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                                                                                                                        描述文件类型和模式的位字段。

                                                                                                                                                                                                                                                                                                                                                                                        stats.nlink#

                                                                                                                                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                                                                                                                                          文件存在的硬链接数。

                                                                                                                                                                                                                                                                                                                                                                                          stats.uid#

                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                            拥有文件的用户的数字用户标识符 (POSIX)。

                                                                                                                                                                                                                                                                                                                                                                                            stats.gid#

                                                                                                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                                                                                                              拥有文件的群组的数字群组标识符 (POSIX)。

                                                                                                                                                                                                                                                                                                                                                                                              stats.rdev#

                                                                                                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                                                                                                                如果文件代表设备,则为数字设备标识符。

                                                                                                                                                                                                                                                                                                                                                                                                stats.size#

                                                                                                                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                                                                                                                  文件的大小(以字节为单位)。

                                                                                                                                                                                                                                                                                                                                                                                                  stats.blksize#

                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                                                                                                    i/o 操作的文件系统块大小。

                                                                                                                                                                                                                                                                                                                                                                                                    stats.blocks#

                                                                                                                                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                                                                                                                                      为此文件分配的块数。

                                                                                                                                                                                                                                                                                                                                                                                                      stats.atimeMs#

                                                                                                                                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                                                                                                                                        指示最后一次访问此文件的时间戳,以 POSIX Epoch 以来的毫秒数表示。

                                                                                                                                                                                                                                                                                                                                                                                                        stats.mtimeMs#

                                                                                                                                                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                                                                                                                                                          指示最后一次修改此文件的时间戳,以 POSIX Epoch 以来的毫秒数表示。

                                                                                                                                                                                                                                                                                                                                                                                                          stats.ctimeMs#

                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                            指示最后一次更改文件状态的时间戳,以 POSIX Epoch 以来的毫秒数表示。

                                                                                                                                                                                                                                                                                                                                                                                                            stats.birthtimeMs#

                                                                                                                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                                                                                                                              指示此文件创建时间的时间戳,以 POSIX Epoch 以来的毫秒数表示。

                                                                                                                                                                                                                                                                                                                                                                                                              stats.atimeNs#

                                                                                                                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                仅在 bigint: true 传入到生成对象的方法中时出现。 指示最后一次访问此文件的时间戳,以 POSIX Epoch 以来的纳秒数表示。

                                                                                                                                                                                                                                                                                                                                                                                                                stats.mtimeNs#

                                                                                                                                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                  仅在 bigint: true 传入到生成对象的方法中时出现。 指示最后一次修改此文件的时间戳,以 POSIX Epoch 以来的纳秒数表示。

                                                                                                                                                                                                                                                                                                                                                                                                                  stats.ctimeNs#

                                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                    仅在 bigint: true 传入到生成对象的方法中时出现。 指示最后一次更改文件状态的时间戳,以 POSIX Epoch 以来的纳秒数表示。

                                                                                                                                                                                                                                                                                                                                                                                                                    stats.birthtimeNs#

                                                                                                                                                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                      仅在 bigint: true 传入到生成对象的方法中时出现。 指示此文件创建时间的时间戳,以 POSIX Epoch 以来的纳秒数表示。

                                                                                                                                                                                                                                                                                                                                                                                                                      stats.atime#

                                                                                                                                                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                        指示最后一次访问此文件的时间戳。

                                                                                                                                                                                                                                                                                                                                                                                                                        stats.mtime#

                                                                                                                                                                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                          指示最后一次修改此文件的时间戳。

                                                                                                                                                                                                                                                                                                                                                                                                                          stats.ctime#

                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                            指示最后一次更改文件状态的时间戳。

                                                                                                                                                                                                                                                                                                                                                                                                                            stats.birthtime#

                                                                                                                                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                              指示此文件创建时间的时间戳。

                                                                                                                                                                                                                                                                                                                                                                                                                              统计的时间值#

                                                                                                                                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                              atimeMsmtimeMsctimeMsbirthtimeMs 属性是数值,以毫秒为单位保存相应的时间。 它们的精度是特定于平台的。 当 bigint: true 传给生成对象的方法时,属性将是长整数,否则它们将是数字

                                                                                                                                                                                                                                                                                                                                                                                                                                fs.WriteStream#

                                                                                                                                                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                  <fs.WriteStream> 的实例是使用 fs.createWriteStream() 函数创建和返回的。

                                                                                                                                                                                                                                                                                                                                                                                                                                  'close' 事件#

                                                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                  <fs.WriteStream> 的底层文件描述符已关闭时触发。

                                                                                                                                                                                                                                                                                                                                                                                                                                  'open' 事件#

                                                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                    打开 <fs.WriteStream> 的文件时触发。

                                                                                                                                                                                                                                                                                                                                                                                                                                    'ready' 事件#

                                                                                                                                                                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                    <fs.WriteStream> 准备好使用时触发。

                                                                                                                                                                                                                                                                                                                                                                                                                                    writeStream.bytesWritten#

                                                                                                                                                                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                    到目前为止写入的字节数。 不包括仍在排队等待写入的数据。

                                                                                                                                                                                                                                                                                                                                                                                                                                    writeStream.close([callback])#

                                                                                                                                                                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                      关闭 writeStream。 可以选择接受一个回调,其将在 writeStream 关闭后执行。

                                                                                                                                                                                                                                                                                                                                                                                                                                      writeStream.path#

                                                                                                                                                                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                      流正在写入的文件的路径,如 fs.createWriteStream() 的第一个参数中所指定。 如果 path 作为字符串传入,则 writeStream.path 将是字符串。 如果 path 作为 <Buffer> 传入,则 writeStream.path 将是 <Buffer>

                                                                                                                                                                                                                                                                                                                                                                                                                                      writeStream.pending#

                                                                                                                                                                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                        如果底层文件尚未打开,即在触发 'ready' 事件之前,则此属性为 true

                                                                                                                                                                                                                                                                                                                                                                                                                                        fs.constants#

                                                                                                                                                                                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          返回一个包含文件系统操作常用常量的对象。

                                                                                                                                                                                                                                                                                                                                                                                                                                          FS 常量#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          以下常量由 fs.constants 导出。

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          文件访问的常量#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          以下常量旨在与 fs.access() 一起使用。

                                                                                                                                                                                                                                                                                                                                                                                                                                          文件复制的常量#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          以下常量旨在与 fs.copyFile() 一起使用。

                                                                                                                                                                                                                                                                                                                                                                                                                                          文件打开的常量#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          以下常量旨在与 fs.open() 一起使用。

                                                                                                                                                                                                                                                                                                                                                                                                                                          文件类型的常量#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          以下常量旨在与 <fs.Stats> 对象的 mode 属性一起使用,以确定文件的类型。

                                                                                                                                                                                                                                                                                                                                                                                                                                          文件模式的常量#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          以下常量旨在与 <fs.Stats> 对象的 mode 属性一起使用,以确定文件的访问权限。

                                                                                                                                                                                                                                                                                                                                                                                                                                          注意事项#

                                                                                                                                                                                                                                                                                                                                                                                                                                          回调与基于 promise 的操作的顺序#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          因为它们是由底层线程池异步地执行,所以当使用回调或基于 promise 的方法时无法保证顺序。

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                          文件路径#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          大多数 fs 操作接受可以以字符串、<Buffer> 或使用 file: 协议的 <URL> 对象的形式指定的文件路径。

                                                                                                                                                                                                                                                                                                                                                                                                                                          字符串路径#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          字符串形式的路径被解释为标识绝对或相对文件名的 UTF-8 字符序列。 相对路径将相对于通过调用 process.cwd() 确定的当前工作目录进行解析。

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          文件 URL 路径#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          对于大多数 fs 模块函数,pathfilename 参数可以作为使用 file: 协议的 <URL> 对象传入。

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                          平台特定的注意事项#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          在 Windows 上,带有主机名的 file: <URL> 转换为 UNC 路径,而带有驱动器号的 file: <URL> 则转换为本地绝对路径。 没有主机名也没有驱动器号的 file: <URL> 会导致错误:

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          Buffer 路径#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          使用 <Buffer> 指定的路径主要用于将文件路径视为不透明字节序列的某些 POSIX 操作系统。 在此类系统上,单个文件路径可能包含使用多种字符编码的子序列。 与字符串路径一样,<Buffer> 路径可以是相对的或绝对的:

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          Windows 上的独立驱动器工作目录#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          在 Windows 上,Node.js 遵循独立驱动器工作目录的概念。 当使用不带反斜杠的驱动器路径时,可以观察到此行为。 例如,fs.readdirSync('C:\\') 可能返回与 fs.readdirSync('C:') 不同的结果。 有关详细信息,请参阅此 MSDN 页面

                                                                                                                                                                                                                                                                                                                                                                                                                                          文件描述符#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          在 POSIX 系统上,对于每个进程,内核维护一个当前打开的文件和资源表。 每个打开的文件都分配了一个简单的数字标识符,称为文件描述符。 在系统级,所有文件系统操作都使用这些文件描述符来识别和跟踪每个特定文件。 Windows 系统使用不同但概念上相似的机制来跟踪资源。 为了方便用户,Node.js 抽象了操作系统之间的差异,并为所有打开的文件分配了一个数字文件描述符。

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                          线程池的使用#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          所有基于回调和 promise 的文件系统 API(除了 fs.FSWatcher())都使用 libuv 的线程池。 这可能会对某些应用程序产生令人惊讶的负面性能影响。 有关更多信息,请参阅 UV_THREADPOOL_SIZE 文档。

                                                                                                                                                                                                                                                                                                                                                                                                                                          文件系统标志#

                                                                                                                                                                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                          以下标志在 flag 选项接受字符串的任何地方可用。

                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                            返回顶部