module String: StringLabelstypet =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 出现在 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 -> pos:int -> len:int -> stringsub s ~pos ~len 是一个长度为 len 的字符串，包含 s 的子字符串，该子字符串从位置 pos 开始，长度为 len。
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 的索引（如果有）。
Invalid_argument 如果 i 不是 s 中的有效位置。val rindex_from : string -> int -> char -> intrindex_from s i c 是 s 中位置 i+1 之前最后一次出现 c 的索引。
Not_found 如果 c 在位置 i+1 之前没有出现在 s 中。Invalid_argument 如果 i+1 不是 s 中的有效位置。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 类似于 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 是从字符索引 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 位整数。