module String: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 -> (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 : string -> int -> bytes -> int -> int -> unit与 Bytes.blit_string 相同，应该优先使用后者。
注意。(^) 二元运算符连接两个字符串。
val concat : 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 出现在 s 中位置 start 之后时为 true。
Invalid_argument 如果 start 不是 s 中的有效位置。val rcontains_from : string -> int -> char -> boolrcontains_from s stop c 当且仅当 c 出现在 s 中位置 stop+1 之前时为 true。
Invalid_argument 如果 stop < 0 或 stop+1 不是 s 中的有效位置。val contains : string -> char -> boolcontains s c 是 String.contains_from s 0 c。
val sub : string -> int -> int -> stringsub s pos len 是长度为 len 的字符串，包含从位置 pos 开始并具有长度 len 的 s 的子字符串。
Invalid_argument 如果 pos 和 len 未指定 s 的有效子字符串。val split_on_char : 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 : (char -> char) -> string -> stringmap f s 是将 f 应用于 s 的所有字符（以递增顺序）得到的字符串。
val mapi : (int -> char -> char) -> string -> stringmapi f s 与 String.map 相似，但字符的索引也会传递给 f。
val fold_left : ('acc -> char -> 'acc) -> 'acc -> string -> 'accfold_left f x s 计算 f (... (f (f x s.[0]) s.[1]) ...) s.[n-1]，其中 n 是字符串 s 的长度。
val fold_right : (char -> 'acc -> 'acc) -> string -> 'acc -> 'accfold_right f s x 计算 f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...))，其中 n 是字符串 s 的长度。
val for_all : (char -> bool) -> string -> boolfor_all p s 检查 s 中的所有字符是否都满足谓词 p。
val exists : (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 : (char -> unit) -> string -> unititer f s 依次将函数 f 应用于 s 的所有字符。它等效于 f s.[0]; f s.[1]; ...; f s.[length s - 1]; ()。
val iteri : (int -> char -> unit) -> string -> unititeri 与 String.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 首次出现的索引（如果有）。
Invalid_argument 如果 i 不是 s 中的有效位置。val rindex_from : string -> int -> char -> intrindex_from s i c 是 s 中 i+1 位置之前的最后一个 c 的索引。
s 中 i+1 位置之前没有 c，则为 Not_found。i+1 不是 s 中的有效位置，则为 Invalid_argument。val rindex_from_opt : string -> int -> char -> int optionrindex_from_opt s i c 是 s 中 i+1 位置之前的最后一个 c 的索引（如果有）。
Invalid_argument 如果 i+1 不是 s 中的有效位置。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 与 String.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 是从字符索引 i 开始的 b 的无符号 8 位整数。
val get_int8 : string -> int -> intget_int8 b i 是从字符索引 i 开始的 b 的有符号 8 位整数。
val get_uint16_ne : string -> int -> intget_uint16_ne b i 是从字符索引 i 开始的 b 的本机端无符号 16 位整数。
val get_uint16_be : string -> int -> intget_uint16_be b i 是从字符索引 i 开始的 b 的大端无符号 16 位整数。
val get_uint16_le : string -> int -> intget_uint16_le b i 是从字符索引 i 开始的 b 的小端无符号 16 位整数。
val get_int16_ne : string -> int -> intget_int16_ne b i 是从字符索引 i 开始的 b 的本机端有符号 16 位整数。
val get_int16_be : string -> int -> intget_int16_be b i 是从字符索引 i 开始的 b 的大端有符号 16 位整数。
val get_int16_le : string -> int -> intget_int16_le b i 是从字符索引 i 开始的 b 的小端有符号 16 位整数。
val get_int32_ne : string -> int -> int32get_int32_ne b i 是从字符索引 i 开始的 b 的本机端 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 是从字符索引 i 开始的 b 的大端 32 位整数。
val get_int32_le : string -> int -> int32get_int32_le b i 是从字符索引 i 开始的 b 的小端 32 位整数。
val get_int64_ne : string -> int -> int64get_int64_ne b i 是从字符索引 i 开始的 b 的本机端 64 位整数。
val get_int64_be : string -> int -> int64get_int64_be b i 是从字符索引 i 开始的 b 的大端 64 位整数。
val get_int64_le : string -> int -> int64get_int64_le b i 是从字符索引 i 开始的 b 的小端 64 位整数。