Node.js v18.7.0 文档


目录

fs 文件系统#

中英对照

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



Promise 的示例#

中英对照

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


回调的示例#

中英对照

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


同步的示例#

中英对照

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


Promise 的 API#

中英对照

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

FileHandle#

中英对照

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

'close' 事件#

中英对照

<FileHandle> 已关闭且不再可用时,则触发 'close' 事件。

filehandle.appendFile(data[, options])#

中英对照

    filehandle.writeFile() 的别名。

    filehandle.chmod(mode)#

    中英对照

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

      filehandle.chown(uid, gid)#

      中英对照

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

        filehandle.close()#

        中英对照

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

          
          
          filehandle.createReadStream([options])#

          中英对照

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

            
            

            
            
            filehandle.createWriteStream([options])#

            中英对照

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

              filehandle.datasync()#

              中英对照

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

                filehandle.fd#

                中英对照

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

                  中英对照

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

                    filehandle.read([options])#

                    中英对照

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

                      filehandle.read(buffer[, options])#

                      中英对照

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

                        filehandle.readableWebStream()#

                        中英对照

                          返回可用于读取文件数据的 ReadableStream

                          
                          

                          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(buffer[, options])#

                                          中英对照

                                            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.F_OK 或由 fs.constants.R_OKfs.constants.W_OKfs.constants.X_OK 中的任何一个(例如 fs.constants.W_OK | fs.constants.R_OK)的按位或组成的掩码。 查看文件访问的常量以获取可能的 mode 值。

                                                        
                                                        

                                                        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.cp(src, dest[, options])#

                                                                中英对照

                                                                  将整个目录结构从 src 异步地复制到 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> 对象。

                                                                                                                  
                                                                                                                  

                                                                                                                  fsPromises.constants#

                                                                                                                  中英对照

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

                                                                                                                    回调的 API#

                                                                                                                    中英对照

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

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

                                                                                                                    中英对照

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

                                                                                                                      
                                                                                                                      

                                                                                                                      
                                                                                                                      

                                                                                                                      
                                                                                                                      

                                                                                                                      
                                                                                                                      

                                                                                                                      
                                                                                                                      

                                                                                                                      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.cp(src, dest[, options], callback)#

                                                                                                                                    中英对照

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

                                                                                                                                      fs.createReadStream(path[, options])#

                                                                                                                                      中英对照

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

                                                                                                                                        
                                                                                                                                        

                                                                                                                                        
                                                                                                                                        

                                                                                                                                        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.read(fd, buffer[, 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, buffer[, options], 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.F_OK 或由 fs.constants.R_OKfs.constants.W_OKfs.constants.X_OK 中的任何一个(例如 fs.constants.W_OK | fs.constants.R_OK)的按位或组成的掩码。 查看文件访问的常量以获取可能的 mode 值。

                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                          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.cpSync(src, dest[, options])#

                                                                                                                                                                                                                                                      中英对照

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

                                                                                                                                                                                                                                                        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, buffer[, options])#

                                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                                                有关详细信息,请参阅此 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>。 如果指定了 fd,则 readStream.path 将是 undefined

                                                                                                                                                                                                                                                                                                                                                                                          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.constantsfsPromises.constants 导出。

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  文件访问的常量#

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  以下常量用作传给 fsPromises.access()fs.access()fs.accessSync()mode 参数。

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  文件复制的常量#

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  文件打开的常量#

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  文件类型的常量#

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  文件模式的常量#

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  注意事项#

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  文件路径#

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  字符串路径#

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  文件 URL 路径#

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  对于大多数 node: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 选项接受字符串的任何地方可用。

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    返回顶部