字符串 | String
弦
字符串是一个UTF-8编码的二进制文件.
编码和字形聚类
该模块中的功能按照Unicode标准9.0.0版执行。
按照标准，代码点是单个Unicode字符，可以用一个或多个字节表示。
例如，代码点“é”是两个字节：
iex> byte_size("é")
2
但是，该模块返回适当的长度：
iex> String.length("é")
1
此外，该模块还提出了字形集群的概念（从现在开始称为字形）。字素可以由多个代码点组成，读者可以将其看作单个字符。例如，“é”既可以表示为一个单独的“e with acute”代码点，也可以表示为字母“e”后跟“组合急性口音”（两个代码点）：
iex> string = "\u0065\u0301"
iex> byte_size(string)
3
iex> String.length(string)
1
iex> String.codepoints(string)
["e", "́"]
iex> String.graphemes(string)
["é"]
虽然上面的例子是由两个字符组成的，但用户认为它是一个。
图形符号也可以是被某些语言解释为一个的两个字符。例如，一些语言可能会将“ch”看作一个字符。但是，由于此信息取决于区域设置，因此本模块没有考虑到该信息。
通常，该模块中的函数依赖于Unicode标准，但不包含任何特定于地区的行为。
有关图形素的更多信息，请参见Unicode标准附件29.当前的药剂版实现了扩展的字形聚类算法。
有关将二进制转换为不同的编码和Unicode规范化机制，请参见Erlang的:unicode模块。
字符串和二进制操作
为了符合Unicode标准，这个模块中的许多函数都是以线性时间运行的，因为它们需要遍历整个字符串，同时考虑到适当的Unicode编码点。
例如，String.length/1随着输入的增长，需要更长的时间。另一方面，Kernel.byte_size/1总是以恒定时间运行（即不管输入大小）。
这意味着与直接使用二进制文件的更低级别的操作相比，在使用本模块中的函数时往往会产生性能成本：
Kernel.binary_part/3-检索二进制文件的一部分
Kernel.bit_size/1和Kernel.byte_size/1-与规模有关的职能
Kernel.is_bitstring/1和Kernel.is_binary/1-类型检查功能
- 另外还有一些在模块中处理二进制文件（字节）的函数
:binary
在许多情况下，使用String模块可以避免，有利于二进制函数或模式匹配。例如，假设您有一个字符串prefix并且您希望从另一个名为full...
人们可能会想写：
iex> take_prefix = fn full, prefix ->
...> base = String.length(prefix)
...> String.slice(full, base, String.length(full) - base)
...> end
iex> take_prefix.("Mr. John", "Mr. ")
"John"
虽然上面的函数工作，但性能很差。为了计算字符串的长度，我们需要完全遍历它，所以我们遍历这两个字符串。prefix和full字符串，然后将full第一，再过一遍。
改进它的第一次尝试可能是使用范围：
iex> take_prefix = fn full, prefix ->
...> base = String.length(prefix)
...> String.slice(full, base..-1)
...> end
iex> take_prefix.("Mr. John", "Mr. ")
"John"
虽然这好得多（我们不会遍历full两次），但它仍然可以改进。在这种情况下，因为我们想从字符串中提取一个子字符串，所以我们可以使用Kernel.byte_size/1，Kernel.binary_part/3因为我们不可能在由多个字节组成的代码点中切片：
iex> take_prefix = fn full, prefix ->
...> base = byte_size(prefix)
...> binary_part(full, base, byte_size(full) - base)
...> end
iex> take_prefix.("Mr. John", "Mr. ")
"John"
或者简单地使用模式匹配：
iex> take_prefix = fn full, prefix ->
...> base = byte_size(prefix)
...> <<_::binary-size(base), rest::binary>> = full
...> rest
...> end
iex> take_prefix.("Mr. John", "Mr. ")
"John"
另一方面，如果要根据整数值动态分割字符串，则使用String.slice/3这是最好的选择，因为它保证我们不会错误地将一个有效的代码点分割成多个字节。
整数码点
虽然代码点可以表示为整数，但这个模块将所有代码点表示为字符串。例如：
iex> String.codepoints("olá")
["o", "l", "á"]
有几种方法可以检索字符整数代码点。可以使用?建造：
iex> ?o
111
iex> ?á
225
也可以通过模式匹配：
iex> <<aacute::utf8>> = "á"
iex> aacute
225
正如我们前面所看到的，代码点可以通过十六进制代码插入到字符串中：
"ol\u0061\u0301" #=>
"olá"
自同步
UTF-8编码是自同步的。这意味着如果遇到格式错误的数据（即根据编码定义不可能的数据），则只需要拒绝一个码点。
此模块依赖于此行为来忽略此类无效字符。例如，length/1将返回一个正确的结果，即使一个无效的代码点被输入到它。
换句话说，该模块期望在其他地方检测到无效数据，通常是在从外部源检索数据时。例如，从数据库读取字符串的驱动程序将负责检查编码的有效性。String.chunk/2可用于将字符串拆分为有效和无效的部分。
模式
本模块中的许多功能都与模式一起工作。例如，String.split/2可以将字符串拆分为给定模式的多个模式。此模式可以是字符串、字符串列表或已编译模式：
iex> String.split("foo bar", " ")
["foo", "bar"]
iex> String.split("foo bar!", [" ", "!"])
["foo", "bar", ""]
iex> pattern = :binary.compile_pattern([" ", "!"])
iex> String.split("foo bar!", pattern)
["foo", "bar", ""]
当相同的匹配将一次又一次地进行时，编译的模式非常有用。注意，虽然编译后的模式不能存储在模块属性中，因为模式是在运行时生成的，并且不能在编译条件下生存下来。
摘要
类型
码点（）字形（）图案（）T（）
功能
在（字符串，位置）
返回在position-8string.如果position大于string长度，然后返回nil
capitalize(string)
将给定字符串中的第一个字符转换为大写，其余部分转换为小写。
chunk(string, trait)
将字符串拆分为具有共同特征的字符块。
codepoints(string)
返回字符串中的所有代码点。
contains?(string, contents)
检查string包含任何给定的contents
downcase(binary)
将给定字符串中的所有字符转换为小写。
duplicate(subject, n)
返回字符串。subject复制n时代
ends_with?(string, suffixes)
回报true如果string以给定的任何后缀结尾
equivalent?(string1, string2)
回报true如果string1是规范上等同于“string 2”的。
first(string)
从UTF-8字符串返回第一个字元，nil如果字符串为空
graphemes(string)
返回字符串中的Unicode图形素，按照扩展的字素聚类算法。
jaro_distance(string1, string2)
返回介于0之间的浮点值（相当于没有相似性）和1（表示精确匹配），表示之间和之间的Jaro距离string1string2
去年（串）
返回UTF-8字符串中的最后一个字元，nil如果字符串为空
length(string)
返回utf-8字符串中的unicode图形符号数。
match?(string, regex)
检查string匹配给定的正则表达式。
myers_difference(string1, string2)
返回表示编辑脚本的关键字列表。
next_codepoint(string)
返回字符串中的下一个代码点。
next_grapheme(binary)
返回字符串中的下一个字元。
next_grapheme_size(string)
返回下一个字元的大小。
normalize(string, form)
中的所有字符string标识为Unicode规范化表单form
pad_leading(string, count, padding \ [" "])
返回一个新的字符串填充，该填充由padding
pad_trailing(string, count, padding \ [" "])
返回一个新的字符串填充，该填充由padding
printable?(string, counter \ :infinity)
检查字符串是否仅包含可打印字符。
replace(subject, pattern, replacement, options \ [])
返回一个新字符串，该字符串是通过替换pattern在subject带着replacement
replace_leading(string, match, replacement)
替换match通过replacement成match在string
replace_prefix(string, match, replacement)
替换前缀string通过replacement如果匹配的话match
replace_suffix(string, match, replacement)
替换后缀string通过replacement如果匹配的话match
replace_trailing(string, match, replacement)
替换match通过replacement在string
reverse(string)
反转给定字符串中的图形素。
slice(string, range)
从范围开始时给定的偏移量返回一个子字符串到范围结束时的偏移量。
slice(string, start, len)
返回从偏移量开始的子字符串。start，以及长度len
split(binary)
在每个Unicode空格出现时将字符串划分为子字符串，忽略前导空格和尾随空格。空白组被视为单个事件。分隔不发生在不间断的空格上。
split(string, pattern, options \ [])
根据模式将字符串划分为子字符串。
split_at(string, position)
在指定的偏移量处将字符串拆分为两个。当给定的偏移量为负值时，从字符串的末尾计算位置。
splitter(string, pattern, options \ [])
返回可根据需要拆分字符串的枚举。
starts_with?(string, prefix)
回报true如果string从给定的任何前缀开始
to_atom(string)
将字符串转换为原子
to_charlist(string)
将字符串转换为字符列表
to_existing_atom(string)
将字符串转换为现有的原子。
to_float(string)
返回文本表示为string
to_integer(string)
返回文本表示为string
to_integer(string, base)
返回文本表示为string在基地base
trim(string)
返回一个字符串，其中删除了所有引导和尾随Unicode空白空间。
trim(string, to_trim)
返回一个字符串，在该字符串中，所有的前导和尾随to_trimS已被移除
trim_leading(string)
返回一个字符串，在该字符串中，已删除了所有领先的Unicode空白空间。
trim_leading(string, to_trim)
返回一个字符串，其中所有前导to_trimS已被移除
trim_trailing(string)
返回一个字符串，在该字符串中，已删除了所有拖尾Unicode空白空间。
trim_trailing(string, to_trim)
返回一个字符串，其中所有的尾随to_trimS已被移除
upcase(binary)
将给定字符串中的所有字符转换为大写。
valid?(string)
检查是否string只包含有效字符
类型
codepoint()
codepoint() :: t
grapheme()
grapheme() :: t
pattern()
pattern() :: t | [t] | :binary.cp
t()
t() :: binary
功能
at(string, position)
at(t, integer) :: grapheme | nil
返回在position-8string.如果position大于string长度，然后返回nil...
实例
iex> String.at("elixir", 0)
"e"
iex> String.at("elixir", 1)
"l"
iex> String.at("elixir", 10)
nil
iex> String.at("elixir", -1)
"r"
iex> String.at("elixir", -10)
nil
capitalize(string)
capitalize(t) :: t
将给定字符串中的第一个字符转换为大写，其余部分转换为小写。
这依赖于Unicode标准提供的标题信息。请注意，此函数不会尝试大写字符串中的所有单词（通常称为titlecase）。
实例
iex> String.capitalize("abcd")
"Abcd"
iex> String.capitalize("fin")
"Fin"
iex> String.capitalize("olá")
"Olá"
chunk(string, trait)
chunk(t, :valid | :printable) :: [t]
将字符串拆分为具有共同特征的字符块。
这种特性可以是两种选择之一：
:valid-字符串被分割为有效字符序列和无效字符序列块。
:printable-字符串被分割为可打印字符序列和不可打印字符序列块。
返回二进制文件的列表，每个二进制文件只包含一种类型的字符。
如果给定的字符串为空，则返回空列表。
实例
iex> String.chunk(<<?a, ?b, ?c, 0>>, :valid)
["abc\0"]
iex> String.chunk(<<?a, ?b, ?c, 0, 0xFFFF::utf16>>, :valid)
["abc\0", <<0xFFFF::utf16>>]
iex> String.chunk(<<?a, ?b, ?c, 0, 0x0FFFF::utf8>>, :printable)
["abc", <<0, 0x0FFFF::utf8>>]
codepoints(string)
codepoints(t) :: [codepoint]
返回字符串中的所有代码点。
有关代码点和图形符号的详细信息，请参阅String模块文件。
实例
iex> String.codepoints("olá")
["o", "l", "á"]
iex> String.codepoints("оптими зации")
["о", "п", "т", "и", "м", "и", " ", "з", "а", "ц", "и", "и"]
iex> String.codepoints("ἅἪῼ")
["ἅ", "Ἢ", "ῼ"]
iex> String.codepoints("é")
["é"]
iex> String.codepoints("é")
["e", "́"]
contains?(string, contents)
contains?(t, pattern) :: boolean
检查string包含任何给定的contents...
contents可以是单个字符串，也可以是字符串列表。
实例
iex> String.contains? "elixir of life", "of"
true
iex> String.contains? "elixir of life", ["life", "death"]
true
iex> String.contains? "elixir of life", ["death", "mercury"]
false
空字符串总是匹配的：
iex> String.contains? "elixir of life", ""
true
iex> String.contains? "elixir of life", ["", "other"]
true
参数也可以是预编译的模式：
iex> pattern = :binary.compile_pattern(["life", "death"])
iex> String.contains? "elixir of life", pattern
true
downcase(binary)
downcase(t) :: t
将给定字符串中的所有字符转换为小写。
实例
iex> String.downcase("ABCD")
"abcd"
iex> String.downcase("AB 123 XPTO")
"ab 123 xpto"
iex> String.downcase("OLÁ")
"olá"
duplicate(subject, n)
duplicate(t, non_neg_integer) :: t
返回字符串。subject复制n时代。
由编译器内联。
实例
iex> String.duplicate("abc", 0)
""
iex> String.duplicate("abc", 1)
"abc"
iex> String.duplicate("abc", 2)
"abcabc"
ends_with?(string, suffixes)
ends_with?(t, t | [t]) :: boolean
回报true如果string以给定的任何后缀结尾。
suffixes可以是单个后缀，也可以是后缀列表。
实例
iex> String.ends_with? "language", "age"
true
iex> String.ends_with? "language", ["youth", "age"]
true
iex> String.ends_with? "language", ["youth", "elixir"]
false
空后缀总是匹配的：
iex> String.ends_with? "language", ""
true
iex> String.ends_with? "language", ["", "other"]
true
equivalent?(string1, string2)
equivalent?(t, t) :: boolean
返回true如果string1与'string2'正常等价。
在比较它们之前，它会对字符串执行规范化表单规范分解（Normalization Decomposition，NFD）。这个功能相当于：
String.normalize(string1, :nfd) == String.normalize(string2, :nfd)
因此，如果您计划对多个字符串进行比较，连续进行多次比较，则可以预先将它们规范化，并直接比较它们，以避免多次规范化传递。
实例
iex> String.equivalent?("abc", "abc")
true
iex> String.equivalent?("man\u0303ana", "mañana")
true
iex> String.equivalent?("abc", "ABC")
false
iex> String.equivalent?("nø", "nó")
false
first(string)
first(t) :: grapheme | nil
从UTF-8字符串返回第一个字元，如果字符串是空的返回nil。
实例
iex> String.first("elixir")
"e"
iex> String.first("եոգլի")
"ե"
图形素%28字符串%29
graphemes(t) :: [grapheme]
返回字符串中的Unicode图形素，按照扩展的字素聚类算法。
该算法在Unicode标准附件#29，Unicode文本分割...
有关代码点和图形符号的详细信息，请参阅String模块文件。
实例
iex> String.graphemes("Ńaïve")
["Ń", "a", "ï", "v", "e"]
iex> String.graphemes("é")
["é"]
iex> String.graphemes("é")
["é"]
jaro_distance(string1, string2)
jaro_distance(t, t) :: float
返回介于0之间的浮点值（相当于没有相似性）和1（表示精确匹配），表示之间和之间的Jaro距离。string1string2
Jaro距离度量是为短字符串(如人名)设计的，也是最适合的。
实例
iex> String.jaro_distance("dwayne", "duane")
0.8222222222222223
iex> String.jaro_distance("even", "odd")
0.0
last(string)
last(t) :: grapheme | nil
返回UTF-8字符串中的最后一个字元，如果字符串是空的返回nil。
实例
iex> String.last("elixir")
"r"
iex> String.last("եոգլի")
"ի"
length(string)
length(t) :: non_neg_integer
返回UTF-8字符串中Unicode图形符号的数目。
实例
iex> String.length("elixir")
6
iex> String.length("եոգլի")
5
match?(string, regex)
match?(t, Regex.t) :: boolean
检查string匹配给定的正则表达式。
实例
iex> String.match?("foo", ~r/foo/)
true
iex> String.match?("bar", ~r/foo/)
false
myers_difference(string1, string2)
myers_difference(t, t) :: [{:eq | :ins | :del, t}] | nil
返回表示编辑脚本的关键字列表。
查帐List.myers_difference/2想了解更多信息。
实例
iex> string1 = "fox hops over the dog"
iex> string2 = "fox jumps over the lazy cat"
iex> String.myers_difference(string1, string2)
[eq: "fox ", del: "ho", ins: "jum", eq: "ps over the ", del: "dog", ins: "lazy cat"]
next_codepoint(string)
next_codepoint(t) :: {codepoint, t} | nil
返回字符串中的下一个代码点。
结果是一个包含代码点和字符串的剩余部分的元组，或者nil以防字符串到达终点。
与字符串模块中的其他函数一样，此函数不检查代码点的有效性。也就是说，如果找到无效的代码点，这个函数将返回它。
实例
iex> String.next_codepoint("olá")
{"o", "lá"}
next_grapheme(binary)
next_grapheme(t) :: {grapheme, t} | nil
返回字符串中的下一个字元。
结果是一个元组，其中包含字形素和字符串的其余部分，或者nil以防字符串到达终点。
实例
iex> String.next_grapheme("olá")
{"o", "lá"}
next_grapheme_size(string)
next_grapheme_size(t) :: {pos_integer, t} | nil
返回下一个字元的大小。
结果是一个元组，其下一个字素大小和字符串的剩余部分或nil以防字符串到达终点。
实例
iex> String.next_grapheme_size("olá")
{1, "lá"}
normalize(string, form)
normalize(t, atom) :: t
将所有字符转换string为由标识的Unicode标准化格式form。
表格
支持的表格是：
:nfd-正则分解的规范化形式。字符按照规范等价进行分解，多个组合字符按特定顺序排列。
:nfc-规范组成的规范化形式。对字符进行分解，然后用规范等价的方法重新组合字符。
实例
iex> String.normalize("yêṩ", :nfd)
"yêṩ"
iex> String.normalize("leña", :nfc)
"leña"
pad_leading(string, count, padding \ " ")
pad_leading(t, non_neg_integer, t | [t]) :: t
返回一个新的字符串，填充由前导元素组成的前导填充符padding。
将字符串列表作为padding将在列表中为每一个缺失项提取一个元素。如果列表比插入的数量短，填充将从列表的开始重新开始。传递字符串padding等于传递其中的图形素列表。如果没有padding则默认为空格。
当count小于或等于给定的长度时string，返回string。
ArgumentError如果给定padding包含非字符串元素，则引发。
实例
iex> String.pad_leading("abc", 5)
" abc"
iex> String.pad_leading("abc", 4, "12")
"1abc"
iex> String.pad_leading("abc", 6, "12")
"121abc"
iex> String.pad_leading("abc", 5, ["1", "23"])
"123abc"
pad_trailing(string, count, padding \ " ")
pad_trailing(t, non_neg_integer, t | [t]) :: t
返回一个新的字符串填充，该填充由padding...
将字符串列表作为padding将在列表中为每一个缺失项提取一个元素。如果列表比插入的数量短，填充将从列表的开始重新开始。传递字符串padding等于传递其中的图形素列表。如果没有padding则默认为空格。
当count小于或等于给定的长度时string，返回string。
提高ArgumentError如果给定padding包含非字符串元素。
实例
iex> String.pad_trailing("abc", 5)
"abc "
iex> String.pad_trailing("abc", 4, "12")
"abc1"
iex> String.pad_trailing("abc", 6, "12")
"abc121"
iex> String.pad_trailing("abc", 5, ["1", "23"])
"abc123"
printable?(string, counter \ :infinity)
printable?(t, non_neg_integer | :infinity) :: boolean
检查字符串是否仅包含可打印字符。
可选limit作为第二个论点。printable?/2只检查字符串的可打印性，直到limit...
实例
iex> String.printable?("abc")
true
iex> String.printable?("abc" <> <<0>>)
false
iex> String.printable?("abc" <> <<0>>, 2)
true
replace(subject, pattern, replacement, options \ [])
replace(t, pattern | Regex.t, t, keyword) :: t
返回一个新字符串，该字符串是通过替换pattern在subject带着replacement...
这pattern可能是一个字符串或正则表达式。
默认情况下，它将替换所有出现的事件，但此行为可以通过:global选项；请参见下面的“选项”部分。
备选方案
:global- （布尔值）如果true所有出现的pattern元素被替换replacement，否则只有第一个元素被替换。默认为true
:insert_replaced- （整数或整数列表）指定将替换零件插入到的位置replacement。如果:insert_replaced选项中给出的任何位置大于替换字符串，或者是负值，ArgumentError则会提高。看下面的例子
实例
iex> String.replace("a,b,c", ",", "-")
"a-b-c"
iex> String.replace("a,b,c", ",", "-", global: false)
"a-b,c"
当模式是正则表达式时，可以给出\N或\g{N}在replacement字符串访问正则表达式中的特定捕获：
iex> String.replace("a,b,c", ~r/,(.)/, ",\\1\\g{1}")
"a,bb,cc"
注意我们必须转义反斜杠转义字符（也就是说，我们用它\\N来代替只是\N为了避免反斜杠;同样的事情\\g{N}）。通过给予\0，可以在替换字符串中注入整个匹配模式。
当模式是一个字符串时，开发人员可以replacement通过使用该:insert_replaced选项并replacement在字符串模式的插入位置内指定位置来使用被替换的部分：
iex> String.replace("a,b,c", "b", "[]", insert_replaced: 1)
"a,[b],c"
iex> String.replace("a,b,c", ",", "[]", insert_replaced: 2)
"a[],b[],c"
iex> String.replace("a,b,c", ",", "[]", insert_replaced: [1, 1])
"a[,,]b[,,]c"
replace_leading(string, match, replacement)
replace_leading(t, t, t) :: t | no_return
替换match通过replacement成match在string...
如果没有发生事件，则返回未触及的字符串。
如果match是""，则此函数引发ArgumentError异常：发生这种情况是因为此函数替换了开始处的所有事件，并且不可能替换“多次”出现的事件。matchstring""
实例
iex> String.replace_leading("hello world", "hello ", "")
"world"
iex> String.replace_leading("hello hello world", "hello ", "")
"world"
iex> String.replace_leading("hello world", "hello ", "ola ")
"ola world"
iex> String.replace_leading("hello hello world", "hello ", "ola ")
"ola ola world"
replace_prefix(string, match, replacement)
replace_prefix(t, t, t) :: t
如果匹配string，replacement则替换前缀match。
如果不匹配，则返回未触及的字符串。如果match是一个空字符串（""），replacement则只是作为前缀string。
实例
iex> String.replace_prefix("world", "hello ", "")
"world"
iex> String.replace_prefix("hello world", "hello ", "")
"world"
iex> String.replace_prefix("hello hello world", "hello ", "")
"hello world"
iex> String.replace_prefix("world", "hello ", "ola ")
"world"
iex> String.replace_prefix("hello world", "hello ", "ola ")
"ola world"
iex> String.replace_prefix("hello hello world", "hello ", "ola ")
"ola hello world"
iex> String.replace_prefix("world", "", "hello ")
"hello world"
replace_suffix(string, match, replacement)
replace_suffix(t, t, t) :: t
如果匹配string，replacement则替换后缀match。
如果不匹配，则返回未触及的字符串。如果match是一个空字符串（""），replacement则仅附加到string。
实例
iex> String.replace_suffix("hello", " world", "")
"hello"
iex> String.replace_suffix("hello world", " world", "")
"hello"
iex> String.replace_suffix("hello world world", " world", "")
"hello world"
iex> String.replace_suffix("hello", " world", " mundo")
"hello"
iex> String.replace_suffix("hello world", " world", " mundo")
"hello mundo"
iex> String.replace_suffix("hello world world", " world", " mundo")
"hello world mundo"
iex> String.replace_suffix("hello", "", " world")
"hello world"
replace_trailing(string, match, replacement)
replace_trailing(t, t, t) :: t | no_return
替换match通过replacement在string...
如果没有发生事件，则返回未触及的字符串。
如果match是""，则此函数引发一个ArgumentError异常：发生这种情况是因为此函数替换了所有出现match的末尾string，并且不可能替换“多次”出现的位置""。
实例
iex> String.replace_trailing("hello world", " world", "")
"hello"
iex> String.replace_trailing("hello world world", " world", "")
"hello"
iex> String.replace_trailing("hello world", " world", " mundo")
"hello mundo"
iex> String.replace_trailing("hello world world", " world", " mundo")
"hello mundo mundo"
reverse(string)
reverse(t) :: t
反转给定字符串中的图形素。
实例
iex> String.reverse("abcd")
"dcba"
iex> String.reverse("hello world")
"dlrow olleh"
iex> String.reverse("hello ∂og")
"go∂ olleh"
请记住，两次反向相同的字符串并不一定会产生原始字符串：
iex> "̀e"
"̀e"
iex> String.reverse("̀e")
"è"
iex> String.reverse String.reverse("̀e")
"è"
在第一个例子中，重音在元音之前，所以它被认为是两个字形。但是，当你将它翻转一次时，就会有元音后面跟着重音，变成一个字形。再次颠倒它将保持它作为一个单独的字形。
slice(string, range)
slice(t, Range.t) :: t
从范围开始时给定的偏移量返回一个子字符串到范围结束时给定的偏移量。
如果范围的开始不是给定字符串的有效偏移量，或者范围的顺序相反，则返回""。
如果范围的开始或结束为负值，则首先遍历整个字符串，以便将负索引转换为正索引。
请记住，此功能可以与Unicode字形一起使用，并将切片视为代表字形偏移量。如果你想分割原始字节，请检查Kernel.binary_part/3。
实例
iex> String.slice("elixir", 1..3)
"lix"
iex> String.slice("elixir", 1..10)
"lixir"
iex> String.slice("elixir", 10..3)
""
iex> String.slice("elixir", -4..-1)
"ixir"
iex> String.slice("elixir", 2..-1)
"ixir"
iex> String.slice("elixir", -4..6)
"ixir"
iex> String.slice("elixir", -1..-4)
""
iex> String.slice("elixir", -10..-7)
""
iex> String.slice("a", 0..1500)
"a"
iex> String.slice("a", 1..1500)
""
slice(string, start, len)
slice(t, integer, integer) :: grapheme
返回从偏移量开始的子字符串。start，以及长度len...
如果偏移量大于字符串长度，则返回""...
请记住，此功能可以与Unicode字形一起使用，并将切片视为代表字形偏移量。如果你想分割原始字节，请检查Kernel.binary_part/3。
实例
iex> String.slice("elixir", 1, 3)
"lix"
iex> String.slice("elixir", 1, 10)
"lixir"
iex> String.slice("elixir", 10, 3)
""
iex> String.slice("elixir", -4, 4)
"ixir"
iex> String.slice("elixir", -10, 3)
""
iex> String.slice("a", 0, 1500)
"a"
iex> String.slice("a", 1, 1500)
""
iex> String.slice("a", 2, 1500)
""
split(binary)
split(t) :: [t]
在每个Unicode空白处将字符串划分为子字符串，忽略前导和尾随空白。空白组被视为单个事件。在不中断的空白处不会发生分割。
实例
iex> String.split("foo bar")
["foo", "bar"]
iex> String.split("foo" <> <<194, 133>> <> "bar")
["foo", "bar"]
iex> String.split(" foo bar ")
["foo", "bar"]
iex> String.split("no\u00a0break")
["no\u00a0break"]
split(string, pattern, options \ [])
split(t, pattern | Regex.t, keyword) :: [t]
根据模式将字符串划分为子字符串。
返回这些子字符串的列表。模式可以是字符串、字符串列表或正则表达式。
默认情况下，字符串被分割成尽可能多的部分，但是可以通过:parts选择。
只有在以下情况下，才会从结果中删除空字符串：:trim选项设置为true...
当使用的模式是正则表达式时，字符串将使用Regex.split/3...
备选方案
:parts（正整数或:infinity） - 该字符串最多可以被分割为与此选项指定的部分一样多的部分。如果:infinity，字符串将被拆分成所有可能的部分。默认为:infinity。
:trim（boolean） - 如果true从结果列表中删除空字符串。
这个函数也接受Regex.split/3if pattern是一个正则表达式接受的所有选项。
实例
用字符串模式分裂：
iex> String.split("a,b,c", ",")
["a", "b", "c"]
iex> String.split("a,b,c", ",", parts: 2)
["a", "b,c"]
iex> String.split(" a b c ", " ", trim: true)
["a", "b", "c"]
模式清单：
iex> String.split("1,2 3,4", [" ", ","])
["1", "2", "3", "4"]
正则表达式：
iex> String.split("a,b,c", ~r{,})
["a", "b", "c"]
iex> String.split("a,b,c", ~r{,}, parts: 2)
["a", "b,c"]
iex> String.split(" a b c ", ~r{\s}, trim: true)
["a", "b", "c"]
iex> String.split("abc", ~r{b}, include_captures: true)
["a", "b", "c"]
在空模式上拆分返回图形符号：
iex> String.split("abc", ~r{})
["a", "b", "c", ""]
iex> String.split("abc", "")
["a", "b", "c", ""]
iex> String.split("abc", "", trim: true)
["a", "b", "c"]
iex> String.split("abc", "", parts: 2)
["a", "bc"]
还可以给出预编译模式：
iex> pattern = :binary.compile_pattern([" ", ","])
iex> String.split("1,2 3,4", pattern)
["1", "2", "3", "4"]
split_at(string, position)
split_at(t, integer) :: {t, t}
在指定的偏移量处将字符串拆分为两个。当给定的偏移量为负值时，从字符串的末尾计算位置。
偏移量以字符串的长度为上限。返回包含两个元素的元组。
注意：记住这个函数在字形上分割，因此它必须线性地遍历字符串。如果您想根据字节数分割字符串或二进制文件，请Kernel.binary_part/3改为使用。
实例
iex> String.split_at "sweetelixir", 5
{"sweet", "elixir"}
iex> String.split_at "sweetelixir", -6
{"sweet", "elixir"}
iex> String.split_at "abc", 0
{"", "abc"}
iex> String.split_at "abc", 1000
{"abc", ""}
iex> String.split_at "abc", -1000
{"", "abc"}
splitter(string, pattern, options \ [])
splitter(t, pattern, keyword) :: Enumerable.t
返回可根据需要拆分字符串的枚举。
这与split/3把所有的字符串都先分开。
注意分隔符不支持正则表达式（因为正则表达式一次遍历字符串比多次传递效率更高）。
备选方案
- ：修剪 - 何时
true，不会发出空白图案
实例
iex> String.splitter("1,2 3,4 5,6 7,8,...,99999", [" ", ","]) |> Enum.take(4)
["1", "2", "3", "4"]
iex> String.splitter("abcd", "") |> Enum.take(10)
["a", "b", "c", "d", ""]
iex> String.splitter("abcd", "", trim: true) |> Enum.take(10)
["a", "b", "c", "d"]
starts_with?(string, prefix)
starts_with?(t, t | [t]) :: boolean
如果string从任何给定的前缀开始返回true。
prefix可以是单个前缀，也可以是前缀列表。
实例
iex> String.starts_with? "elixir", "eli"
true
iex> String.starts_with? "elixir", ["erlang", "elixir"]
true
iex> String.starts_with? "elixir", ["erlang", "ruby"]
false
空字符串总是匹配的：
iex> String.starts_with? "elixir", ""
true
iex> String.starts_with? "elixir", ["", "other"]
true
to_atom(string)
to_atom(String.t) :: atom
将字符串转换为原子。
警告：这个函数动态地创建原子，原子不被垃圾收集。因此，string不应该是不可信的值，例如从套接字或网络请求期间收到的输入。考虑to_existing_atom/1改用。
默认情况下，最大的原子数是1_048_576。使用VM选项可以提高或降低此限制+t。
最大原子大小为255个字符。在OTP 20之前，只允许使用延迟一个字符。
编译器插入。
实例
iex> String.to_atom("my_atom")
:my_atom
to_charlist(string)
to_charlist(t) :: charlist
将字符串转换为字符列表。
具体来说，这个函数采用一个UTF-8编码二进制数并返回其整数代码点列表。它类似于codepoints/1除了后者以字符串的形式返回一个代码点列表。
如果您需要处理字节，请查看:binary模块...
实例
iex> String.to_charlist("æß")
'æß'
to_existing_atom(string)
to_existing_atom(String.t) :: atom
将字符串转换为现有原子。
最大原子大小为255个字符。在OTP 20之前，只允许使用延迟一个字符。
编译器插入。
实例
iex> _ = :my_atom
iex> String.to_existing_atom("my_atom")
:my_atom
iex> String.to_existing_atom("this_atom_will_never_exist")
** (ArgumentError) argument error
to_float(string)
to_float(String.t) :: float
返回文本表示为string...
string必须是浮点数的字符串表示形式，包括小数点。为了将没有小数点的字符串解析为浮点数，那么Float.parse/1应该用。否则，ArgumentError将被提升。
编译器插入。
实例
iex> String.to_float("2.2017764e+0")
2.2017764
iex> String.to_float("3.0")
3.0
String.to_float("3")
#=> ** (ArgumentError) argument error
to_integer(string)
to_integer(String.t) :: integer
返回文本表示为string...
编译器插入。
实例
iex> String.to_integer("123")
123
to_integer(string, base)
to_integer(String.t, 2..36) :: integer
返回其文本表示string以基数表示的整数base。
编译器插入。
实例
iex> String.to_integer("3FF", 16)
1023
trim(string)
trim(t) :: t
返回一个字符串，其中删除了所有引导和尾随Unicode空白空间。
实例
iex> String.trim("\n abc\n ")
"abc"
trim(string, to_trim)
trim(t, t) :: t
返回一个字符串，在该字符串中，所有的前导和尾随to_trim他已经被移走了。
实例
iex> String.trim("a abc a", "a")
" abc "
trim_leading(string)
trim_leading(t) :: t
返回一个字符串，在该字符串中，已删除了所有领先的Unicode空白空间。
实例
iex> String.trim_leading("\n abc ")
"abc "
trim_leading(string, to_trim)
trim_leading(t, t) :: t
返回一个字符串，其中所有前导to_trim他已经被移走了。
实例
iex> String.trim_leading("__ abc _", "_")
" abc _"
iex> String.trim_leading("1 abc", "11")
"1 abc"
trim_trailing(string)
trim_trailing(t) :: t
返回一个字符串，在该字符串中，已删除所有拖尾Unicode空白空间。
实例
iex> String.trim_trailing(" abc\n ")
" abc"
trim_trailing(string, to_trim)
trim_trailing(t, t) :: t
返回所有尾部to_trim已被删除的字符串。
实例
iex> String.trim_trailing("_ abc __", "_")
"_ abc "
iex> String.trim_trailing("abc 1", "11")
"abc 1"
upcase(binary)
upcase(t) :: t
将给定字符串中的所有字符转换为大写。
实例
iex> String.upcase("abcd")
"ABCD"
iex> String.upcase("ab 123 xpto")
"AB 123 XPTO"
iex> String.upcase("olá")
"OLÁ"
valid?(string)
valid?(t) :: boolean
检查是否string只包含有效字符。
实例
iex> String.valid?("a")
true
iex> String.valid?("ø")
true
iex> String.valid?(<<0xFFFF :: 16>>)
false
iex> String.valid?(<<0xEF, 0xB7, 0x90>>)
true
iex> String.valid?("asd" <> <<0xFFFF :: 16>>)
false
