uni.getFileSystemManager()

获取文件管理器

文件管理器对象，用于操作应用可访问的本地文件空间，在app平台是应用沙盒目录。

可实现目录和文件的创建、删除、改名或改路径、遍历目录、获取文件信息、读写文件。

注意：DCloud-、DCloud_、uni-、uni_开头的目录和文件是保留目录。开发者自用的文件目录需避免使用这些前缀。

注意：读取文件API受具体设备内存大小限制，为了在老旧设备具备更好的兼容性，请避免一次性读取大文件的情况（建议文件大小不要超过16M）。

返回值

类型
FileSystemManager
名称 类型 必备 默认值 描述 close any 是 - 关闭文件

FileSystemManager 的方法

readFile(options)

读取本地文件内容

参数

名称	类型	必填	默认值	描述
options	ReadFileOptions	是	-	-
名称 类型 必备 默认值 描述 encoding "base64" | "utf-8" 是 - base64 / utf-8 filePath string.URIString 是 - 文件路径，支持相对地址和绝对地址 success (res: ReadFileSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 通用的错误返回结果回调 complete (res: any) => void | null 否 - 通用的结束返回结果回调

ReadFileSuccessResult 的属性值

名称	类型	必备	默认值	描述
data	string	是	-	-

readFile 兼容性

Android	iOS	web
3.9.0	4.11	x

readFileSync(filePath, encoding?)

FileSystemManager.readFile 的同步版本参数

参数

名称	类型	必填	默认值	描述
filePath	string	是	-	-
encoding	string | null	否	-

返回值

类型
string

readFileSync 兼容性

Android	iOS	web
4.13	x	x

writeFile(options)

写文件

参数

名称	类型	必填	默认值	描述
options	WriteFileOptions	是	-	-
名称 类型 必备 默认值 描述 filePath string.URIString 是 - 文件路径，只支持绝对地址 encoding "ascii" | "base64" | "utf-8" 是 - 指定写入文件的字符编码 支持:ascii base64 utf-8 data string 是 - 写入的文本内容 success (res: FileManagerSuccessResult) => void | null 否 - 通用的正确返回结果回调 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

FileManagerSuccessResult 的属性值

名称	类型	必备	默认值	描述
errMsg	string	是	-	-

writeFile 兼容性

Android	iOS	web
3.9.0	4.11	x

writeFileSync(filePath, data, encoding)

FileSystemManager.writeFile 的同步版本

参数

名称	类型	必填	默认值	描述
filePath	string	是	-	-
data	string	是	-	-
encoding	string	是	-	-

writeFileSync 兼容性

Android	iOS	web
4.13	x	x

unlink(options)

删除文件

参数

名称	类型	必填	默认值	描述
options	UnLinkOptions	是	-	-
名称 类型 必备 默认值 描述 filePath string.URIString 是 - 文件路径，只支持绝对地址 success (res: FileManagerSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

unlink 兼容性

Android	iOS	web
3.9.0	4.11	x

unlinkSync(filePath)

FileSystemManager.unlink 的同步版本

参数

名称	类型	必填	默认值	描述
filePath	string	是	-	-

unlinkSync 兼容性

Android	iOS	web
4.13	x	x

mkdir(options)

创建目录

参数

名称	类型	必填	默认值	描述
options	MkDirOptions	是	-	-
名称 类型 必备 默认值 描述 dirPath string.URIString 是 - 创建的目录路径 (本地路径) recursive boolean 是 - 是否在递归创建该目录的上级目录后再创建该目录。如果对应的上级目录已经存在，则不创建该上级目录。如 dirPath 为 a/b/c/d 且 recursive 为 true，将创建 a 目录，再在 a 目录下创建 b 目录，以此类推直至创建 a/b/c 目录下的 d 目录。 success (res: FileManagerSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

mkdir 兼容性

Android	iOS	web
3.9.0	4.11	x

mkdirSync(dirPath, recursive)

FileSystemManager.mkdir 的同步版本

参数

名称	类型	必填	默认值	描述
dirPath	string	是	-	-
recursive	boolean	是	-	-

mkdirSync 兼容性

Android	iOS	web
4.13	x	x

rmdir(options)

删除目录

参数

名称	类型	必填	默认值	描述
options	RmDirOptions	是	-	-
名称 类型 必备 默认值 描述 dirPath string.URIString 是 - 要删除的目录路径 (本地路径) recursive boolean 是 - 是否递归删除目录。如果为 true，则删除该目录和该目录下的所有子目录以及文件。 success (res: FileManagerSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

rmdir 兼容性

Android	iOS	web
3.9.0	4.11	x

rmdirSync(dirPath, recursive)

FileSystemManager.rmdir 的同步版本

参数

名称	类型	必填	默认值	描述
dirPath	string	是	-	-
recursive	boolean	是	-	-

rmdirSync 兼容性

Android	iOS	web
4.13	x	x

readdir(options)

读取目录内文件列表

参数

名称	类型	必填	默认值	描述
options	ReadDirOptions	是	-	-
名称 类型 必备 默认值 描述 dirPath string.URIString 是 - 要读取的目录路径 (本地路径) success (res: ReadDirSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

ReadDirSuccessResult 的属性值

名称	类型	必备	默认值	描述
files	Array<string>	是	-	-

readdir 兼容性

Android	iOS	web
3.9.0	4.11	x

readdirSync(dirPath)

FileSystemManager.readdir 的同步版本

参数

名称	类型	必填	默认值	描述
dirPath	string	是	-	-

返回值

类型	必备
Array<string> | null	否

readdirSync 兼容性

Android	iOS	web
4.13	x	x

access(options)

判断文件/目录是否存在

参数

名称	类型	必填	默认值	描述
options	AccessOptions	是	-	-
名称 类型 必备 默认值 描述 path string.URIString 是 - 要删除的目录路径 (本地路径) success (res: FileManagerSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

access 兼容性

Android	iOS	web
3.9.0	4.11	x

accessSync(path)

FileSystemManager.access 的同步版本

参数

名称	类型	必填	默认值	描述
path	string	是	-	-

accessSync 兼容性

Android	iOS	web
4.13	x	x

rename(options)

重命名文件。可以把文件从 oldPath 移动到 newPath

参数

名称	类型	必填	默认值	描述
options	RenameOptions	是	-	-
名称 类型 必备 默认值 描述 oldPath string.URIString 是 - 源文件路径，支持本地路径 newPath string.URIString 是 - 新文件路径，支持本地路径 success (res: FileManagerSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

rename 兼容性

Android	iOS	web
3.9.0	4.11	x

renameSync(oldPath, newPath)

FileSystemManager.rename 的同步版本

参数

名称	类型	必填	默认值	描述
oldPath	string	是	-	-
newPath	string	是	-	-

renameSync 兼容性

Android	iOS	web
4.13	x	x

copyFile(options)

复制文件

参数

名称	类型	必填	默认值	描述
options	CopyFileOptions	是	-	-
名称 类型 必备 默认值 描述 srcPath string.URIString 是 - 源文件路径，支持本地路径 destPath string.URIString 是 - 新文件路径，支持本地路径 success (res: FileManagerSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

copyFile 兼容性

Android	iOS	web
3.9.0	4.11	x

copyFileSync(srcPath, destPath)

FileSystemManager.copyFile 的同步版本

参数

名称	类型	必填	默认值	描述
srcPath	string	是	-	-
destPath	string	是	-	-

copyFileSync 兼容性

Android	iOS	web
4.13	x	x

getFileInfo(options)

获取该本地临时文件 或 本地缓存文件 信息

参数

名称	类型	必填	默认值	描述
options	GetFileInfoOptions	是	-	-
名称 类型 必备 默认值 描述 filePath string.URIString 是 - 要读取的文件路径 (本地路径) digestAlgorithm "md5" | "sha1" 是 - md5 / sha1 success (res: GetFileInfoSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

GetFileInfoSuccessResult 的属性值

名称	类型	必备	默认值	描述
digest	string	是	-	-
size	number	是	-	-
errMsg	string	是	-	-

getFileInfo 兼容性

Android	iOS	web
3.9.0	4.11	x

stat(options)

获取文件 Stats 对象

参数

名称	类型	必填	默认值	描述
options	StatOptions	是	-	-
名称 类型 必备 默认值 描述 path string.URIString 是 - 文件/目录路径 (本地路径) recursive boolean 是 - 是否递归获取目录下的每个文件的 Stats 信息 success (res: StatSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

StatSuccessResult 的属性值

名称	类型	必备	默认值	描述
errMsg	string	是	-	-
stats	Array<FileStats>	是	-	-
名称 类型 必备 默认值 描述 path string 是 - - stats Stats 是 - - 名称 类型 必备 默认值 描述 mode number 是 - 文件的类型和存取的权限，对应 POSIX stat.st_mode 注意android中，文件类型只包含是否是目录与文件， 另外在android中这里的权限指的是当前进程对文件或者文件夹是否有读，写，执行的权限， 这里没有与 POSIX stat.st_mode对应的组，其他人等相关权限的数据返回,只有所有者的相关权限 size number 是 - 文件大小，单位：B，对应 POSIX stat.st_size lastAccessedTime number 是 - 文件最近一次被存取或被执行的时间，UNIX 时间戳，对应 POSIX stat.st_atime 注意：android中由于系统限制无法获取该数据 lastModifiedTime number 是 - 文件最后一次被修改的时间，UNIX 时间戳，对应 POSIX stat.st_mtime

Stats 的方法

isDirectory()

判断当前文件是否一个目录

返回值

类型
boolean

isFile()

判断当前文件是否一个普通文件

返回值

类型
boolean

stat 兼容性

Android	iOS	web
3.9.0	4.11	x

statSync(path, recursive)

FileSystemManager.stat 的同步版本

参数

名称	类型	必填	默认值	描述
path	string	是	-	-
recursive	boolean	是	-	-

返回值

类型
Array<FileStats>

statSync 兼容性

Android	iOS	web
4.13	x	x

appendFile(options)

在文件结尾追加内容

参数

名称	类型	必填	默认值	描述
options	AppendFileOptions	是	-	-
名称 类型 必备 默认值 描述 filePath string.URIString 是 - 要追加内容的文件路径 (本地路径) encoding "ascii" | "base64" | "utf-8" 是 - 指定写入文件的字符编码 支持:ascii base64 utf-8 data string 是 - 要追加的文本 success (res: FileManagerSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

appendFile 兼容性

Android	iOS	web
4.13	x	x

appendFileSync(filePath, data, encoding)

FileSystemManager.appendFile 的同步版本

参数

名称	类型	必填	默认值	描述
filePath	string	是	-	-
data	string	是	-	-
encoding	string	是	-	-

appendFileSync 兼容性

Android	iOS	web
4.13	x	x

saveFile(options)

保存临时文件到本地。此接口会移动临时文件，因此调用成功后，tempFilePath 将不可用。

参数

名称	类型	必填	默认值	描述
options	SaveFileOptions	是	-	-
名称 类型 必备 默认值 描述 tempFilePath string.URIString 是 - 临时存储文件路径 (本地路径) filePath string.URIString | null 否 - 要存储的文件路径 (本地路径) success (res: SaveFileSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

SaveFileSuccessResult 的属性值

名称	类型	必备	默认值	描述
savedFilePath	string	是	-	存储后的文件路径 (本地路径)

saveFile 兼容性

Android	iOS	web
4.13	x	x

saveFileSync(tempFilePath, filePath?)

FileSystemManager.saveFile 的同步版本

参数

名称	类型	必填	默认值	描述
tempFilePath	string	是	-	-
filePath	string | null	否	-

返回值

类型
string

saveFileSync 兼容性

Android	iOS	web
4.13	x	x

removeSavedFile(options)

删除该小程序下已保存的本地缓存文件

参数

名称	类型	必填	默认值	描述
options	RemoveSavedFileOptions	是	-	-
名称 类型 必备 默认值 描述 filePath string.URIString 是 - 需要删除的文件路径 (本地路径) success (res: FileManagerSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

removeSavedFile 兼容性

Android	iOS	web
4.13	x	x

unzip(options)

解压文件

参数

名称	类型	必填	默认值	描述
options	UnzipFileOptions	是	-	-
名称 类型 必备 默认值 描述 zipFilePath string 是 - 源文件路径，支持本地路径, 只可以是 zip 压缩文件 targetPath string 是 - 目标目录路径, 支持本地路径 success (res: FileManagerSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

unzip 兼容性

Android	iOS	web
4.13	x	x

getSavedFileList(options)

获取该已保存的本地缓存文件列表

参数

名称	类型	必填	默认值	描述
options	GetSavedFileListOptions	是	-	-
名称 类型 必备 默认值 描述 success (res: GetSavedFileListResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

GetSavedFileListResult 的属性值

名称	类型	必备	默认值	描述
fileList	Array<string>	是	-	-

getSavedFileList 兼容性

Android	iOS	web
4.13	x	x

truncate(options)

对文件内容进行截断操作

参数

名称	类型	必填	默认值	描述
options	TruncateFileOptions	是	-	-
名称 类型 必备 默认值 描述 filePath string.URIString 是 - 要截断的文件路径 (本地路径) length number 是 - 截断位置，默认0。如果 length 小于文件长度（字节），则只有前面 length 个字节会保留在文件中，其余内容会被删除； 如果 length 大于文件长度，不做处理 success (res: FileManagerSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

truncate 兼容性

Android	iOS	web
4.13	x	x

truncateSync(filePath, length?)

对文件内容进行截断操作 (truncate 的同步版本)

参数

名称	类型	必填	默认值	描述
filePath	string	是	-	-
length	number	否	-	-

truncateSync 兼容性

Android	iOS	web
4.13	x	x

readCompressedFile(options)

读取指定压缩类型的本地文件内容

参数

名称	类型	必填	默认值	描述
options	ReadCompressedFileOptions	是	-	-
名称 类型 必备 默认值 描述 filePath string.URIString 是 - 要读取的文件的路径 (本地用户文件或代码包文件) compressionAlgorithm string 是 - 文件压缩类型，目前仅支持 'br'。 success (res: ReadCompressedFileResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

ReadCompressedFileResult 的属性值

名称	类型	必备	默认值	描述
data	string	是	-	-

readCompressedFile 兼容性

Android	iOS	web
4.13	x	x

readCompressedFileSync(filePath, compressionAlgorithm)

同步读取指定压缩类型的本地文件内容

参数

名称	类型	必填	默认值	描述
filePath	string	是	-	-
compressionAlgorithm	string	是	-	-

返回值

类型
string

readCompressedFileSync 兼容性

Android	iOS	web
4.13	x	x

open(options)

打开文件，返回文件描述符

参数

名称	类型	必填	默认值	描述
options	OpenFileOptions	是	-	-
名称 类型 必备 默认值 描述 filePath string.URIString 是 - 要追加内容的文件路径 (本地路径) flag "a" | "ax" | "a+" | "ax+" | "r" | "r+" | "w" | "wx" | "w+" | "wx" | "wx+" 是 - 文件系统标志，默认值: 'r' success (res: OpenFileSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

OpenFileSuccessResult 的属性值

名称	类型	必备	默认值	描述
fd	string	是	-	-

open 兼容性

Android	iOS	web
4.13	x	x

openSync(options)

同步打开文件，返回文件描述符

参数

名称	类型	必填	默认值	描述
options	OpenFileSyncOptions	是	-	-
名称 类型 必备 默认值 描述 filePath string.URIString 是 - 要追加内容的文件路径 (本地路径) flag "a" | "ax" | "a+" | "ax+" | "r" | "r+" | "w" | "wx" | "w+" | "wx" | "wx+" 是 - 文件系统标志，默认值: 'r'

返回值

类型
string

openSync 兼容性

Android	iOS	web
4.13	x	x

write(options)

写入文件

参数

名称	类型	必填	默认值	描述
options	WriteOptions	是	-	-
名称 类型 必备 默认值 描述 fd string 是 - 文件描述符。fd 通过 FileSystemManager.open 或 FileSystemManager.openSync 接口获得 data string 是 - 写入的内容 encoding "ascii" | "base64" | "utf-8" 是 - 指定写入文件的字符编码 支持:ascii base64 utf-8 success (res: WriteResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

WriteResult 的属性值

名称	类型	必备	默认值	描述
bytesWritten	number	是	-	实际被写入到文件中的字节数（注意，被写入的字节数不一定与被写入的字符串字符数相同）

write 兼容性

Android	iOS	web
4.13	x	x

writeSync(options)

同步写入文件

参数

名称	类型	必填	默认值	描述
options	WriteSyncOptions	是	-	-
名称 类型 必备 默认值 描述 fd string 是 - 文件描述符。fd 通过 FileSystemManager.open 或 FileSystemManager.openSync 接口获得 data string 是 - 写入的内容 encoding "ascii" | "base64" | "utf-8" 是 - 指定写入文件的字符编码 支持:ascii base64 utf-8

返回值

类型
WriteResult

writeSync 兼容性

Android	iOS	web
4.13	x	x

closeSync(options)

同步关闭文件

参数

名称	类型	必填	默认值	描述
options	CloseSyncOptions	是	-	-
名称 类型 必备 默认值 描述 fd string 是 - 需要被关闭的文件描述符。fd 通过 FileSystemManager.open 或 FileSystemManager.openSync 接口获得

closeSync 兼容性

Android	iOS	web
4.13	x	x

fstat(options)

获取文件的状态信息

参数

名称	类型	必填	默认值	描述
options	FStatOptions	是	-	-
名称 类型 必备 默认值 描述 fd string 是 - 文件描述符。fd 通过 FileSystemManager.open 或 FileSystemManager.openSync 接口获得 success (res: FStatSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

FStatSuccessResult 的属性值

名称	类型	必备	默认值	描述
stats	Stats	是	-	Stats 对象，包含了文件的状态信息

fstat 兼容性

Android	iOS	web
4.13	x	x

fstatSync(options)

同步获取文件的状态信息

参数

名称	类型	必填	默认值	描述
options	FStatSyncOptions	是	-	-
名称 类型 必备 默认值 描述 fd string 是 - 文件描述符。fd 通过 FileSystemManager.open 或 FileSystemManager.openSync 接口获得

返回值

类型
Stats

fstatSync 兼容性

Android	iOS	web
4.13	x	x

ftruncate(options)

对文件内容进行截断操作

参数

名称	类型	必填	默认值	描述
options	FTruncateFileOptions	是	-	-
名称 类型 必备 默认值 描述 fd string 是 - 文件描述符。fd 通过 FileSystemManager.open 或 FileSystemManager.openSync 接口获得 length number 是 - 截断位置，默认0。如果 length 小于文件长度（字节），则只有前面 length 个字节会保留在文件中，其余内容会被删除； 如果 length 大于文件长度，不做处理 success (res: FileManagerSuccessResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

ftruncate 兼容性

Android	iOS	web
4.13	x	x

ftruncateSync(options)

同步对文件内容进行截断操作

参数

名称	类型	必填	默认值	描述
options	FTruncateFileSyncOptions	是	-	-
名称 类型 必备 默认值 描述 fd string 是 - 文件描述符。fd 通过 FileSystemManager.open 或 FileSystemManager.openSync 接口获得 length number 是 - 截断位置，默认0。如果 length 小于文件长度（字节），则只有前面 length 个字节会保留在文件中，其余内容会被删除； 如果 length 大于文件长度，不做处理

ftruncateSync 兼容性

Android	iOS	web
4.13	x	x

readZipEntry(options)

读取压缩包内的文件

参数

名称	类型	必填	默认值	描述
options	ReadZipEntryOptions	是	-	-
名称 类型 必备 默认值 描述 filePath string.URIString 是 - 要读取的压缩包的路径 (本地路径) encoding "ascii" | "base64" | "utf-8" 是 - 统一指定读取文件的字符编码，只在 entries 值为"all"时有效。 如果 entries 值为"all"且不传 encoding，则以 string 格式读取文件的内容 entries Array<EntryItem> | null 否 - 要读取的压缩包内的文件列表（当不传入时表示读取压缩包内所有文件） 名称 类型 必备 默认值 描述 path string 是 - 压缩包内文件路径 encoding "ascii" | "base64" | "base64" 是 - 指定写入文件的字符编码 支持:ascii base64 utf-8 success (res: EntriesResult) => void | null 否 - 接口调用的回调函数 fail (res: UniError) => void | null 否 - 接口调用失败的回调函数 complete (res: any) => void | null 否 - 接口调用结束的回调函数（调用成功、失败都会执行）

EntriesResult 的属性值

名称	类型	必备	默认值	描述
result	Map<string, ZipFileItem>	是	-	文件路径

readZipEntry 兼容性

Android	iOS	web
4.13	x	x

FileSystemManager 兼容性

	Android	iOS	web
close	4.13	x	x

getFileSystemManager 兼容性

Android	iOS	web
3.9.0	4.11	x

特殊说明

app-ios平台暂时仅支持在uvue文件中使用文件管理器对象，uts插件中暂不支持

参见

相关 Bug

示例

hello uni-app x

<template>
 <!-- #ifdef APP -->
 <text>显示简易操作日志,详细日志需真机运行查看</text><button size="mini" @click="log=''">清空日志</button>
 <text style="margin: 2px; padding: 2px; border: 1px solid #000000;">{{ log }}</text>
 <scroll-view style="flex: 1;">
 <!-- #endif -->
   <button class="btnstyle" type="primary" @tap="statFileInfoTest"
     id="btn-stat-file">递归获取目录files的Stats对象{{statFile}}</button>
   <button class="btnstyle" type="primary" @tap="mkdirTest" id="btn-mkdir">创建文件夹{{mkdirFile}}</button>
   <button class="btnstyle" type="primary" @tap="writeFileTest" id="btn-write-file">覆盖写入文件{{writeFile}}</button>
   <button class="btnstyle" type="primary" @tap="readDirTest" id="btn-read-dir">读取文件夹{{readDir}}</button>
   <button class="btnstyle" type="primary" @tap="readFileTest" id="btn-read-file">读取文件{{readFile}}</button>
   <button class="btnstyle" type="primary" @tap="copyFileTest"
     id="btn-copy-file">复制文件{{copyFromFile}}到{{copyToFile}}</button>
   <button class="btnstyle" type="primary" @tap="renameFileTest"
     id="btn-rename-file">重命名文件{{renameFromFile}}到{{renameToFile}}</button>
   <button class="btnstyle" type="primary" @tap="accessFileTest" id="btn-access-file">判断文件{{accessFile}}是否存在</button>
   <button class="btnstyle" type="primary" @tap="getFileInfoTest"
     id="btn-get-file-info">获取文件信息{{getFileInfoFile}}</button>
   <button class="btnstyle" type="primary" @tap="unlinkTest" id="btn-unlink-file">删除文件{{unlinkFile}}</button>
   <button class="btnstyle" type="primary" @tap="copyStaticToFilesTest"
     id="btn-copyStatic-file">从static目录复制文件到a目录</button>
   <button class="btnstyle" type="primary" @tap="unlinkAllFileTest"
     id="btn-clear-file">删除文件夹{{rmDirFile}}下的所有文件</button>
   <button class="btnstyle" type="primary" @tap="rmdirTest" id="btn-remove-dir">删除文件夹{{rmDirFile}}</button>


   <!-- #ifdef APP-ANDROID -->
   <button class="btnstyle" type="primary" @tap="statFileInfoSyncTest"
     id="btn-stat-file-sync">同步递归获取目录files的Stats对象{{statFile}}</button>
   <button class="btnstyle" type="primary" @tap="appendFileTest" id="btn-append-file">在文件{{readFile}}结尾追加内容</button>
   <button class="btnstyle" type="primary" @tap="appendFileSyncTest"
     id="btn-append-file-sync">同步在文件{{readFile}}结尾追加内容</button>
   <button class="btnstyle" type="primary" @tap="writeFileSyncTest"
     id="btn-write-file-sync">同步覆盖写入文件{{writeFile}}</button>
   <button class="btnstyle" type="primary" @tap="readFileSyncTest" id="btn-read-file-sync">同步读取文件{{readFile}}</button>
   <button class="btnstyle" type="primary" @tap="unlinkSyncTest"
     id="btn-unlink-file-sync">同步删除文件{{unlinkFile}}</button>
   <button class="btnstyle" type="primary" @tap="mkdirSyncTest" id="btn-mkdir-sync">同步创建文件夹{{mkdirFile}}</button>
   <button class="btnstyle" type="primary" @tap="rmdirSyncTest" id="btn-remove-dir-sync">同步删除文件夹{{rmDirFile}}</button>
   <button class="btnstyle" type="primary" @tap="readDirSyncTest" id="btn-read-dir-sync">同步读取文件夹{{readDir}}</button>
   <button class="btnstyle" type="primary" @tap="accessFileSyncTest"
     id="btn-access-file-sync">同步判断文件{{accessFile}}是否存在</button>
   <button class="btnstyle" type="primary" @tap="renameFileSync"
     id="btn-rename-file-sync">同步重命名文件{{renameFromFile}}到{{renameToFile}}</button>
   <button class="btnstyle" type="primary" @tap="copyFileSyncTest"
     id="btn-copy-file-sync">同步复制文件{{copyFromFile}}到{{copyToFile}}</button>
   <button class="btnstyle" type="primary" @tap="saveFileTest" id="btn-save-file">保存临时文件到本地</button>
   <button class="btnstyle" type="primary" @tap="saveFileSyncTest" id="btn-save-file-sync">同步保存临时文件到本地</button>
   <button class="btnstyle" type="primary" @tap="removeSavedFileTest" id="btn-remove-saved-file">删除已保存的本地文件</button>
   <button class="btnstyle" type="primary" @tap="unzipFileTest" id="btn-unzip-file-sync">解压文件</button>
   <button class="btnstyle" type="primary" @tap="getSavedFileListTest"
     id="btn-getsaved-filelist">获取该已保存的本地缓存文件列表</button>
   <button class="btnstyle" type="primary" @tap="truncateFileTest"
     id="btn-truncate-file">对文件{{writeFile}}内容进行截断操作</button>
   <button class="btnstyle" type="primary" @tap="truncateFileSyncTest"
     id="btn-truncate-file-sync">同步对文件{{writeFile}}内容进行截断操作</button>
   <button class="btnstyle" type="primary" @tap="readCompressedFileTest"
     id="btn-compressed-file">读取指定压缩类型的本地文件内容</button>
   <button class="btnstyle" type="primary" @tap="readCompressedFileSyncTest"
     id="btn-compressed-file-sync">同步读取指定压缩类型的本地文件内容</button>
   <button class="btnstyle" type="primary" @tap="openFileTest" id="btn-open-file">打开文件{{readFile}}，返回描述符</button>
   <button class="btnstyle" type="primary" @tap="openFileSyncTest('r')"
     id="btn-open-file-sync">同步打开文件{{readFile}}，返回描述符</button>
   <button class="btnstyle" type="primary" @tap="closeTest" id="btn-close-file">通过文件描述符关闭文件{{readFile}}</button>
   <button class="btnstyle" type="primary" @tap="closeSyncTest"
     id="btn-close-file-sync">通过文件描述符同步关闭文件{{readFile}}</button>
   <button class="btnstyle" type="primary" @tap="writeTest" id="btn-write">通过文件描述符写入文件{{readFile}}</button>
   <button class="btnstyle" type="primary" @tap="writeSyncTest" id="btn-write-sync">同步通过文件描述符写入文件{{readFile}}</button>
   <button class="btnstyle" type="primary" @tap="fstatTest" id="btn-fstat-file">通过文件描述符获取{{statFile}}的状态信息</button>
   <button class="btnstyle" type="primary" @tap="fstatSyncTest"
     id="btn-fstat-file-sync">同步通过文件描述符获取{{statFile}}的状态信息</button>
   <button class="btnstyle" type="primary" @tap="ftruncateFileTest"
     id="btn-ftruncate-file">通过文件描述符对文件{{writeFile}}内容进行截断</button>
   <button class="btnstyle" type="primary" @tap="ftruncateFileSyncTest"
     id="btn-ftruncate-file-sync">同步通过文件描述符对文件{{writeFile}}内容进行截断</button>
   <button class="btnstyle" type="primary" @tap="readZipEntry" id="btn-readzip-entry">读取压缩包内的文件</button>
   <view style="height: 4px;"></view>
   <!-- #endif -->
 <!-- #ifdef APP -->
 </scroll-view>
 <!-- #endif -->
</template>

<script>
 export default {

   data() {
     return {
       log: "",
       /**
        * 自动化测试需要关闭log
        */
       logAble: true,
       fileListSuccess: [] as string[],
       fileListComplete: [] as string[],
       accessFileRet: '',
       lastFailError: new UniError("uni-file-manager", 1300000, "mock error"),
       lastCompleteError: new UniError("uni-file-manager", 1300000, "mock error"),
       readDir: 'a',
       readFileRet: "",
       writeFileContent: "中文 en.\r\n\t换行",
       appendFileContent: "append content",
       getFileInfoAlgorithm: "md5",
       getFileInfoSize: -1,
       getFileInfoDigest: "",
       unlinkFile: 'a/1.txt',
       accessFile: 'a/1.txt',
       writeFile: 'a/1.txt',
       writeData: 'insert data哈哈哈',
       brFile: 'a/1.txt.br',
       temFile: 'a/1.txt',
       copyFromFile: 'a/1.txt',
       copyToFile: 'a/2.txt',
       renameFromFile: 'a/2.txt',
       renameToFile: 'a/3.txt',
       getFileInfoFile: 'a/1.txt',
       statFile: '',
       rmDirFile: 'a',
       mkdirFile: 'a',
       readFile: 'a/1.txt',
       recursiveVal: true,
       done: false,
       writeFileEncoding: "utf-8",
       readFileEncoding: "utf-8",
       statsRet: [] as Array<FileStats>,
       unzipFile: 'zip/1.zip',
       targetZip: "unzip",
       renameFileRet: '',
       saveFileRet: '',
       removeSavedFileRet: '',
       fd: '',
       closeFileRet: '',
       bytesWritten: 0,
       fstat: null as Stats | null,
       ftruncateRet: '',
       readZipFile: 'to.zip',
       getSavedFileListRet: '',
       /**
        * 待测试的全局环境变量
        */
       basePath: uni.env.USER_DATA_PATH,
       copyToBasePath: uni.env.USER_DATA_PATH,
       globalTempPath: uni.env.CACHE_PATH,
       globalRootPath: uni.env.SANDBOX_PATH,
       globalUserDataPath: uni.env.USER_DATA_PATH
     }
   },
   onLoad() {
   },

   methods: {
     statFileInfoTest: function (_ : any) {
       const fileManager = uni.getFileSystemManager()
       fileManager.stat({
         // path: `${this.basePath}${this.statFile}`, //USER_DATA_PATH
         path: `${this.globalTempPath}${this.statFile}`, //CACHE_PATH
         recursive: this.recursiveVal,
         success: (res : StatSuccessResult) => {
           if (this.logAble) {
             this.log += 'statFileInfoTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('statFileInfoTest success', res)
           this.statsRet = res.stats
           console.log('this.statsRet', this.statsRet)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'statFileInfoTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('statFileInfoTest fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           console.log("statFileInfoTest complete", res)
           this.done = true
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }
         }
       } as StatOptions)
     },

     getFileInfoTest: function () {
       const fileManager = uni.getFileSystemManager()

       fileManager.getFileInfo({
         filePath: `${this.basePath}${this.getFileInfoFile}`,
         digestAlgorithm: this.getFileInfoAlgorithm,
         success: (res : GetFileInfoSuccessResult) => {
           if (this.logAble) {
             this.log += 'getFileInfoTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
           this.getFileInfoSize = res.size
           this.getFileInfoDigest = res.digest
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'getFileInfoTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           console.log("complete", res)
           this.done = true
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }
         }
       } as GetFileInfoOptions)
     },

     copyFileTest: function () {
       const fileManager = uni.getFileSystemManager()

       fileManager.copyFile({
         srcPath: `${this.basePath}${this.copyFromFile}`,
         destPath: `${this.copyToBasePath}${this.copyToFile}`,
         success: (res : FileManagerSuccessResult) => {
           if (this.logAble) {
             this.log += 'copyFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'copyFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           console.log("complete", res)
           this.done = true
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }
         }
       } as CopyFileOptions)
     },

     renameFileTest: function () {
       const fileManager = uni.getFileSystemManager()

       fileManager.rename({
         oldPath: `${this.basePath}${this.renameFromFile}`,
         newPath: `${this.basePath}${this.renameToFile}`,
         success: (res) => {
           if (this.logAble) {
             this.log += 'renameFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'renameFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           this.done = true
           console.log("complete", res)
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }
         }
       } as RenameOptions)
     },

     readDirTest: function () {
       const fileManager = uni.getFileSystemManager()
       fileManager.readdir({
         dirPath: `${this.basePath}${this.readDir}`,
         success: (res : ReadDirSuccessResult) => {
           if (this.logAble) {
             this.log += 'readDirTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log("success", res)
           this.fileListSuccess = res.files
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'readDirTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           console.log("complete", res)
           this.done = true
           if (res instanceof UniError) {
             this.lastCompleteError = res
           } else {
             this.fileListComplete = (res as ReadDirSuccessResult).files
           }
         }
       } as ReadDirOptions)
     },

     writeFileTest: function (_ : any) {
       const fileManager = uni.getFileSystemManager()

       fileManager.writeFile({
         filePath: `${this.basePath}${this.writeFile}`,
         data: this.writeFileContent,
         encoding: this.writeFileEncoding,
         success: (res) => {
           if (this.logAble) {
             this.log += 'writeFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'writeFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail')
           this.lastFailError = res
         },
         complete: (res : any) => {
           this.done = true
           console.log("complete")
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }

         }
       } as WriteFileOptions)
     },

     readFileTest: function () {
       const fileManager = uni.getFileSystemManager()

       fileManager.readFile({
         filePath: `${this.basePath}${this.readFile}`,
         encoding: this.readFileEncoding,
         success: (res : ReadFileSuccessResult) => {
           if (this.logAble) {
             this.log += 'readFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
           this.readFileRet = res.data
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'readFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           console.log("complete", res)
           this.done = true
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }
         }
       } as ReadFileOptions)
     },

     rmdirTest: function () {
       const fileManager = uni.getFileSystemManager()
       fileManager.rmdir({
         dirPath: `${this.basePath}${this.rmDirFile}`,
         recursive: this.recursiveVal,
         success: (res : FileManagerSuccessResult) => {
           if (this.logAble) {
             this.log += 'rmdirTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'rmdirTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           console.log("complete", res)
           this.done = true
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }
         }
       } as RmDirOptions)
     },

     mkdirTest: function () {
       // 准备测试数据
       const fileManager = uni.getFileSystemManager()

       fileManager.mkdir({
         dirPath: `${this.basePath}${this.mkdirFile}`,
         recursive: this.recursiveVal,
         success: (res : FileManagerSuccessResult) => {
           if (this.logAble) {
             this.log += 'mkdirTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'mkdirTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }
           this.done = true
           console.log("complete", res)
         }
       } as MkDirOptions)

     },
     accessFileTest: function () {
       this.accessFileRet = ''
       const fileManager = uni.getFileSystemManager()
       fileManager.access({
         path: `${this.basePath}${this.accessFile}`,
         success: (res : FileManagerSuccessResult) => {
           if (this.logAble) {
             this.log += 'accessFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
           this.accessFileRet = res.errMsg
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'accessFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }
           console.log("complete", res)
           this.done = true
         }
       } as AccessOptions)

     },
     unlinkTest: function () {
       const fileManager = uni.getFileSystemManager()

       fileManager.unlink({
         filePath: `${this.basePath}${this.unlinkFile}`,
         success: (res : FileManagerSuccessResult) => {
           if (this.logAble) {
             this.log += 'unlinkTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'unlinkTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }
           console.log("complete", res)
           this.done = true
         }
       } as UnLinkOptions)
     },
     unlinkAllFileTest: function () {
       const fileManager = uni.getFileSystemManager()
       fileManager.readdir({
         dirPath: `${this.basePath}${this.rmDirFile}`,
         success: (res : ReadDirSuccessResult) => {
           console.log("success to readdir", res)
           res.files.forEach(element => {
             console.log(element)
             let filePath : string
             if (this.rmDirFile.length <= 0) {
               filePath = `${this.basePath}${element}`
             } else {
               filePath = `${this.basePath}${this.rmDirFile}/${element}`
             }
             fileManager.unlink({
               filePath: filePath,
               success: (res : FileManagerSuccessResult) => {
                 if (this.logAble) {
                   this.log += 'unlinkAllFileTest success:' + JSON.stringify(res) + '\n\n'
                 }
                 console.log('success unlink', res)
               },
               fail: (res : UniError) => {
                 if (this.logAble) {
                   this.log += 'unlinkAllFileTest fail:' + JSON.stringify(res) + '\n\n'
                 }
                 console.log('fail unlink', res)
                 this.lastFailError = res
               },
               complete: (res : any) => {
                 if (res instanceof UniError) {
                   this.lastCompleteError = res
                 }
                 console.log("complete unlink", res)
                 this.done = true
               }
             } as UnLinkOptions)
           });
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'unlinkAllFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail to readdir', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           console.log("complete readdir", res)
           this.done = true
           if (res instanceof UniError) {
             this.lastCompleteError = res
           } else {
             this.fileListComplete = (res as ReadDirSuccessResult).files
           }
         }
       } as ReadDirOptions)
     },
     copyStaticToFilesTest: function () {
       const fileManager = uni.getFileSystemManager()

       fileManager.copyFile({
         srcPath: "/static/list-mock/mock.json",
         destPath: `${this.copyToBasePath}/a/mock.json`,
         success: (res : FileManagerSuccessResult) => {
           if (this.logAble) {
             this.log += 'copyFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'copyFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           console.log("complete", res)
           this.done = true
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }
         }
       } as CopyFileOptions)
     },
     //start
     appendFileTest: function (_ : any) {
       const fileManager = uni.getFileSystemManager()
       fileManager.appendFile({
         filePath: `${this.basePath}${this.writeFile}`,
         data: this.appendFileContent,
         encoding: this.writeFileEncoding,
         success: (res : FileManagerSuccessResult) => {
           if (this.logAble) {
             this.log += 'appendFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'appendFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail')
           this.lastFailError = res
         },
         complete: (res : any) => {
           this.done = true
           console.log("complete")
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }

         }
       } as AppendFileOptions)
     },
     writeFileSyncTest: function (_ : any) {
       try {
         const fileManager = uni.getFileSystemManager()
         fileManager.writeFileSync(`${this.basePath}${this.writeFile}`, this.writeFileContent, this.writeFileEncoding)
         if (this.logAble) {
           this.log += 'writeFileSyncTest success:' + '\n\n'
         }
         this.done = true
       } catch (e) {
         if (this.logAble) {
           this.log += 'writeFileSyncTest fail:' + e + '\n\n'
         }
         this.done = true
       }

     },
     readFileSyncTest: function () {
       try {
         const fileManager = uni.getFileSystemManager()
         let data = fileManager.readFileSync(
           `${this.basePath}${this.readFile}`,
           this.readFileEncoding)
         if (this.logAble) {
           this.log += 'readFileSyncTest result:' + data + '\n\n'
         }
         this.done = true
         this.readFileRet = data
       } catch (e) {
         if (this.logAble) {
           this.log += 'readFileSyncTest fail:' + e + '\n\n'
         }
         this.done = true
       }

     },
     unlinkSyncTest: function () {
       try {
         const fileManager = uni.getFileSystemManager()
         fileManager.unlinkSync(
           `${this.basePath}${this.unlinkFile}`)
         this.done = true
       } catch (e) {
         if (this.logAble) {
           this.log += 'unlinkSyncTest fail:' + e + '\n\n'
         }
         this.done = true
       }
     },
     mkdirSyncTest: function () {
       // 准备测试数据
       try {
         const fileManager = uni.getFileSystemManager()
         fileManager.mkdirSync(`${this.basePath}${this.mkdirFile}`, this.recursiveVal)
         this.done = true
       } catch (e) {
         this.done = true
         if (this.logAble) {
           this.log += 'mkdirSyncTest fail:' + e + '\n\n'
         }
       }

     },
     rmdirSyncTest: function () {
       try {
         const fileManager = uni.getFileSystemManager()
         fileManager.rmdirSync(
           `${this.basePath}${this.rmDirFile}`,
           this.recursiveVal)
         this.done = true
       } catch (e) {
         if (this.logAble) {
           this.log += 'rmdirSyncTest fail:' + e + '\n\n'
         }
         this.done = true
       }
     },
     readDirSyncTest: function () {
       try {
         const fileManager = uni.getFileSystemManager()
         let res = fileManager.readdirSync(
           `${this.basePath}${this.readDir}`)
         if (this.logAble) {
           this.log += 'readDirTest success:' + JSON.stringify(res) + '\n\n'
         }
         if (res != null) {
           this.fileListSuccess = res
         }
         this.done = true
       } catch (e) {
         if (this.logAble) {
           this.log += 'rmdirSyncTest fail:' + e + '\n\n'
         }
         this.done = true
       }
     },
     accessFileSyncTest: function () {
       this.accessFileRet = ''
       const fileManager = uni.getFileSystemManager()
       try {
         fileManager.accessSync(`${this.basePath}${this.accessFile}`)
         this.done = true
         this.accessFileRet = 'access:ok'
       } catch (e) {
         if (this.logAble) {
           this.log += 'rmdirSyncTest fail:' + e + '\n\n'
         }
         this.done = true
       }
     },
     renameFileSync: function () {
       const fileManager = uni.getFileSystemManager()
       try {
         fileManager.renameSync(`${this.basePath}${this.renameFromFile}`,
           `${this.basePath}${this.renameToFile}`)
         this.done = true
         this.renameFileRet = "rename:ok"

       } catch (e) {
         if (this.logAble) {
           this.log += 'rmdirSyncTest fail:' + e + '\n\n'
         }
         console.log('renameSync:' + e)
         this.done = true
       }
     },
     copyFileSyncTest: function () {
       const fileManager = uni.getFileSystemManager()
       try {
         fileManager.copyFileSync(
           `${this.basePath}${this.copyFromFile}`,
           `${this.copyToBasePath}${this.copyToFile}`)
         this.done = true
       } catch (e) {
         if (this.logAble) {
           this.log += 'rmdirSyncTest fail:' + e + '\n\n'
         }
         this.done = true
       }
     },
     appendFileSyncTest: function (_ : any) {
       const fileManager = uni.getFileSystemManager()
       try {
         fileManager.appendFileSync(
           `${this.basePath}${this.writeFile}`,
           this.appendFileContent,
           this.writeFileEncoding)
         this.done = true
       } catch (e) {
         if (this.logAble) {
           this.log += 'rmdirSyncTest fail:' + e + '\n\n'
         }
         this.done = true
       }
     },
     saveFileTest: function (_ : any) {
       const fileManager = uni.getFileSystemManager()
       fileManager.saveFile({
         tempFilePath: `${this.globalTempPath}${this.temFile}`,
         // filePath:`${this.basePath}local/`,
         success: (res : SaveFileSuccessResult) => {
           if (this.logAble) {
             this.log += 'saveFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
           this.saveFileRet = res.savedFilePath
           this.done = true
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'saveFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('saveFileTest fail', res)
           this.lastFailError = res
           this.done = true
         },
         complete: (_) => {
           this.done = true
         }
       } as SaveFileOptions)
     },
     saveFileSyncTest: function (_ : any) {
       const fileManager = uni.getFileSystemManager()
       try {
         fileManager.saveFileSync(
           `${this.globalTempPath}${this.temFile}`, `${this.basePath}/`)
         // filePath:`${this.basePath}local/`,)
         this.done = true

         //todo 后面打开
         // this.saveFileRet=res
       } catch (e) {
         console.log('saveFileSyncTest:' + e)
         this.done = true
       }
     },
     unzipFileTest: function (_ : any) {
       const fileManager = uni.getFileSystemManager()
       try {
         fileManager.mkdirSync(`${this.basePath}${this.targetZip}`, true)
       } catch (e) {
         console.error(e)
       }
       fileManager.unzip({
         zipFilePath: '/static/filemanager/to.zip',
         targetPath: `${this.basePath}${this.targetZip}`,
         success: (res : FileManagerSuccessResult) => {
           if (this.logAble) {
             this.log += 'unzipFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log('success', res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'unzipFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (_) => {
           this.done = true
         }
       } as UnzipFileOptions)
     },

     getSavedFileListTest: function () {
       const fileManager = uni.getFileSystemManager()
       fileManager.getSavedFileList({
         success: (res : GetSavedFileListResult) => {
           if (this.logAble) {
             this.log += 'getSavedFileListTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log("getSavedFileListTest success", res)
           this.fileListSuccess = res.fileList
           this.getSavedFileListRet = "getSavedFileList:ok"
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'getSavedFileListTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('getSavedFileListTest fail', res)
           this.lastFailError = res
           this.getSavedFileListRet = JSON.stringify(res)
         },
         complete: (res : any) => {
           console.log("complete", res)
           this.done = true
           if (res instanceof UniError) {
             this.lastCompleteError = res
           } else {
             this.fileListComplete = (res as GetSavedFileListResult).fileList
           }
         }
       } as GetSavedFileListOptions)
     },
     truncateFileTest() {
       const fileManager = uni.getFileSystemManager()
       fileManager.truncate({
         filePath: `${this.basePath}${this.writeFile}`,
         length: 7,
         success: (res : FileManagerSuccessResult) => {
           if (this.logAble) {
             this.log += 'truncateFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log("success", res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'truncateFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           console.log("complete", res)
           this.done = true
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }
         }
       } as TruncateFileOptions)
     },
     truncateFileSyncTest() {
       const fileManager = uni.getFileSystemManager()
       try {
         fileManager.truncateSync(
           `${this.basePath}${this.writeFile}`,
           4)
         this.done = true
       } catch (e) {
         console.log(e)
         this.done = true
       }
     },
     readCompressedFileTest() {
       const fileManager = uni.getFileSystemManager()
       fileManager.readCompressedFile({
         filePath: '/static/filemanager/1.txt.br',
         compressionAlgorithm: "br",
         success: (res : ReadCompressedFileResult) => {
           if (this.logAble) {
             this.log += 'readCompressedFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log("success", res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'readCompressedFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (_) => {
           this.done = true
         }
       } as ReadCompressedFileOptions)
     },
     readCompressedFileSyncTest() {
       console.log('readCompressedFileSyncTest')
       const fileManager = uni.getFileSystemManager()
       try {
         let data = fileManager.readCompressedFileSync(
           '/static/filemanager/1.txt.br',
           "br")
         if (this.logAble) {
           this.log += data
         }
         this.done = true
       } catch (e) {
         if (this.logAble) {
           this.log += 'readCompressedFileSyncTest fail:' + e + '\n\n'
         }
         this.done = true
       }

     },
     removeSavedFileTest() {
       console.log("removeSavedFileTest enter")
       const fileManager = uni.getFileSystemManager()
       fileManager.removeSavedFile({
         filePath: `${this.basePath}${this.writeFile}`,
         success: (res : FileManagerSuccessResult) => {
           if (this.logAble) {
             this.log += 'removeSavedFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           this.removeSavedFileRet = res.errMsg
           console.log("removeSavedFileTest success", res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'removeSavedFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('removeSavedFileTest fail', res)
         },
         complete: (_) => {
           this.done = true
         }
       } as RemoveSavedFileOptions)
     },

     statFileInfoSyncTest: function (_ : any) {
       const fileManager = uni.getFileSystemManager()
       try {
         let res = fileManager.statSync(
           // path: `${this.basePath}${this.statFile}`, //USER_DATA_PATH
           `${this.globalTempPath}${this.statFile}`, //CACHE_PATH
           this.recursiveVal)
         if (this.logAble) {
           this.log += 'statFileInfoSyncTest success:' + JSON.stringify(res) + '\n\n'
         }
         this.statsRet = res
         this.done = true
       } catch (e) {
         if (this.logAble) {
           this.log += 'statFileInfoSyncTest fail:' + e + '\n\n'
         }
         this.done = true
       }

     },
     openFileTest() {
       const fileManager = uni.getFileSystemManager()
       fileManager.open({
         filePath: `${this.basePath}${this.readFile}`,
         flag: "a",
         success: (res : OpenFileSuccessResult) => {
           if (this.logAble) {
             this.log += 'openFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log("success", res)
           this.fd = res.fd
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'openFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (_) => {
           this.done = true
         }
       } as OpenFileOptions)
     },
     openFileSyncTest(param : string) : string {
       const fileManager = uni.getFileSystemManager()
       try {
         let fd = fileManager.openSync({
           filePath: `${this.basePath}${this.readFile}`,
           flag: param,
         } as OpenFileSyncOptions)
         if (this.logAble) {
           this.log += 'openFileSyncTest success:' + fd + '\n\n'
         }
         this.done = true
         this.fd = fd
         return fd
       } catch (e) {
         if (this.logAble) {
           this.log += 'openFileSyncTest fail:' + JSON.stringify(e) + '\n\n'
         }
         console.log('fail', e)
         this.done = true
       }
       return ""
     },
     closeSyncTest() {
       console.log('closeSyncTest')
       const fileManager = uni.getFileSystemManager()
       try {
         console.log('closeSync')
         fileManager.closeSync({
           fd: this.openFileSyncTest('r')
         } as CloseSyncOptions)
         if (this.logAble) {
           this.log += 'closeSyncTest success:' + '\n\n'
         }
         this.done = true
         this.closeFileRet = "close:ok"
       } catch (e) {
         if (this.logAble) {
           this.log += 'closeSyncTest fail:' + JSON.stringify(e) + '\n\n'
         }
         console.log('fail', e)
         this.done = true
       }
     },
     closeTest() {
       const fileManager = uni.getFileSystemManager()
       fileManager.close({
         fd: this.openFileSyncTest('r'),
         success: (res : FileManagerSuccessResult) => {
           if (this.logAble) {
             this.log += 'closeTest success:' + JSON.stringify(res) + '\n\n'
           }
           this.closeFileRet = res.errMsg
           console.log("success", res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'closeTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (_) => {
           this.done = true
         }

       } as CloseOptions)
     },
     writeTest() {
       const fileManager = uni.getFileSystemManager()
       try {
         fileManager.mkdirSync(`${this.basePath}${this.mkdirFile}`, true)
       } catch (e) {
         console.error(e)
       }

       fileManager.write({
         fd: this.openFileSyncTest('w+'),
         data: this.writeData,
         encoding: "utf-8",
         success: (res : WriteResult) => {
           if (this.logAble) {
             this.log += 'writeTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log("success", res)
           this.bytesWritten = res.bytesWritten
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'writeTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (_) => {
           this.done = true
         }

       } as WriteOptions)
     },
     writeSyncTest() {
       const fileManager = uni.getFileSystemManager()
       try {
         fileManager.mkdirSync(`${this.basePath}${this.mkdirFile}`, true)
       } catch (e) {
         console.error(e)
       }
       fileManager.open({
         filePath: `${this.basePath}${this.readFile}`,
         flag: "r+",
         success: (res : OpenFileSuccessResult) => {
           console.log("success", res)
           if (res.fd.length <= 0) {
             this.done = true
             return
           }
           try {
             let ret = fileManager.writeSync({
               fd: res.fd,
               data: this.writeData,
               encoding: "utf-8"
             } as WriteSyncOptions)
             if (this.logAble) {
               this.log += 'writeSyncTest success:' + JSON.stringify(ret) + '\n\n'
             }
             console.log("success", ret)
             this.done = true
             this.bytesWritten = ret.bytesWritten
           } catch (e) {
             if (this.logAble) {
               this.log += 'writeSyncTest fail:' + JSON.stringify(e) + '\n\n'
             }
             console.log('fail', e)
             this.done = true
           }
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'openFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
           this.done = true
         }
       } as OpenFileOptions)

     },
     fstatTest() {
       const fileManager = uni.getFileSystemManager()
       fileManager.fstat({
         fd: this.openFileSyncTest('r'),
         success: (res : FStatSuccessResult) => {
           if (this.logAble) {
             this.log += 'fstatTest success:' + JSON.stringify(res) + '\n\n'
           }
           console.log("success", res)
           this.fstat = res.stats
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'fstatTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (_) => {
           this.done = true
         }

       } as FStatOptions)
     },
     fstatSyncTest() {
       const fileManager = uni.getFileSystemManager()
       try {
         let stat =
           fileManager.fstatSync({
             fd: this.openFileSyncTest('r'),
           } as FStatSyncOptions)
         if (this.logAble) {
           this.log += 'fstatSyncTest success:' + JSON.stringify(stat) + '\n\n'
         }
         this.done = true
         this.fstat = stat
       } catch (e) {
         if (this.logAble) {
           this.log += 'fstatSyncTest fail:' + JSON.stringify(e) + '\n\n'
         }
         this.done = true
       }
     },
     ftruncateFileTest() {
       const fileManager = uni.getFileSystemManager()
       fileManager.ftruncate({
         fd: this.openFileSyncTest('r+'),
         length: 6,
         success: (res : FileManagerSuccessResult) => {
           if (this.logAble) {
             this.log += 'ftruncateFileTest success:' + JSON.stringify(res) + '\n\n'
           }
           this.ftruncateRet = res.errMsg
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'ftruncateFileTest fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         },
         complete: (res : any) => {
           console.log("complete", res)
           this.done = true
           if (res instanceof UniError) {
             this.lastCompleteError = res
           }
         }
       } as FTruncateFileOptions)
     },
     ftruncateFileSyncTest() {
       const fileManager = uni.getFileSystemManager()
       try {
         fileManager.ftruncateSync({
           fd: this.openFileSyncTest('r+'),
           length: 4
         } as FTruncateFileSyncOptions)
         if (this.logAble) {
           this.log += 'ftruncateFileSyncTest success:' + '\n\n'
         }
         this.done = true
         this.ftruncateRet = 'ftruncate:ok'
       } catch (e) {
         if (this.logAble) {
           this.log += 'ftruncateFileSyncTest fail:' + JSON.stringify(e) + '\n\n'
         }
         this.done = true
       }
     },
     readZipEntry() {
       const fileManager = uni.getFileSystemManager()
       fileManager.readZipEntry({
         filePath: '/static/filemanager/to.zip',
         encoding: 'utf-8',
         success: (res : EntriesResult) => {
           if (this.logAble) {
             this.log += 'readZipEntry success:size=' + res.result.size + '\n\n'
           }
           console.log("success", res)
         },
         fail: (res : UniError) => {
           if (this.logAble) {
             this.log += 'readZipEntry fail:' + JSON.stringify(res) + '\n\n'
           }
           console.log('fail', res)
           this.lastFailError = res
         }
       } as ReadZipEntryOptions)
     },

   },

 }
</script>

<style>
 .btnstyle {
   margin: 4px;
 }
</style>

通用类型

GeneralCallbackResult

名称	类型	必备	默认值	描述
errMsg	string	是	-	错误信息