uni.getFileSystemManager()

获取文件管理器

getFileSystemManager 兼容性

Android	iOS	web
3.9.0	4.11	x

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

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

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

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

返回值

类型
FileSystemManager
名称 类型 必备 默认值 兼容性 描述 close any 是 - Android iOS web 4.13 x x 关闭文件

FileSystemManager 的方法

readFile(options)

读取本地文件内容

参数

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

ReadFileSuccessResult 的属性值

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

IFileSystemManagerFail 的属性值

名称	类型	必备	默认值	兼容性	描述
errCode	1200002 | 1300002 | 1300013 | 1300021 | 1300022 | 1300066 | 1301003 | 1301005 | 1300201 | 1300202 | 1301111 | 1302003 | 1300009	是	-	-	错误码 - 1200002 类型错误。仅支持 base64 / utf-8 - 1300002 未找到文件 - 1300013 无权限 - 1300021 是目录 - 1300022 参数无效 - 1300066 目录非空 - 1301003 对目录的非法操作 - 1301005 文件已存在 - 1300201 系统错误 - 1300202 超出文件存储限制的最大尺寸 - 1301111 brotli解压失败 - 1302003 标志无效 - 1300009 文件描述符错误
errSubject	string	是	-	-	统一错误主题（模块）名称
data	any | null	否	-	-	错误信息中包含的数据
cause	Error | null	否	-	-	源错误信息，可以包含多个错误，详见SourceError
errMsg	string	是	-	-	-

readFile 兼容性

Android	iOS	web
3.9.0	4.11	x

readFileSync(filePath, encoding?)

FileSystemManager.readFile 的同步版本参数

参数

名称	类型	必填	默认值	兼容性	描述
filePath	string	是	-	-	，支持相对地址和绝对地址，app-android平台支持代码包文件目录
encoding	string | null	否	-	-	/ utf-8

返回值

类型
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: IFileSystemManagerFail) => 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	是	-	-	,支持:ascii base64 utf-8

writeFileSync 兼容性

Android	iOS	web
4.13	x	x

unlink(options)

删除文件

参数

名称	类型	必填	默认值	兼容性	描述
options	UnLinkOptions	是	-	-	-
名称 类型 必备 默认值 兼容性 描述 filePath string.URIString 是 - - 文件路径，只支持绝对地址 success (res: FileManagerSuccessResult) => void | null 否 - - 接口调用的回调函数 fail (res: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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	是	-	-	。如果对应的上级目录已经存在，则不创建该上级目录。如 dirPath 为 a/b/c/d 且 recursive 为 true，将创建 a 目录，再在 a 目录下创建 b 目录，以此类推直至创建 a/b/c 目录下的 d 目录。

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: IFileSystemManagerFail) => 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	是	-	-	。如果为 true，则删除该目录和该目录下的所有子目录以及文件。

rmdirSync 兼容性

Android	iOS	web
4.13	x	x

readdir(options)

读取目录内文件列表

参数

名称	类型	必填	默认值	兼容性	描述
options	ReadDirOptions	是	-	-	-
名称 类型 必备 默认值 兼容性 描述 dirPath string.URIString 是 - - 要读取的目录路径 (本地路径) success (res: ReadDirSuccessResult) => void | null 否 - - 接口调用的回调函数 fail (res: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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

isDirectory 兼容性

Android	iOS	web
-	-	-

isFile()

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

返回值

类型
boolean

isFile 兼容性

Android	iOS	web
-	-	-

stat 兼容性

Android	iOS	web
3.9.0	4.11	x

statSync(path, recursive)

FileSystemManager.stat 的同步版本

参数

名称	类型	必填	默认值	兼容性	描述
path	string	是	-	-	/目录路径 (本地路径)
recursive	boolean	是	-	-	Stats 信息

返回值

类型
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: IFileSystemManagerFail) => 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	是	-	-	:ascii base64 utf-8

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: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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 是 - - 要读取的文件的路径 (本地用户文件或代码包文件)，app-android平台支持代码包文件目录 compressionAlgorithm string 是 - - 文件压缩类型，目前仅支持 'br'。 success (res: ReadCompressedFileResult) => void | null 否 - - 接口调用的回调函数 fail (res: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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: IFileSystemManagerFail) => 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 是 - - 要读取的压缩包的路径 (本地路径)，app-android平台支持代码包文件目录 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: IFileSystemManagerFail) => void | null 否 - - 接口调用失败的回调函数 complete (res: any) => void | null 否 - - 接口调用结束的回调函数（调用成功、失败都会执行）

EntriesResult 的属性值

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

readZipEntry 兼容性

Android	iOS	web
4.13	x	x

特殊说明

app-ios平台暂时仅支持在uvue文件中使用文件管理器对象，uts插件中暂不支持 app-android平台API不支持代码包文件目录

参见

相关 Bug

示例

hello uni-app x

该 API 不支持 Web，请运行 hello uni-app x 到 App 平台体验

<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:IUniError ) => {
            if (this.logAble) {
              this.log += 'statFileInfoTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('statFileInfoTest fail', res)
            this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)
          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'getFileInfoTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
            this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)
          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'copyFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
            this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)
          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'renameFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
            this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)
          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'readDirTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
            this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)
          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'writeFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail')
            this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)
          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'readFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
            this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)
          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'rmdirTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
            this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)
          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'mkdirTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'accessFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'unlinkTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
                  if (this.logAble) {
                    this.log += 'unlinkAllFileTest fail:' + JSON.stringify(res) + '\n\n'
                  }
                  console.log('fail unlink', res)
                              this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

                },
                complete: (res : any) => {
                  if (res instanceof UniError) {
                    this.lastCompleteError = res
                  }
                  console.log("complete unlink", res)
                  this.done = true
                }
              } as UnLinkOptions)
            });
          },
          fail: (res : IUniError) => {
            if (this.logAble) {
              this.log += 'unlinkAllFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail to readdir', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'copyFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'appendFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail')
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'saveFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('saveFileTest fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

            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 : IUniError) => {
            if (this.logAble) {
              this.log += 'unzipFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'getSavedFileListTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('getSavedFileListTest fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

            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 : IUniError) => {
            if (this.logAble) {
              this.log += 'truncateFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'readCompressedFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            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 : IUniError) => {
            if (this.logAble) {
              this.log += 'openFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'closeTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'writeTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'openFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

            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 : IUniError) => {
            if (this.logAble) {
              this.log += 'fstatTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'ftruncateFileTest fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          },
          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 : IUniError) => {
            if (this.logAble) {
              this.log += 'readZipEntry fail:' + JSON.stringify(res) + '\n\n'
            }
            console.log('fail', res)
                        this.lastFailError=new UniError(res.errSubject, res.errCode, res.errMsg)

          }
        } as ReadZipEntryOptions)
      },

    },

  }
</script>

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

通用类型

GeneralCallbackResult

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