fs 包

介绍

fs 包提供对文件、目录、路径、文件元数据信息的一些操作函数。目前支持 Linux，macOS 和 Windows 平台下使用。

主要接口

struct Path

public struct Path <: Equatable<Path> & Hashable & ToString {
 public init(rawPath: String)
}

Path 用来表示本地路径（Windows 平台已支持 DOS 设备路径和 UNC 路径，长度限制跟随系统）。路径的字符串最大支持 4096 个字节（包括结束符 \0）。

init

public init(rawPath: String)

功能：创建 Path 实例初始化时不检查路径字符串是否合法。

参数：

rawPath：路径的字符串

prop directoryName

public prop directoryName: Option<Path>

功能：获得 Path 的目录部分，以 Option 形式返回

对于路径 "/a/b/c"，此属性返回 Some(Path("/a/b"))
对于路径 "/a/b/"，此属性返回 Some(Path("/a/b"))
对于路径 "/a"，此属性返回 Some(Path("/"))
对于路径 "/"，此属性返回 Some(Path("/"))
对于路径 "./a/b"，此属性返回 Some(Path("./a"))
对于路径 "./"，此属性返回 Some(Path("."))
对于路径 "."，此属性返回 None
对于路径 ".gitignore"，此属性返回 None
对于路径 "a.txt"，此属性返回 None
对于路径 "C:\a\b\c"，此属性返回 Some(Path("C:\a\b"))
对于路径 "C:\a\b"，此属性返回 Some(Path("C:\a\b"))

返回值：返回构造时传入的路径中的目录部分，构造时传入的路径中无目录部分时返回 None

异常：

IllegalArgumentException：当路径为空，或包含字符串结束符则抛出异常

prop fileName

public prop fileName: Option<String>

功能：获得 Path 的文件名（含扩展名）部分，以 Option 形式返回

对于路径 "./NewFile.txt"，此属性返回 Some("NewFile.txt")
对于路径 "./.gitignore"，此属性返回 Some(".gitignore")
对于路径 "./noextension"，此属性返回 Some("noextension")
对于路径 "./a.b.c"，此属性返回 Some("a.b.c")
对于路径 "./NewDir/"，此属性返回 None

返回值：返回构造时传入的路径中的文件名（含扩展名）部分，构造时传入的路径中无文件名（含扩展名）部分时返回 None

异常：

IllegalArgumentException：当路径为空，或包含字符串结束符则抛出异常

prop extensionName

public prop extensionName: Option<String>

功能：获得 Path 的文件扩展名部分，以 Option 形式返回

对于路径 "./NewFile.txt"，此属性返回 Some("txt")
对于路径 "./.gitignore"，此属性返回 Some("gitignore")
对于路径 "./noextension"，此属性返回 None
对于路径 "./a.b.c"，此属性返回 Some("c")
对于路径 "./NewDir/"，此属性返回 None
对于路径 "./NewDir/NewFile."，此属性返回 None

返回值：返回构造时传入的路径中的文件扩展名部分，构造时传入的路径中无文件扩展名部分时返回 None

异常：

IllegalArgumentException：当路径为空，或包含字符串结束符则抛出异常

prop fileNameWithoutExtension

public prop fileNameWithoutExtension: Option<String>

功能：获得 Path 的文件名（不含扩展名）部分，以 Option 形式返回

对于路径 "./NewFile.txt"，此属性返回 Some("NewFile")
对于路径 "./.gitignore"，此属性返回 None
对于路径 "./noextension"，此属性返回 Some("noextension")
对于路径 "./a.b.c"，此属性返回 Some("a.b")
对于路径 "./NewDir/"，此属性返回 None

返回值：返回构造时传入的路径中的文件名（不含扩展名）部分，构造时传入的路径中无文件名（不含扩展名）部分时返回 None

异常：

IllegalArgumentException：当路径为空，或包含字符串结束符则抛出异常

func isAbsolute

public func isAbsolute(): Bool

功能：判断 Path 是否是绝对路径。在 Unix 中，以 "/" 开头的路径为绝对路径。

返回值：true，是绝对路径；false，不是绝对路径

异常：

IllegalArgumentException：当路径为空，或包含字符串结束符则抛出异常

func isRelative

public func isRelative(): Bool

功能：判断 Path 是否是相对路径与 isAbsolute 结果相反。

返回值：true，是相对路径；false，不是相对路径

异常：

IllegalArgumentException：当路径为空，或包含字符串结束符则抛出异常

func isSymbolicLink

public func isSymbolicLink(): Bool

功能：判断 Path 是否是软链接，与 isFile, isDirectory 互斥。

返回值：true，是软链接；false，不是软链接

异常：

FSException：如果路径不存在，或者判断过程中底层调用的系统接口发生错误，则抛异常
IllegalArgumentException：当路径为空，或包含字符串结束符则抛出异常

func isFile

public func isFile(): Bool

功能：判断 Path 是否是文件，与 isSymbolicLink, isDirectory 互斥。

返回值：true，是文件；false，不是文件

异常：

FSException：如果路径不存在，或者判断过程中底层调用的系统接口发生错误，则抛异常
IllegalArgumentException：当路径为空，或包含字符串结束符则抛出异常

func isDirectory

public func isDirectory(): Bool

功能：判断 Path 是否是目录，与 isFile, isSymbolicLink 互斥。

返回值：true，是目录；false，不是目录

异常：

FSException：如果路径不存在，或者判断过程中底层调用的系统接口发生错误，则抛异常
IllegalArgumentException：当路径为空，或包含字符串结束符则抛出异常

func split

public func split(): (Option<Path>, Option<String>)

功能：将 Path 分割成目录和文件名两部分以元组形式返回分割结果 (directoryName, fileName) 获取目录失败，返回 Option.None 文件名获取失败，返回 Option.None。

返回值：返回值为元组类型，第一个元素表示路径，路径获取成功，返回 Option.Some(p)；第二个元素表示文件名，文件名获取成功，返回 Option.Some(s)

异常：

IllegalArgumentException：当路径为空，或包含字符串结束符则抛出异常

func join

public func join(path: String): Path

功能：在当前路径后拼接另一个路径字符串形成新路径对于路径 "a/b", "c"，返回 "a/b/c" 对于路径 "a", "b/c"，返回 "a/b/c"。

返回值：新路径的 Path 实例

异常：

FSException：如果参数 path 是绝对路径则抛异常
IllegalArgumentException：当前路径为空，或当前路径、入参路径非法时抛出异常

func join

public func join(path: Path): Path

功能：在当前路径后拼接另一个路径形成新路径对于路径 "a/b", "c"，返回 "a/b/c" 对于路径 "a", "b/c"，返回 "a/b/c"。

返回值：新路径的 Path 实例

异常：

FSException：如果参数 path 是绝对路径则抛异常
IllegalArgumentException：当前路径为空，或当前路径、入参路径非法时抛出异常

func toCanonical

public func toCanonical(): Path

功能：将 Path 规范化返回绝对路径形式的规范化路径，所有的中间引用和软链接都会处理（UNC 路径下的软链接无法被规范化）对于路径 "/foo/test/../test/bar.txt"，该函数会返回 "/foo/test/bar.txt"。

返回值：规范化路径的 Path 实例

异常：

FSException：路径不存在或无法规范化时抛出异常
IllegalArgumentException：路径为空，或包含字符串结束符时抛出异常

operator func ==

public operator func ==(that: Path): Bool

功能：判断 Path 是否是同一路径。

返回值：true，是同一路径；false，不是同一路径

operator func !=

public operator func !=(that: Path): Bool

功能：判断 Path 是否不是同一路径。

返回值：true，不是同一路径；false，是同一路径

func hashCode

public func hashCode(): Int64

功能：获得 Path 的哈希值。

返回值：Path 的哈希值

func toString

public func toString(): String

功能：获得 Path 的路径字符串。

返回值：Path 的路径字符串

enum OpenOption

public enum OpenOption {
    | Append
    | Create(Bool)
    | Truncate(Bool)
    | Open(Bool, Bool)
    | CreateOrTruncate(Bool)
    | CreateOrAppend
}

OpenOption 枚举类型表示不同的文件打开选项。

Append

Append

功能：构造一个 OpenOption 实例，指定文件系统应打开现有文件并查找到文件尾，用这个选项创建的 File 默认只具有 Write 权限，试图查找文件尾之前的位置时会引发 FSException 异常，并且任何试图读取的操作都会失败并引发异常，如果文件不存在，则将引发异常。

Create

Create(Bool)

功能：构造一个 OpenOption 实例，指定文件系统应创建新文件，用这个选项创建的 File 默认具有 Write 权限，可以通过参数指定是否具有 Read 权限。如果文件已存在，则将引发异常。

Truncate

Truncate(Bool)

功能：构造一个 OpenOption 实例，指定文件系统应打开现有文件，该文件被打开时，将被截断为零字节大小。用这个选项创建的 File 默认具有 Write 权限，可以通过参数指定是否具有 Read 权限。如果文件不存在，则将引发异常。

Open

Open(Bool, Bool)

功能：构造一个 OpenOption 实例，指定文件系统应打开现有文件，第一个参数指定文件是否具有 Read 权限，第二个参数指定文件具有 Write 权限。如果文件不存在，则将引发异常。

CreateOrTruncate

CreateOrTruncate(Bool)

功能：构造一个 OpenOption 实例，指定文件系统应创建新文件，如果此文件已存在，则会将其覆盖。用这个选项创建的 File 默认具有 Write 权限，可以通过参数指定是否具有 Read 权限。分为两种情况：如果文件不存在，则使用 Create；否则使用 Truncate。

CreateOrAppend

CreateOrAppend

功能：构造一个 OpenOption 实例，指定文件系统应打开文件（如果文件存在），否则，应创建新文件。用这个选项创建的 File 默认只具有 Write 权限，并且试图查找文件尾之前的位置时会引发 FSException 异常。分为两种情况：如果文件不存在，则使用 Create；否则使用 Append。

struct FileDescriptor

public struct FileDescriptor

此类用于获取文件句柄信息。

prop fileHandle

public prop fileHandle: CPointer<Unit>

功能：Windows 下获取文件句柄信息。

prop fileHandle

public prop fileHandle: Int32

功能：Linux 下获取文件句柄信息。

class File

public class File <: Resource & InputStream & OutputStream & Seekable {
    public init(path: String, openOption: OpenOption)
    public init(path: Path, openOption: OpenOption)
}

此类提供一些对文件进行操作的函数，包括文件的流式读写操作和一些常用的辅助函数等。

注：创建的 File 对象会默认打开对应的文件，当使用结束后需要及时调用 close 函数关闭文件, 否则会造成资源泄露。

init

public init(path: String, openOption: OpenOption)

功能：创建 File 对象。

参数：

path：文件路径字符串
openOption：文件打开选项

异常：

FSException：如果创建操作时文件已存在、进行操作时文件不存在、文件的父目录不存在，或其他原因导致无法打开文件，则抛异常
IllegalArgumentException：如果 path 是空字符串或者 path 包含 '\0'，则抛出异常

init

public init(path: Path, openOption: OpenOption)

功能：创建一个 File 对象。

参数：

path：文件路径
openOption：文件打开选项

异常：

FSException：如果创建操作时文件已存在、进行操作时文件不存在、文件的父目录不存在，或其他原因导致无法打开文件，则抛异常
IllegalArgumentException：如果 path 为空路径或者 path 路径中包含 '\0'，则抛出异常

prop length

public prop length: Int64

功能：获取文件头至文件尾的数据字节数。

prop remainLength

public prop remainLength: Int64

功能：获取文件当前光标位置至文件尾的数据字节数。

prop position

public prop position: Int64

功能：获取文件当前光标位置。

prop info

public prop info: FileInfo

功能：获取文件元数据信息。

prop fileDescriptor

public prop fileDescriptor: FileDescriptor

功能：获取文件描述符信息。

func read

public func read(buffer: Array<Byte>): Int64

功能：从文件中读出数据到 buffer 中。

参数：

buffer：读取数据存放的缓冲区

返回值：读取成功，返回读取字节数，如果文件被读完，返回 0

异常：

IllegalArgumentException：如果 buffer 为空，则抛出异常
FSException：读取失败、文件已关闭，或文件不可读，则抛出异常

func write

public func write(buffer: Array<Byte>): Unit

功能：将 buffer 中的数据写入到文件中。

参数：

buffer：待写入数据的缓冲区，若 buffer 为空则直接返回

异常：

FSException：如果写入失败或者只写入了部分数据，或文件已关闭、文件不可写，则抛出异常

func seek

public func seek(sp: SeekPosition): Int64

功能：将光标跳转到指定位置，指定的位置不能位于文件头部之前，指定位置可以超过文件末尾，但指定位置到文件头部的最大偏移量不能超过当前文件系统允许的最大值，这个最大值接近当前文件系统的所允许的最大文件大小，一般为最大文件大小减去 4096 个字节。

参数：

sp：指定光标跳转后的位置

返回值：返回文件头部到跳转后位置的偏移量（以字节为单位）

异常：

FSException：指定位置不满足以上情况时，或如果文件不能seek，seek 操作均会抛异常

func canRead

public func canRead(): Bool

功能：判断当前 File 对象是否可读，该函数返回值由创建文件对象的 openOption 所决定，文件对象关闭后返回 false。

返回值：返回 false 表示不可读或文件对象已关闭，返回 true 表示可读

func canWrite

public func canWrite(): Bool

功能：判断当前 File 对象是否可写，该函数返回值由创建文件对象的 openOption 所决定，文件对象关闭后返回 falsefalse：不可写或文件对象已关闭。

返回值：返回 true 表示可写

func readToEnd

public func readToEnd(): Array<Byte>

功能：读取当前 File 所有剩余数据，以 Array 形式返回剩余的 bytes。

返回值：文件内剩余的 bytes

异常：

FSException：如果读取失败，或文件不可读，则抛异常

func copyTo

public func copyTo(out: OutputStream): Unit

功能：将当前 File 还没读取的数据全部写入到指定的 OutputStream 中。

参数：

out：待写入的 OutputStream

异常：

FSException：文件读取时未被打开或文件没有读取权限，则抛出异常

func close

public func close(): Unit

功能：关闭当前 File 对象。

异常：

FSException：如果关闭失败，则抛异常

func isClosed

public func isClosed(): Bool

功能：判断当前 File 对象是否已关闭。

返回值：false 表示未关闭，true 表示已关闭

func exists

public static func exists(path: String): Bool

功能：判断路径对应的文件是否存在。

参数：

path：文件路径字符串

返回值：false 表示路径不存在或者路径对应的不是文件，true 表示路径对应的是文件或指向文件的软链接

func exists

public static func exists(path: Path): Bool

功能：判断路径对应的文件是否存在。

参数：

path：文件路径

返回值：false 表示路径不存在或者路径对应的不是文件，true 表示路径对应的是文件或指向文件的软链接

func openRead

public static func openRead(path: String): File

功能：以只读模式打开指定路径的文件。

参数：

path：文件路径字符串

返回值：File 实例，该实例需要及时调用 close 函数关闭文件

异常：

FSException：如果文件不存在，或文件不可读，则抛异常
IllegalArgumentException：文件路径包含空字符则抛出异常

func openRead

public static func openRead(path: Path): File

功能：以只读模式打开指定路径的文件。

参数：

path：文件路径

返回值：File 实例，该实例需要手动调用 close 函数关闭文件

异常：

FSException：如果文件不存在，或文件不可读，则抛异常
IllegalArgumentException：文件路径包含空字符则抛出异常

func create

public static func create(path: String): File

功能：以只写模式创建指定路径的文件。

参数：

path：文件路径字符串

返回值：File 实例

异常：

FSException：如果路径指向的文件的上级目录不存在或文件已存在，则抛出异常
IllegalArgumentException：如果文件路径为空字符串或包含空字符，则抛出异常

func create

public static func create(path: Path): File

功能：以只写模式创建指定路径的文件。

参数：

path：文件路径

返回值：File 实例

异常：

FSException：如果路径指向的文件的上级目录不存在或文件已存在，则抛出异常
IllegalArgumentException：如果文件路径为空或包含空字符，则抛出异常

func createTemp

public static func createTemp(directoryPath: String): File

功能：在指定目录下创建临时文件创建的文件名称是 tmpFileXXXXXX 形式，不使用的临时文件应手动删除。

参数：

directoryPath：目录路径字符串

返回值：临时文件 File 实例

异常：

FSException：创建文件失败或路径不存在则抛出异常
IllegalArgumentException：如果文件路径为空字符串或包含空字符，则抛出异常

func createTemp

public static func createTemp(directoryPath: Path): File

功能：在指定目录下创建临时文件创建的文件名称是 tmpFileXXXXXX 形式，不使用的临时文件应手动删除。

参数：

返回值：临时文件 File 实例

异常：

FSException：创建文件失败或路径不存在则抛出异常
IllegalArgumentException：如果文件路径为空或包含空字符，则抛出异常

func readFrom

public static func readFrom(path: String): Array<Byte>

功能：直接读取指定路径的文件，以 Array 形式返回所有的 bytes。

参数：

path：文件路径字符串

返回值：文件内所有 bytes

异常：

FSException：文件读取失败、文件关闭失败、文件路径为空、文件不可读，则抛出异常
IllegalArgumentException：文件路径包含空字符则抛出异常

func readFrom

public static func readFrom(path: Path): Array<Byte>

功能：直接读取指定路径的文件，以 Array 形式返回所有的 bytes。

参数：

path：文件路径

返回值：文件内所有 bytes

异常：

FSException：文件路径为空、文件不可读、文件读取失败，则抛出异常
IllegalArgumentException：文件路径包含空字符则抛出异常

func writeTo

public static func writeTo(path: String, buffer: Array<Byte>, openOption!: OpenOption = CreateOrAppend): Unit

功能：按照 openOption 打开指定路径的文件并将 buffer 写入。

参数：

path：文件路径字符串
buffer：待写入的 bytes
openOption：文件打开选项，默认为 CreateOrAppend

异常：

FSException：文件路径为空则抛出异常
IllegalArgumentException：如果文件路径为空字符串或包含空字符，则抛出异常

func writeTo

public static func writeTo(path: Path, buffer: Array<Byte>, openOption!: OpenOption = CreateOrAppend): Unit

功能：按照 openOption 打开指定路径的文件并将 buffer 写入。

参数：

path：文件路径
buffer：待写入的 bytes
openOption：文件打开选项，默认为 CreateOrAppend

异常：

FSException：文件路径为空则抛出异常
IllegalArgumentException：如果文件路径为空或包含空字符，则抛出异常

func delete

public static func delete(path: String): Unit

功能：删除指定路径下的文件，删除文件前需保证文件已关闭，否则可能删除失败。

参数：

path：文件路径字符串

异常：

FSException：如果指定文件不存在，或删除失败，则抛异常

func delete

public static func delete(path: Path): Unit

功能：删除指定路径下的文件，删除文件前需保证文件已关闭，否则可能删除失败。

参数：

path：文件路径

异常：

FSException：如果指定文件不存在，或删除失败，则抛异常

func move

public static func move(sourcePath: String, destinationPath: String, overwrite: Bool): Unit

功能：移动文件，当 overwrite 为 true，如果指定路径中已有同名的文件，则会覆盖已存在的文件。参数：

sourcePath：文件原路径
destinationPath：文件目标路径
overwrite：是否覆盖

异常：

IllegalArgumentException：目标目录名为空，或目标目录名包含空字符
FSException：源目录不存在，或 overwrite 为 false 时目标目录已存在，或移动失败

func move

public static func move(sourcePath: Path, destinationPath: Path, overwrite: Bool): Unit

功能：移动文件当 overwrite 为 true，如果指定路径中已有同名的文件，则会覆盖已存在的文件。参数：

sourcePath：文件原路径
destinationPath：文件目标路径
overwrite：是否覆盖

异常：

IllegalArgumentException：目标目录名为空，或目标目录名包含空字符
FSException：源目录不存在，或 overwrite 为 false 时目标目录已存在，或移动失败

func copy

public static func copy(sourcePath: String, destinationPath: String, overwrite: Bool): Unit

功能：将文件拷贝到新的位置，不成功则抛异常。

参数：

sourcePath：文件原路径
destinationPath：文件目标路径
overwrite：是否覆盖

异常：

FSException：文件路径为空，或源路径文件无读权限，或目标路径文件已存在且无写权限则抛出异常
IllegalArgumentException：文件路径包含空字符则抛出异常

func copy

public static func copy(sourcePath: Path, destinationPath: Path, overwrite: Bool): Unit

功能：将文件拷贝到新的位置，不成功则抛异常。

参数：

sourcePath：文件原路径
destinationPath：文件目标路径
overwrite：是否覆盖

异常：

FSException：文件路径为空，或源路径文件无读权限，或目标路径文件已存在且无写权限则抛出异常
IllegalArgumentException：文件路径包含空字符则抛出异常

func flush

public func flush(): Unit

功能：清空缓存区，该函数提供默认实现，默认实现为空。

class Directory

Directory 对应文件系统中的目录，它提供了常规目录操作，以及遍历目录的能力。

public class Directory <: Iterable<FileInfo> {
    public init(path: String)
    public init(path: Path)
}

init

public init(path: String)

功能：创建 Directory 实例，路径非法抛异常。

参数：

异常：

FSException：当路径不存在时或路径为空时，抛出异常

init

public init(path: Path)

功能：创建 Directory 实例。

参数：

异常：

FSException：如果路径非法，则抛异常

func exists

public static func exists(path: String): Bool

功能：判断路径对应的目录是否存在。

参数：

返回值：false 表示路径不存在，或者路径对应的不是目录，true 表示路径对应的是目录或指向目录的软链接

func exists

public static func exists(path: Path): Bool

功能：判断路径对应的目录是否存在。

参数：

返回值：false 表示路径不存在或者路径对应的不是目录，true 表示路径对应的是目录或指向目录的软链接

func create

public static func create(path: String, recursive!: Bool = false): Directory

功能：创建目录，可指定是否递归创建，如果需要递归创建，将逐级创建路径中不存在的目录，否则仅创建最后一级目录。

参数：

path：待创建的目录路径
recursive：是否递归创建目录，默认 false

返回值：新创建的 Directory 实例

异常：

FSException：目录已存在时，抛出异常；非递归时中间有不存在的目录时抛出异常
IllegalArgumentException：目录为空、目录为当前目录、目录为根目录，或目录中存在空字符时抛出异常

func create

public static func create(path: Path, recursive!: Bool = false): Directory

功能：创建目录，可指定是否递归创建，如果需要递归创建，将逐级创建路径中不存在的目录，否则仅创建最后一级目录。

参数：

path：待创建的目录路径
recursive：是否递归创建目录，默认 false

返回值：新创建的 Directory 实例

异常：

FSException：目录已存在时，抛出异常；非递归时中间有不存在的目录时抛出异常
IllegalArgumentException：目录为空、目录为当前目录、目录为根目录，或目录中存在空字符时抛出异常

func createTemp

public static func createTemp(directoryPath: String): Directory

参数：

directoryPath：String 形式的目录路径

返回值：临时目录的 Directory 实例

异常：

FSException：目录不存在或创建失败时抛出异常
IllegalArgumentException：目录为空或包含空字符时抛出异常

func createTemp

public static func createTemp(directoryPath: Path): Directory

参数：

directoryPath：Path 对象形式的目录路径

返回值：临时目录的 Directory 实例

异常：

FSException：目录不存在或创建失败时抛出异常
IllegalArgumentException：目录为空或包含空字符时抛出异常

func delete

public static func delete(path: String, recursive!: Bool = false): Unit

功能：删除目录，可指定是否递归删除，如果需要递归删除，将逐级删除目录，否则仅删除最后一级目录。

参数：

path：String 形式的指定目录路径
recursive：是否递归，默认不递归

异常：

FSException：如果目录不存在或递归删除失败，则抛出异常
IllegalArgumentException：如果 path 为空字符串或包含空字符或长度大于 4096 ，则出抛异常

func delete

public static func delete(path: Path, recursive!: Bool = false): Unit

功能：删除目录，可指定是否递归删除，如果需要递归删除，将逐级删除目录，否则仅删除最后一级目录。

参数：

path：String 形式的指定目录路径
recursive：是否递归，默认不递归

异常：

FSException：如果目录不存在或递归删除失败，则抛出异常
IllegalArgumentException：如果 path 为空字符串或包含空字符或长度大于 4096 ，则出抛异常

func move

public static func move(sourceDirPath: String, destinationDirPath: String, overwrite: Bool): Unit

功能：将该目录以及文件、子文件夹都移动到指定路径。

参数：

sourceDirPath：String 形式的源目录路径
destinationDirPath：String 形式的目标目录路径
overwrite：是否覆盖, 为 true 时将覆盖目标路径中的所有子文件夹和文件

异常：

IllegalArgumentException：目标目录名为空，或目标目录名包含空字符
FSException：源目录不存在，或 overwrite 为 false 时目标目录已存在，或移动失败

func move

public static func move(sourceDirPath: Path, destinationDirPath: Path, overwrite: Bool): Unit

功能：将该目录以及文件、子文件夹都移动到指定路径。

参数：

sourceDirPath：String 形式的源目录路径
destinationDirPath：String 形式的目标目录路径
overwrite：是否覆盖, 为 true 时将覆盖目标路径中的所有子文件夹和文件

异常：

IllegalArgumentException：目标目录名为空，或目标目录名包含空字符
FSException：源目录不存在，或 overwrite 为 false 时目标目录已存在，或移动失败

func copy

public static func copy(sourceDirPath: String, destinationDirPath: String, overwrite: Bool): Unit

功能：将该目录以及文件、子文件夹都拷贝到新的位置，不成功则抛异常。

参数：

sourceDirPath：String 形式的源目录路径
destinationDirPath：String 形式的目标目录路径
overwrite：是否覆盖

异常：

FSException：源目录不存在，或 overwrite 为 false 时目标目录已存在，或目标目录在源目录中，或复制失败，抛出异常
IllegalArgumentException：源目录或目标目录名包含空字符则抛出异常

func copy

public static func copy(sourceDirPath: Path, destinationDirPath: Path, overwrite: Bool): Unit

功能：将该目录以及文件、子文件夹都拷贝到新的位置。

参数：

sourceDirPath：Path 形式的源目录路径
destinationDirPath：Path 形式的目标目录路径
overwrite：是否覆盖

异常：

FSException：源目录不存在，或 overwrite 为 false 时目标目录已存在，或目标目录在源目录中，或复制失败，抛出异常
IllegalArgumentException：源目录或目标目录名包含空字符则抛出异常

func createSubDirectory

public func createSubDirectory(name: String): Directory

功能：在当前 Directory 下创建指定名字的子目录。

参数：

name：子目录名，参数只接受不带路径前缀的字符串

返回值：子目录的 Directory 实例

异常：

FSException：当子目录名中含有路径信息，路径已存在，或创建目录失败时，抛出异常
IllegalArgumentException：当目录名中含有空字符时，抛出异常

func createFile

public func createFile(name: String): File

功能：在当前 Directory 下创建指定名字的子文件。

参数：

name：子文件名，参数只接受不带路径前缀的字符串

返回值：子文件的 File 实例，该实例需要手动调用 close 函数关闭文件

异常：

FSException：当子文件名中含有路径信息，文件名已存在，抛出异常
IllegalArgumentException：当文件名包含空字符时抛出异常

prop info

public prop info: FileInfo

功能：当前目录元数据信息

func isEmpty

public func isEmpty(): Bool

功能：判断当前目录是否为空。

异常：

FSException：如果判断过程中底层调用的系统接口发生错误，则抛异常

func iterator

public func iterator(): Iterator<FileInfo>

异常：

FSException：获取目录的成员信息失败时，抛出异常

func directories

public func directories(): Iterator<FileInfo>

异常：

FSException：获取目录的成员信息失败时，抛出异常

func files

public func files(): Iterator<FileInfo>

功能：返回当前目录的子文件迭代器。

返回值：当前目录的子文件迭代器

异常：

FSException：获取目录的成员信息失败时，抛出异常

func entryList

public func entryList(): ArrayList<FileInfo>

异常：

FSException：获取目录的成员信息失败时，抛出异常

func directoryList

public func directoryList(): ArrayList<FileInfo>

异常：

FSException：获取目录的成员信息失败时，抛出异常

func fileList

public func fileList(): ArrayList<FileInfo>

功能：返回当前目录的子文件列表。

返回值：当前目录的子文件列表

异常：

FSException：获取目录的成员信息失败时，抛出异常

struct FileInfo

public struct FileInfo <: Equatable<FileInfo> {
 public init(path: String)
 public init(path: Path)
}

FileInfo 对应文件系统中的文件元数据，提供一些文件属性的查询和操作。

FileInfo 的底层实现是没有直接缓存文件属性的，每次通过 FileInfo 的 API 都是现场获取的最新的文件属性。

因此这里有需要注意的情况，对于创建的同一 FileInfo 实例，如果在两次获取其文件属性操作期间，对应的文件实体可能会被其他用户或进程做了修改或者替换等不期望的操作，就会导致后一次获取的可能不是期望的文件属性。如果有特殊文件操作需求需要避免上述情况的产生，可以采用设置文件权限或者给关键文件操作加锁的方式来保证。

init

public init(path: String)

功能：创建 FileInfo 实例。

参数：

异常：

FSException：路径非法

init

public init(path: Path)

功能：创建 FileInfo 实例。

参数：

异常：

FSException：路径非法

prop parentDirectory

public prop parentDirectory: Option<FileInfo>

功能：获得父级目录元数据，以 Option 形式返回，有父级返回 Option.Some(v)；否则返回 Option.None

prop path

public prop path: Path

功能：获得当前文件路径，以 Path 形式返回

prop symbolicLinkTarget

public prop symbolicLinkTarget: Option<Path>

功能：获得链接目标路径，以 Option 形式返回，当前是符号链接返回 Option.Some(v)；否则返回 Option.None。

prop creationTime

public prop creationTime: DateTime

功能：获取创建时间。

异常 FSException - 如果判断过程中底层调用的系统接口发生错误，则抛异常

prop lastAccessTime

public prop lastAccessTime: DateTime

功能：获取最后访问时间。

异常 FSException - 如果判断过程中底层调用的系统接口发生错误，则抛异常

prop lastModificationTime

public prop lastModificationTime: DateTime

功能：获取最后修改时间。

异常 FSException - 如果判断过程中底层调用的系统接口发生错误，则抛异常

prop length

public prop length: Int64

功能：返回当前文件大小。

当前是文件时，表示单个文件占用磁盘空间的大小
当前是目录时，表示当前目录的所有文件占用磁盘空间的大小

异常：

FSException：如果判断过程中底层调用的系统接口发生错误，则抛异常

func isSymbolicLink

public func isSymbolicLink(): Bool

功能：判断当前文件是否是软链接。

异常：

FSException：如果判断过程中底层调用的系统接口发生错误，则抛异常

func isFile

public func isFile(): Bool

功能：判断当前文件是否是普通文件。

异常：

FSException：如果判断过程中底层调用的系统接口发生错误，则抛异常

func isDirectory

public func isDirectory(): Bool

功能：判断当前文件是否是目录。

异常：

FSException：如果判断过程中底层调用的系统接口发生错误，则抛异常

func isReadOnly

public func isReadOnly(): Bool

功能：判断当前文件是否只读。

在 Windows 环境下，用户对于文件的只读权限正常使用；用户始终拥有对于目录的删除修改权限，该函数不生效，返回 false
在 Linux 和 macOS 环境下，该函数正常使用

异常：

FSException：如果判断过程中底层调用的系统接口发生错误，则抛异常

func isHidden

public func isHidden(): Bool

功能：判断当前文件是否隐藏。

func canExecute

public func canExecute(): Bool

功能：判断当前用户是否有权限执行该实例对应的文件。

对文件而言，判断用户是否有执行文件的权限
对目录而言，判断用户是否有进入目录的权限
在 Windows 环境下，用户对于文件的执行权限由文件扩展名决定；用户始终拥有对于目录的执行权限，该函数不生效，返回 true
在 Linux 和 macOS 环境下，该函数正常使用

异常：

FSException：如果判断过程中底层调用的系统接口发生错误，则抛异常

func canRead

public func canRead(): Bool

功能：判断当前用户是否有权限读取该实例对应的文件。

对文件而言，判断用户是否有读取文件的权限
对目录而言，判断用户是否有浏览目录的权限
在 windows 环境下，用户始终拥有对于文件和目录的可读权限，该函数不生效，返回 true
在 Linux 和 macOS 环境下，该函数正常使用

异常：

FSException：如果判断过程中底层调用的系统接口发生错误，或文件不可读，则抛异常

func canWrite

public func canWrite(): Bool

功能：判断当前用户是否有权限写入该实例对应的文件。

对文件而言，判断用户是否有写入文件的权限
对目录而言，判断用户是否有删除、移动、创建目录内文件的权限
在 Windows 环境下，用户对于文件的可写权限正常使用，用户始终拥有对于目录的可写权限，该函数不生效，返回 true
在 Linux 和 macOS 环境下，该函数正常使用

异常：

FSException：如果判断过程中底层调用的系统接口发生错误，则抛异常

func setExecutable

public func setExecutable(executable: Bool): Bool

功能：对当前实例对应的文件设置当前用户是否可执行的权限，当前用户没有权限修改抛异常。

对文件而言，设置用户是否有执行文件的权限，对目录而言，设置用户是否有进入目录的权限
在 Windows 环境下，用户对于文件的执行权限由文件扩展名决定，用户始终拥有对于目录的执行权限该函数不生效，返回 false
在 Linux 和 macOS 环境下，该函数正常使用如果在此函数调用期间，该 FileInfo 对应的文件实体被其它用户或者进程修改，有可能因为竞争条件(Race Condition)导致其它修改不能生效

参数：

executable：是否设置可执行

返回值：true，操作成功；false，操作失败

func setReadable

public func setReadable(readable: Bool): Bool

功能：对当前实例对应的文件设置当前用户是否可读取的权限，当前用户没有权限修改抛异常。

对文件而言，设置用户是否有读取文件的权限
对目录而言，设置用户是否有浏览目录的权限
在 Windows 环境下，用户始终拥有对于文件以及目录的可读权限，不可更改，该函数不生效当 readable 为 true 时，函数返回 true，当 readable 为 false 时，函数返回 false
在 Linux 和 macOS 环境下，该函数正常使用如果在此函数调用期间，该 FileInfo 对应的文件实体被其它用户或者进程修改，有可能因为竞争条件(Race Condition)导致其它修改不能生效。

参数：

readable：是否设置可读

返回值：true，操作成功；false，操作失败

func setWritable

public func setWritable(writable: Bool): Bool

功能：对当前实例对应的文件设置当前用户是否可写入的权限，当前用户没有权限修改抛异常。

对文件而言，设置用户是否有写入文件的权限对
目录而言，设置用户是否有删除、移动、创建目录内文件的权限
在 Windows 环境下，用户对于文件的可写权限正常使用；用户始终拥有对于目录的可写权限，不可更改，该函数不生效，返回 false
在 Linux 和 macOS 环境下，该函数正常使用如果在此函数调用期间，该 FileInfo 对应的文件实体被其它用户或者进程修改，有可能因为竞争条件(Race Condition)导致其它修改不能生效

参数：

writable：是否设置可写

返回值：true，操作成功；false，操作失败

operator func ==

public operator func ==(that: FileInfo): Bool

功能：判断当前 FileInfo 和另一个 FileInfo 是否对应同一文件。

返回值：true，是同一文件；false，不是同一文件

operator func !=

public operator func !=(that: FileInfo): Bool

功能：判断当前 FileInfo 和另一个 FileInfo 是否对应非同一文件。

返回值：true，不是同一文件；false，是同一文件

class FSException

此类是文件流异常类，继承了异常类

public class FSException <: Exception {
    public init()
    public init(message: String)
}

init

public init()

功能：无参构造函数。

init

public init(message: String)

参数：

message：错误信息

from std import fs.Path

main() {
    let pathStrArr: Array<String> = [
        // 绝对路径
        "/a/b/c",
        "/a/b/",
        "/a/b/c.cj",
        "/a",
        "/",
        // 相对路径
        "./a/b/c",
        "./a/b/",
        "./a/b/c.cj",
        "./",
        ".",
        "123."
    ]

    for (i in 0..pathStrArr.size) {
        let path: Path = Path(pathStrArr[i])
        // 打印 path 的整个路径字符串
        println("Path${i}: ${path.toString()}")
        // 打印 path 的目录路径
        println("Path.directoryName: ${path.directoryName}")
        // 打印 path 的文件全名（有扩展名）
        println("Path.fileName: ${path.fileName}")
        // 打印 path 的扩展名
        println("Path.extensionName: ${path.extensionName}")
        // 打印 path 的文件名（无扩展名）
        println("Path.fileNameWithoutExtension: ${path.fileNameWithoutExtension}")
        // 打印 path 的拆分成的目录路径和文件全名
        var (directoryName, fileName): (Option<Path>, Option<String>) = path.split()
        println("Path.split: (${directoryName}, ${fileName})")
        // 打印 path 的是否是符号链接、普通文件、目录
        println("Path.isAbsolute: ${path.isAbsolute()}; Path.isRelative: ${path.isRelative()}")
        println()
    }

    return 0
}

运行结果如下：

Path0: /a/b/c
Path.directoryName: Some(/a/b)
Path.fileName: Some(c)
Path.extensionName: None
Path.fileNameWithoutExtension: Some(c)
Path.split: (Some(/a/b), Some(c))
Path.isAbsolute: true; Path.isRelative: false

Path1: /a/b/
Path.directoryName: Some(/a/b)
Path.fileName: None
Path.extensionName: None
Path.fileNameWithoutExtension: None
Path.split: (Some(/a/b), None)
Path.isAbsolute: true; Path.isRelative: false

Path2: /a/b/c.cj
Path.directoryName: Some(/a/b)
Path.fileName: Some(c.cj)
Path.extensionName: Some(cj)
Path.fileNameWithoutExtension: Some(c)
Path.split: (Some(/a/b), Some(c.cj))
Path.isAbsolute: true; Path.isRelative: false

Path3: /a
Path.directoryName: Some(/)
Path.fileName: Some(a)
Path.extensionName: None
Path.fileNameWithoutExtension: Some(a)
Path.split: (Some(/), Some(a))
Path.isAbsolute: true; Path.isRelative: false

Path4: /
Path.directoryName: Some(/)
Path.fileName: None
Path.extensionName: None
Path.fileNameWithoutExtension: None
Path.split: (Some(/), None)
Path.isAbsolute: true; Path.isRelative: false

Path5: ./a/b/c
Path.directoryName: Some(./a/b)
Path.fileName: Some(c)
Path.extensionName: None
Path.fileNameWithoutExtension: Some(c)
Path.split: (Some(./a/b), Some(c))
Path.isAbsolute: false; Path.isRelative: true

Path6: ./a/b/
Path.directoryName: Some(./a/b)
Path.fileName: None
Path.extensionName: None
Path.fileNameWithoutExtension: None
Path.split: (Some(./a/b), None)
Path.isAbsolute: false; Path.isRelative: true

Path7: ./a/b/c.cj
Path.directoryName: Some(./a/b)
Path.fileName: Some(c.cj)
Path.extensionName: Some(cj)
Path.fileNameWithoutExtension: Some(c)
Path.split: (Some(./a/b), Some(c.cj))
Path.isAbsolute: false; Path.isRelative: true

Path8: ./
Path.directoryName: Some(.)
Path.fileName: None
Path.extensionName: None
Path.fileNameWithoutExtension: None
Path.split: (Some(.), None)
Path.isAbsolute: false; Path.isRelative: true

Path9: .
Path.directoryName: None
Path.fileName: Some(.)
Path.extensionName: None
Path.fileNameWithoutExtension: None
Path.split: (None, Some(.))
Path.isAbsolute: false; Path.isRelative: true

Path10: 123.
Path.directoryName: None
Path.fileName: Some(123.)
Path.extensionName: None
Path.fileNameWithoutExtension: Some(123)
Path.split: (None, Some(123.))
Path.isAbsolute: false; Path.isRelative: true

Path 的拼接、判等、转规范化路径等操作

代码如下：

from std import fs.*

main() {
    let dirPath: Path = Path("./a/b/c")
    if (!Directory.exists(dirPath)) {
        Directory.create(dirPath, recursive: true)
    }

    let filePath: Path = dirPath.join("d.cj") // ./a/b/c/d.cj
    if (filePath == Path("./a/b/c/d.cj")) {
        println("filePath.join: success")
    }
    if (!File.exists(filePath)) {
        File.create(filePath).close()
    }

    let curNormalizedPath: Path = Path(".").toCanonical()
    let fileNormalizedPath: Path = Path("././././a/./../a/b/../../a/b/c/.././../../a/b/c/d.cj").toCanonical()
    if (fileNormalizedPath == filePath &&
        fileNormalizedPath.toString() == curNormalizedPath.toString() + "/a/b/c/d.cj") {
        println("filePath.toCanonical: success")
    }

    Directory.delete(dirPath, recursive: true)
    return 0
}

运行结果如下：

filePath.join: success
filePath.toCanonical: success

通过 Path 创建文件和目录

代码如下：

from std import fs.*

main() {
    let curPath: Path = Path("./")
    let dirPath: Path = curPath.join("tempDir")
    let filePath: Path = dirPath.join("tempFile.txt")
    if (Directory.exists(dirPath)) {
        Directory.delete(dirPath, recursive: true)
    }

    Directory.create(dirPath)
    if (Directory.exists(dirPath)) {
        println("Directory 'tempDir' is created successfully.")
    }

    File.create(filePath).close()
    if (File.exists(filePath)) {
        println("File 'tempFile.txt' is created successfully in directory 'tempDir'.")
    }

    Directory.delete(dirPath, recursive: true)
    return 0
}

运行结果如下：

Directory 'tempDir' is created successfully.
File 'tempFile.txt' is created successfully in directory 'tempDir'.

File 示例

File 常规操作：创建、删除、读写、关闭

代码如下：

from std import fs.*
from std import io.SeekPosition

main() {
    let filePath: Path = Path("./tempFile.txt")
    if (File.exists(filePath)) {
        File.delete(filePath)
    }

    /* 在当前目录以 只写模式 创建新文件 'tempFile.txt'，写入三遍 "123456789\n" 并关闭文件 */
    var file: File = File(filePath, OpenOption.Create(false))
    if (File.exists(filePath)) {
        println("The file 'tempFile.txt' is created successfully in current directory.\n")
    }
    let bytes: Array<Byte> = b"123456789\n"
    for (_ in 0..3) {
        file.write(bytes)
    }
    file.close()

    /* 以 追加模式 打开文件 './tempFile.txt'，写入 "abcdefghi\n" 并关闭文件 */
    file = File(filePath, OpenOption.Append)
    file.write(b"abcdefghi\n")
    file.close()

    /* 以 只读模式 打开文件 './tempFile.txt'，按要求读出数据并关闭文件 */
    file = File(filePath, OpenOption.Open(true, false))
    let bytesBuf: Array<Byte> = Array<Byte>(10, item: 0)
    // 从文件头开始的第 10 个字节后开始读出 10 个字节的数据
    file.seek(SeekPosition.Begin(10))
    file.read(bytesBuf)
    println("Data of the 10th byte after the 10th byte: ${String.fromUtf8(bytesBuf)}")
    // 读出文件尾的 10 个字节的数据
    file.seek(SeekPosition.End(-10))
    file.read(bytesBuf)
    println("Data of the last 10 bytes: ${String.fromUtf8(bytesBuf)}")
    file.close()

    /* 以 截断模式 打开文件 './tempFile.txt'，写入 "The file was truncated to an empty file!" 并关闭文件 */
    file = File(filePath, OpenOption.Truncate(true))
    file.write(b"The file was truncated to an empty file!")
    file.seek(SeekPosition.Begin(0))
    let allBytes: Array<Byte> = file.readToEnd()
    file.close()
    println("Data written newly: ${String.fromUtf8(allBytes)}")

    File.delete(filePath)
    return 0
}

运行结果如下：

The file 'tempFile.txt' is created successfully in current directory.

Data of the 10th byte after the 10th byte: 123456789

Data of the last 10 bytes: abcdefghi

Data written newly: The file was truncated to an empty file!

File 的一些 static 函数演示

代码如下：

from std import fs.*

main() {
    let filePath: Path = Path("./tempFile.txt")
    if (File.exists(filePath)) {
        File.delete(filePath)
    }

    /* 以 只写模式 创建文件，并写入 "123456789\n" 并关闭文件 */
    var file: File = File.create(filePath)
    file.write(b"123456789\n")
    file.close()

    /* 以 追加模式 写入 "abcdefghi\n" 到文件 */
    File.writeTo(filePath, b"abcdefghi", openOption: OpenOption.Append)

    /* 直接读取文件中所有数据 */
    let allBytes: Array<Byte> = File.readFrom(filePath)
    println(String.fromUtf8(allBytes))

    File.delete(filePath)
    return 0
}

运行结果如下：

123456789
abcdefghi

Directory 示例

Directory 一些基础操作演示

代码如下：

from std import fs.*

main() {
    let testDirPath: Path = Path("./testDir")
    let subDirPath: Path = Path("./testDir/subDir")
    if (Directory.exists(testDirPath)) {
        Directory.delete(testDirPath, recursive: true)
    }

    /* 递归创建目录 和 "./testDir/subDir" */
    let subDir: Directory = Directory.create(subDirPath, recursive: true)
    if (Directory.exists(subDirPath)) {
        println("The directory './testDir/subDir' is successfully created recursively in current directory.")
    }

    /* 在 "./testDir/subDir" 下创建子目录 "dir1" */
    subDir.createSubDirectory("dir1")
    if (Directory.exists("./testDir/subDir/dir1")) {
        println("The directory 'dir1' is created successfully in directory './testDir/subDir'.")
    }

    /* 在 "./testDir/subDir" 下创建子文件 "file1" */
    subDir.createFile("file1")
    if (File.exists("./testDir/subDir/file1")) {
        println("The file 'file1' is created successfully in directory './testDir/subDir'.")
    }

    /* 在 "./testDir" 下创建临时目录 */
    let tempDir: Directory = Directory.createTemp(testDirPath)
    let tempDirPath: Path = tempDir.info.path
    if (Directory.exists(tempDirPath)) {
        println("The temporary directory is created successfully in directory './testDir'.")
    }

    /* 将 "subDir" 移动到临时目录下并重命名为 "subDir_new" */
    let newSubDirPath: Path = tempDirPath.join("subDir_new")
    Directory.move(subDirPath, newSubDirPath, false)
    if (Directory.exists(newSubDirPath) && !Directory.exists(subDirPath)) {
        println("The directory './testDir/subDir' is moved successfully to the temporary directory and renamed 'subDir_new'.")
    }

    /* 将 "subDir_new" 拷贝到 "./testDir" 下并重命名为 "subDir" */
    Directory.copy(newSubDirPath, subDirPath, false)
    if (Directory.exists(subDirPath) && Directory.exists(newSubDirPath)) {
        println("The directory 'subDir_new' is copied successfully to directory './testDir' and renamed 'subDir'.")
    }

    Directory.delete(testDirPath, recursive: true)
    return 0
}

运行结果如下：

The directory './testDir/subDir' is successfully created recursively in current directory.
The directory 'dir1' is created successfully in directory './testDir/subDir'.
The file 'file1' is created successfully in directory './testDir/subDir'.
The temporary directory is created successfully in directory './testDir'.
The directory './testDir/subDir' is moved successfully to the temporary directory and renamed 'subDir_new'.
The directory 'subDir_new' is copied successfully to directory './testDir' and renamed 'subDir'.

FileInfo 示例

FileInfo 一些基础操作演示

代码如下：

from std import fs.*
from std import time.DateTime

main() {
    // 在当前目录下创建个临时文件以便下面 FileInfo 的演示
    let curDirPath: Path = Path("./").toCanonical()
    let file: File =  File.createTemp(curDirPath)
    file.write(b"123456789\n")
    let fileInfo: FileInfo = file.info

    file.close()

    /* 获得这个文件父级目录的 FileInfo，这个文件的父目录是当前目录 */
    let parentDirectory: Option<FileInfo> = fileInfo.parentDirectory
    checkResult(parentDirectory == Some(FileInfo(curDirPath)), "The 'parentFileInfo' is obtained successfully.")

    /* 获得这个文件的路径 */
    /*
    let filePath: Path = fileInfo.path
    */

    /* 如果文件是软链接，获得其链接文件的 Path，这里的文件不是软链接故是 Option<Path>.None */
    let symbolicLinkTarget: Option<Path> = fileInfo.symbolicLinkTarget
    checkResult(symbolicLinkTarget == None, "It's not a symbolic link, there's no `symbolicLinkTarget`.")

    /* 获取这个文件的创建时间、最后访问时间、最后修改时间 */
    /*
    let creationTime: DateTime = fileInfo.creationTime
    let lastAccessTime: DateTime = fileInfo.lastAccessTime
    let lastModificationTime: DateTime = fileInfo.lastModificationTime
    */

    /*
     * 获取这个文件的 length
     * 如果是文件代表这个文件占用磁盘空间的大小
     * 如果是目录代表这个目录的所有文件占用磁盘空间的大小(不包含子目录)
     */
    /*
    let length: Int64 = fileInfo.length
    */

    /* 判断这个文件是否是软链接、普通文件、目录 */
    checkResult(fileInfo.isSymbolicLink(), "The file is a symbolic link.")
    checkResult(fileInfo.isFile(), "The file is a common file.")
    checkResult(fileInfo.isDirectory(), "The file is a directory.")

    /* 判断这个文件对于当前用户是否是只读、隐藏、可执行、可读、可写 */
    checkResult(fileInfo.isReadOnly(), "This file is read-only.")
    checkResult(fileInfo.isHidden(), "The file is hidden.")
    checkResult(fileInfo.canExecute(), "The file is executable.")
    checkResult(fileInfo.canRead(), "The file is readable.")
    checkResult(fileInfo.canWrite(), "The file is writable.")

    /* 修改当前用户对这个文件的权限，这里设置为对当前用户只读 */
    checkResult(fileInfo.setExecutable(false), "The file was successfully set to executable.")
    checkResult(fileInfo.setReadable(true), "The file was successfully set to readable.")
    checkResult(fileInfo.setWritable(false), "The file was successfully set to writable.")
    checkResult(fileInfo.isReadOnly(), "This file is now read-only.")

    return 0
}

func checkResult(result: Bool, message: String): Unit {
    if (result) {
        println(message)
    }
}

运行结果如下：

The 'parentFileInfo' is obtained successfully.
It's not a symbolic link, there's no `symbolicLinkTarget`.
The file is a common file.
The file is readable.
The file is writable.
The file was successfully set to executable.
The file was successfully set to readable.
The file was successfully set to writable.
This file is now read-only.

仓颉用户手册