module StringLabels:sig..end
字符串。
长度为 n 的字符串 s 是 n 个字节的可索引且不可变的序列。由于历史原因，这些字节被称为字符。
字符串函数的语义是根据索引和位置定义的。这些如下所示和描述。
positions 0 1 2 3 4 n-1 n
+---+---+---+---+ +-----+
indices | 0 | 1 | 2 | 3 | ... | n-1 |
+---+---+---+---+ +-----+s 的索引 i 是范围 [0;n-1] 内的整数。它表示 s 的第 i 个字节（字符），可以使用常数时间字符串索引运算符 s.[i] 访问。s 的位置 i 是范围 [0;n] 内的整数。它表示字符串开头的点、两个索引之间的点或字符串末尾的点。第 i 个字节索引位于位置 i 和 i+1 之间。如果 len >= 0 且 start、start+len 是 s 的位置，则称两个整数 start 和 len 定义了 s 的有效子字符串。
Unicode 文本。字符串是任意字节序列，因此可以保存任何类型的文本编码。但是，在 OCaml 字符串中存储 Unicode 文本的推荐编码是 UTF-8。这是字符串文字中 Unicode 转义使用的编码。例如，字符串 "\u{1F42B}" 是 Unicode 字符 U+1F42B 的 UTF-8 编码。
过去的可变性。在 OCaml 4.02 之前，字符串像 Bytes.t 可变字节序列一样可以在原地修改。OCaml 4 有各种编译器标志和配置选项来支持从可变字符串到不可变字符串的过渡期。这些选项不再可用，字符串现在始终是不可变的。
此模块的带标签版本可以按照 StdLabels 模块中的描述使用。
typet =string
字符串的类型。
val make : int -> char -> stringmake n c 是一个长度为 n 的字符串，每个索引都包含字符 c。
Invalid_argument，如果 n < 0 或 n > Sys.max_string_length。val init : int -> f:(int -> char) -> stringinit n ~f 是一个长度为 n 的字符串，索引 i 包含字符 f i（按递增的索引顺序调用）。
Invalid_argument，如果 n < 0 或 n > Sys.max_string_length。val empty : string空字符串。
val length : string -> intlength s 是 s 的长度（字节/字符数）。
val get : string -> int -> charget s i 是 s 中索引 i 处的字符。这与编写 s.[i] 相同。
Invalid_argument，如果 i 不是 s 的索引。val of_bytes : bytes -> string返回一个新的字符串，其中包含与给定字节序列相同的字节。
val to_bytes : string -> bytes返回一个新的字节序列，其中包含与给定字符串相同的字节。
val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit与 Bytes.blit_string 相同，建议优先使用它。
注意。 (^) 二元运算符连接两个字符串。
val concat : sep:string -> string list -> stringconcat ~sep ss 连接字符串列表 ss，在每个字符串之间插入分隔符字符串 sep。
Invalid_argument，如果结果长度超过 Sys.max_string_length 个字节。val cat : string -> string -> stringcat s1 s2 连接 s1 和 s2 (s1 ^ s2)。
Invalid_argument，如果结果长度超过 Sys.max_string_length 个字节。val equal : t -> t -> boolequal s0 s1 当且仅当 s0 和 s1 字符级相等时为 true。
val compare : t -> t -> intcompare s0 s1 以字典顺序对 s0 和 s1 进行排序。 compare 的行为类似于字符串上的 compare，但可能更高效。
val starts_with : prefix:string -> string -> boolstarts_with ~prefix s 当且仅当 s 以 prefix 开头时为 true。
val ends_with : suffix:string -> string -> boolends_with ~suffix s 当且仅当 s 以 suffix 结尾时为 true。
val contains_from : string -> int -> char -> boolcontains_from s start c 当且仅当 c 出现在位置 start 之后 的 s 中时为 true。
Invalid_argument，如果 start 不是 s 中的有效位置。val rcontains_from : string -> int -> char -> boolrcontains_from s stop c 当且仅当 c 出现在位置 stop+1 之前 的 s 中时为 true。
Invalid_argument，如果 stop < 0 或 stop+1 不是 s 中的有效位置。val contains : string -> char -> boolcontains s c 是 String.contains_from s 0 c。
val sub : string -> pos:int -> len:int -> stringsub s ~pos ~len 是一个长度为 len 的字符串，包含从位置 pos 开始且长度为 len 的 s 的子字符串。
Invalid_argument，如果 pos 和 len 没有指定 s 的有效子字符串。val split_on_char : sep:char -> string -> string listsplit_on_char ~sep s 是 s 的所有（可能为空）子字符串的列表，这些子字符串由字符 sep 分隔。如果 s 为空，则结果为单例列表 [""]。
函数的结果由以下不变量指定
sep 作为分隔符连接其元素将返回一个等于输入的字符串 (concat (make 1 sep)
(split_on_char sep s) = s)。sep 字符。val map : f:(char -> char) -> string -> stringmap f s 是将 f 应用于 s 的所有字符（按递增顺序）后得到的字符串。
val mapi : f:(int -> char -> char) -> string -> stringmapi ~f s 类似于 StringLabels.map，但字符的索引也会传递给 f。
val fold_left : f:('acc -> char -> 'acc) -> init:'acc -> string -> 'accfold_left f x s 计算 f (... (f (f x s.[0]) s.[1]) ...) s.[n-1]，其中 n 是字符串 s 的长度。
val fold_right : f:(char -> 'acc -> 'acc) -> string -> init:'acc -> 'accfold_right f s x 计算 f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...))，其中 n 是字符串 s 的长度。
val for_all : f:(char -> bool) -> string -> boolfor_all p s 检查 s 中的所有字符是否都满足谓词 p。
val exists : f:(char -> bool) -> string -> boolexists p s 检查 s 中是否至少有一个字符满足谓词 p。
val trim : string -> stringtrim s 是 s 去除开头和结尾的空格后的结果。空格字符为：' '、'\x0C'（换页）、'\n'、'\r' 和 '\t'。
val escaped : string -> stringescaped s 是 s 中特殊字符用转义序列表示的结果，遵循 OCaml 的词法约定。
所有超出 US-ASCII 可打印范围 [0x20;0x7E] 的字符以及反斜杠 (0x2F) 和双引号 (0x22) 都会被转义。
函数 Scanf.unescaped 是 escaped 的左逆，即 Scanf.unescaped (escaped s) = s 对于任何字符串 s 都成立（除非 escaped s 失败）。
Invalid_argument，如果结果长度超过 Sys.max_string_length 个字节。val uppercase_ascii : string -> stringuppercase_ascii s 是 s 中所有小写字母都转换为大写字母的结果，使用 US-ASCII 字符集。
val lowercase_ascii : string -> stringlowercase_ascii s 是 s 中所有大写字母都转换为小写字母的结果，使用 US-ASCII 字符集。
val capitalize_ascii : string -> stringcapitalize_ascii s 是 s 中第一个字符转换为大写字母的结果，使用 US-ASCII 字符集。
val uncapitalize_ascii : string -> stringuncapitalize_ascii s 是 s 中第一个字符转换为小写字母的结果，使用 US-ASCII 字符集。
val iter : f:(char -> unit) -> string -> unititer ~f s 依次将函数 f 应用于 s 的所有字符。它等效于 f s.[0]; f s.[1]; ...; f s.[length s - 1]; ()。
val iteri : f:(int -> char -> unit) -> string -> unititeri 类似于 StringLabels.iter，但函数也会获得相应的字符索引。
val index_from : string -> int -> char -> intindex_from s i c 是 s 中位置 i 之后第一次出现 c 的索引。
Not_found，如果 c 在位置 i 之后没有出现在 s 中。Invalid_argument，如果 i 不是 s 中的有效位置。val index_from_opt : string -> int -> char -> int optionindex_from_opt s i c 是 s 中位置 i 之后第一次出现 c 的索引（如果存在）。
i不是s中的有效位置，则引发Invalid_argument异常。val rindex_from : string -> int -> char -> intrindex_from s i c是c在s中位置i+1之前最后一次出现的索引。
c在s中位置i+1之前没有出现，则返回Not_found。i+1不是s中的有效位置，则引发Invalid_argument异常。val rindex_from_opt : string -> int -> char -> int optionrindex_from_opt s i c是c在s中位置i+1之前最后一次出现的索引（如果存在）。
i+1不是s中的有效位置，则引发Invalid_argument异常。val index : string -> char -> intindex s c等价于String.index_from s 0 c。
val index_opt : string -> char -> int optionindex_opt s c等价于String.index_from_opt s 0 c。
val rindex : string -> char -> intrindex s c等价于String.rindex_from s (length s - 1) c。
val rindex_opt : string -> char -> int optionrindex_opt s c等价于String.rindex_from_opt s (length s - 1) c。
val to_seq : t -> char Seq.tto_seq s是一个由字符串字符按升序排列组成的序列。在"unsafe-string"模式下，迭代期间对字符串的修改将反映在序列中。
val to_seqi : t -> (int * char) Seq.tto_seqi s类似于StringLabels.to_seq，但还会将相应的索引作为元组。
val of_seq : char Seq.t -> tof_seq s是由序列字符组成的字符串。
val get_utf_8_uchar : t -> int -> Uchar.utf_decodeget_utf_8_uchar b i解码b中索引i处的UTF-8字符。
val is_valid_utf_8 : t -> boolis_valid_utf_8 b当且仅当b包含有效的UTF-8数据时为true。
val get_utf_16be_uchar : t -> int -> Uchar.utf_decodeget_utf_16be_uchar b i解码b中索引i处的UTF-16BE字符。
val is_valid_utf_16be : t -> boolis_valid_utf_16be b当且仅当b包含有效的UTF-16BE数据时为true。
val get_utf_16le_uchar : t -> int -> Uchar.utf_decodeget_utf_16le_uchar b i解码b中索引i处的UTF-16LE字符。
val is_valid_utf_16le : t -> boolis_valid_utf_16le b当且仅当b包含有效的UTF-16LE数据时为true。
本节中的函数将整数从字符串以二进制方式解码。
所有以下函数，如果在索引i处解码整数所需的字符不可用，则引发Invalid_argument异常。
小端序（resp. 大端序）编码表示最低（resp. 最高）有效字节存储在最前面。大端序也称为网络字节序。原生端序编码可以是小端序或大端序，具体取决于Sys.big_endian。
32位和64位整数分别由int32和int64类型表示，它们可以解释为有符号或无符号数。
8位和16位整数由int类型表示，它比二进制编码具有更多的位数。对于解码8位或16位整数并将其表示为int值的函数，这些额外的位将进行符号扩展（或零扩展）。
val get_uint8 : string -> int -> intget_uint8 b i是b从字符索引i开始的无符号8位整数。
val get_int8 : string -> int -> intget_int8 b i是b从字符索引i开始的有符号8位整数。
val get_uint16_ne : string -> int -> intget_uint16_ne b i是b从字符索引i开始的原生端序无符号16位整数。
val get_uint16_be : string -> int -> intget_uint16_be b i是b从字符索引i开始的大端序无符号16位整数。
val get_uint16_le : string -> int -> intget_uint16_le b i是b从字符索引i开始的小端序无符号16位整数。
val get_int16_ne : string -> int -> intget_int16_ne b i是b从字符索引i开始的原生端序有符号16位整数。
val get_int16_be : string -> int -> intget_int16_be b i是b从字符索引i开始的大端序有符号16位整数。
val get_int16_le : string -> int -> intget_int16_le b i是b从字符索引i开始的小端序有符号16位整数。
val get_int32_ne : string -> int -> int32get_int32_ne b i是b从字符索引i开始的原生端序32位整数。
val hash : t -> int一个用于字符串的无种子哈希函数，输出值与Hashtbl.hash相同。此函数允许将此模块作为参数传递给函子Hashtbl.Make。
val seeded_hash : int -> t -> int一个用于字符串的有种子哈希函数，输出值与Hashtbl.seeded_hash相同。此函数允许将此模块作为参数传递给函子Hashtbl.MakeSeeded。
val get_int32_be : string -> int -> int32get_int32_be b i是b从字符索引i开始的大端序32位整数。
val get_int32_le : string -> int -> int32get_int32_le b i是b从字符索引i开始的小端序32位整数。
val get_int64_ne : string -> int -> int64get_int64_ne b i是b从字符索引i开始的原生端序64位整数。
val get_int64_be : string -> int -> int64get_int64_be b i是b从字符索引i开始的大端序64位整数。
val get_int64_le : string -> int -> int64get_int64_le b i是b从字符索引i开始的小端序64位整数。