AnyMath 文档

弦乐器

该 抽象字符串 type是Julia中所有字符串实现的超类型。 字符串是序列的编码https://unicode.org/[Unicode]代码点由 摘要: 类型。 Julia对字符串做了一些假设:

*字符串按固定大小的"代码单位"进行编码 **代码单位可以提取与 代码单元(s,i) **第一个代码单元有索引 1 **最后一个代码单元有索引 ncodeunits（s） **任何索引 i 这样， 1≤i≤ncodeunits(s) 在边界内 *字符串索引是根据这些代码单元完成的: **字符由 s[i] 具有有效的字符串索引 i **每个 摘要: 在一个字符串是由一个或多个代码单元编码 **只有一个的第一个代码单元的索引 摘要: 是有效的索引 **一个的编码 摘要: 独立于它的前面或后面 **字符串编码是https://en.wikipedia.org/wiki/Self-synchronizing_code[self-synchronizing]--即 isvalid(s,i) 是O(1)

从字符串中提取代码单元，字符或子字符串的某些字符串函数如果传递它们越界或无效的字符串索引，则会出错。 这包括 代码单元(s,i) 和 s[i]. 执行字符串索引算术的函数采用更宽松的索引方法，并在越界或越界时为您提供最接近的有效字符串索引，表现得好像有无限多的字符填充字符串的 通常这些假想的填充字符具有代码单元长度 1 但是字符串类型可以选择不同的"假想"字符大小，这对于它们的实现是有意义的（例如，子字符串可以将索引算术传递给它们提供视图的底层字符串）。 宽松的索引函数包括那些用于索引运算的函数: 这个问题, 下一篇 和 上一页. 此模型允许索引算术将越界索引用作中间值，只要从不使用它们来检索字符，这通常有助于避免需要围绕边缘情况编码。

请参阅 [医代码], n.ncodeunits, 这个问题, 下一篇, 上一页.

该 摘要: type是Julia中所有字符实现的超类型。 字符表示Unicode代码点，可以通过 [医代码点]函数以便获得码点的数值，或者由相同的整数构造。 这些数值决定了如何将字符与 < 和 == 例如。 新的 T<:抽象 类型应该定义一个 代码点(::T) 方法和a T(::UInt32) 构造函数，至少。

一个给定的 摘要: 子类型可能只能表示Unicode的一个子集，在这种情况下，从不支持的转换 UInt32 值可能会抛出错误。 相反，内置 查尔type表示Unicode的_superset_（为了无损地编码无效的字节流），在这种情况下转换非Unicode值_to_ UInt32 抛出一个错误。 该 [医价值]函数可用于检查哪些代码点在给定的代码中是可表示的 摘要: 类型。

在内部，一个 摘要: 类型可以使用多种编码。 通过转换 代码点(char) 不会显示此编码，因为它始终返回字符的Unicode值。 印刷(io,c) 任何一个 c::摘要 产生由 伊俄 （所有内置的UTF-8 伊俄 类型），通过转换为 查尔 如有必要。

写(io,c)，相比之下，可能会发出一个编码取决于 类型(c)，而 阅读(io,typeof(c)) 应该读取相同的编码 写. 新的 摘要: 类型必须提供它们自己的 写 和 讀！.

Char(c::Union{Number,AbstractChar})

查尔 是一个32位 摘要:类型是Julia中字符的默认表示形式。 查尔 用于字符文字的类型是 'x' 它也是 字符串.

为了无损地表示存储在一个任意字节流 字符串，一个 查尔 值可以存储不能转换为Unicode代码点的信息—​转换这样的 查尔 到 UInt32 会抛出错误。 该 isvalid(c::Char)函数可用于查询是否 c 表示有效的Unicode字符。

codepoint(c::AbstractChar) -> Integer

返回字符对应的Unicode代码点（无符号整数 c （或抛出异常，如果 c 不代表有效字符）。 为 查尔，这是一个 UInt32 值，但是 摘要: 仅表示Unicode子集的类型可能会返回不同大小的整数（例如 UInt8).

length(s::AbstractString) -> Int
length(s::AbstractString, i::Integer, j::Integer) -> Int

返回字符串中的字符数 s 从指数 i 通过 j.

这计算为代码单元索引的数量 i 到 j 它们是有效的字符索引。 只有一个字符串参数，它计算整个字符串中的字符数。 与 i 和 j 参数它计算之间的索引数 i 和 j 包含字符串中的有效索引 s. 除了界内值, i 可能取越界值 ncodeunits（s）+1 和 j 可能取越界值 0.

注意此操作的时间复杂度总体上是线性的。 也就是说，它将花费与字符串中的字节数或字符数成比例的时间，因为它正在计算值。 这与数组的方法相反，数组是一个恒定时间操作。

请参阅 [医价值], n.ncodeunits, lastindex,lastindex, 这个问题, 下一篇, 上一页.

*例子*

julia> length("jμΛIα")
5
sizeof(str::AbstractString)

字符串的大小（以字节为单位） 斯特拉. 等于代码单元的数量 斯特拉 乘以一个代码单元的大小（以字节为单位） 斯特拉.

*例子*

julia> sizeof("")
0

julia> sizeof("∀")
3
&ast;(s::Union{AbstractString, AbstractChar}, t::Union{AbstractString, AbstractChar}...) -> AbstractString

连接字符串和/或字符，产生 字符串或 注释字符串(视情况而定)。 这相当于调用 字符串或 注释字符串对参数起作用。 内置字符串类型的串联总是产生一个类型的值 字符串 但其他字符串类型可能会根据需要选择返回不同类型的字符串。

*例子*

julia> "Hello " &ast; "world"
"Hello world"

julia> 'j' &ast; "ulia"
"julia"
^(s::Union{AbstractString,AbstractChar}, n::Integer) -> AbstractString

重复字符串或字符 n 时代。 这也可以写成 重复(s,n).

请参阅 重复一遍.

*例子*

julia> "Test "^3
"Test Test Test "
string(xs...)

使用 印刷业功能。

字符串 通常不应直接定义。 而是定义一个方法 打印(io::IO,x::MyType). 如果 字符串(x) 对于某种类型需要高效，那么添加一个方法可能是有意义的 字符串 并定义 print(io::IO,x::MyType)=print(io,string(x)) 以确保功能一致。

请参阅: 字符串, 代表, 冲刺, 展览.

*例子*

julia> string("a", 1, true)
"a1true"
string(n::Integer; base::Integer = 10, pad::Integer = 1)

转换整数 n 到给定的字符串 基地，可选地指定要填充的位数。

请参阅 数字, 比特串, n.计数,计数.

*例子*

julia> string(5, base = 13, pad = 4)
"0005"

julia> string(-13, base = 5, pad = 4)
"-0023"
repeat(s::AbstractString, r::Integer)

重复一个字符串 r 时代。 这可以写成 s^r.

请参阅 .

*例子*

julia> repeat("ha", 3)
"hahaha"
repeat(c::AbstractChar, r::Integer) -> String

重复一个字符 r 时代。 这可以等价地通过调用 c^r.

*例子*

julia> repeat('A', 3)
"AAA"
repr(x; context=nothing)

使用2参数创建任何值的字符串表示形式 显示(io,x) 函数，其目的是在可能的情况下生成一个可解析Julia代码的字符串。 即 eval（元。解析(repr(x)))==x 应该成立。 您不应该将方法添加到 代表;定义一个 展览方法代替。

可选关键字参数 上下文环境 可以设置为一个 :键=>值 对，一个元组 :键=>值 对，或一个 伊俄 或 IOContext对象，其属性用于传递到的I/O流 展览.

请注意 代表(x) 通常类似于 x 将进入朱莉娅。 请参阅 repr(MIME("text/plain"),x)而不是返回一个"漂亮印刷"的版本 x 更多地为人类消费而设计，相当于 x，使用3参数 显示(io,mime,x).

兼容性

Julia1.7将元组传递给关键字 上下文环境 需要Julia1.7或更高版本。

*例子*

julia> repr(1)
"1"

julia> repr(zeros(3))
"[0.0, 0.0, 0.0]"

julia> repr(big(1/3))
"0.333333333333333314829616256247390992939472198486328125"

julia> repr(big(1/3), context=:compact => true)
"0.333333"
String(s::AbstractString)

创建一个新的 字符串 从现有的 抽象字符串.

SubString(s::AbstractString, i::Integer, j::Integer=lastindex(s))
SubString(s::AbstractString, r::UnitRange{<:Integer})

像 getindex,getindex，但返回一个视图到父字符串 s 范围内 i：j 或 r 分别而不是制作副本。

该 @意见宏转换任何字符串切片 s[i:j] 成子字符串 子字符串(s,i,j) 在一个代码块中。

*例子*

julia> SubString("abc", 1, 2)
"ab"

julia> SubString("abc", 1:2)
"ab"

julia> SubString("abc", 2)
"bc"
LazyString <: AbstractString

字符串插值的惰性表示。 当需要在不需要或不需要执行实际插值和字符串构造的上下文中构造字符串时（例如在函数的错误路径中），这很有用。

这种类型的设计是为了在运行时构建便宜，试图将尽可能多的工作卸载到宏或更高版本的打印操作。

*例子*

julia> n = 5; str = LazyString("n is ", n)
"n is 5"

请参阅 @lazy_str.

兼容性

朱莉娅1.8 [医]懒骨头 需要Julia1.8或更高版本。

*扩展帮助*

*并发程序的安全属性*

懒惰字符串本身不会引入任何并发问题，即使它打印在多个Julia任务中。 但是，如果 印刷业 在没有同步的情况下调用捕获值上的方法可能会出现并发问题，打印惰性字符串可能会导致问题。 此外， 印刷业 捕获值上的方法可以被多次调用，尽管只会返回一个结果。

兼容性

朱莉娅1.9 [医]懒骨头 在Julia1.9及更高版本中，上述意义上是安全的。

 
lazy"str"

创建一个 [医懒骨头]使用常规字符串插值语法。 请注意，插值在LazyString构造时是_evaluated_，但_printing_被延迟到第一次访问字符串。

见 [医懒骨头]并发程序的安全属性文档。

*例子*

julia> n = 5; str = lazy"n is $n"
"n is 5"

julia> typeof(str)
LazyString
兼容性

朱莉娅1.8 懒惰的"str" 需要Julia1.8或更高版本。

 
transcode(T, src)

在Unicode编码之间转换字符串数据。 src公司 是一个 字符串 或一个 向量{UIntXX} UTF-XX代码单元，其中 XX 是8、16或32。 T 指示返回值的编码: 字符串 返回一个（UTF-8编码） 字符串 或 UIntXX的 返回 向量{UIntXX} UTF的-XX 数据。 （别名 Cwchar_t也可以用作整数类型，用于转换 wchar_t* 外部C库使用的字符串。)

该 转码/转码 只要输入数据可以在目标编码中合理表示，函数就会成功；对于UTF-XX编码之间的转换，即使对于无效的Unicode数据，它也总是成功。

目前只支持转换为UTF-8。

*例子*

julia> str = "αβγ"
"αβγ"

julia> transcode(UInt16, str)
3-element Vector{UInt16}:
 0x03b1
 0x03b2
 0x03b3

julia> transcode(String, transcode(UInt16, str))
"αβγ"
unsafe_string(p::Ptr{UInt8}, [length::Integer])

从编码为UTF-8的C风格（NUL终止）字符串的地址复制字符串。 （之后可以安全地释放指针。)如果 长度 指定（以字节为单位的数据长度），字符串不必为NUL终止。

此函数被标记为"不安全"，因为如果 p 不是所请求长度的数据的有效内存地址。

ncodeunits(s::AbstractString) -> Int

返回字符串中的代码单元数。 在访问此字符串的范围内的索引必须满足 1≤i≤ncodeunits(s). 并非所有这些索引都是有效的-它们可能不是字符的开头，但它们会在调用时返回代码单元值 代码单元(s,i).

*例子*

julia> ncodeunits("The Julia Language")
18

julia> ncodeunits("∫eˣ")
6

julia> ncodeunits('∫'), ncodeunits('e'), ncodeunits('ˣ')
(3, 1, 2)

请参阅 [医代码], 支票/支票, 大小；大小, 长度, lastindex,lastindex.

codeunit(s::AbstractString, i::Integer) -> Union{UInt8, UInt16, UInt32}

返回字符串中的代码单位值 s 在索引 i. 请注意

codeunit(s, i) :: codeunit(s)

即返回的值 代码单元(s,i) 是由返回的类型 代码单元.

*例子*

julia> a = codeunit("Hello", 2)
0x65

julia> typeof(a)
UInt8

请参阅 n.ncodeunits, 支票/支票.

codeunit(s::AbstractString) -> Type{<:Union{UInt8, UInt16, UInt32}}

返回给定字符串对象的代码单元类型。 对于ASCII，Latin-1或UTF-8编码的字符串，这将是 UInt8;对于UCS-2和UTF-16这将是 UInt16;对于UTF-32这将是 UInt32. 代码单元类型不必限于这三种类型，但很难想到不使用这些单元之一的广泛使用的字符串编码。 代码单元 是一样的 类型(codeunit(s,1)) 何时 s 为非空字符串。

请参阅 n.ncodeunits.

codeunits(s::AbstractString)

获取包含字符串的代码单位的矢量状对象。 返回a 代码单位 默认情况下包装，但 代码单位 如果需要，可以选择为新的字符串类型定义。

*例子*

julia> codeunits("Juλia")
6-element Base.CodeUnits{UInt8, String}:
 0x4a
 0x75
 0xce
 0xbb
 0x69
 0x61
ascii(s::AbstractString)

将字符串转换为 字符串 键入并检查它只包含ASCII数据，否则抛出一个 [医]争论者 指示第一个非ASCII字节的位置。

请参阅 isascii谓词以过滤或替换非ASCII字符。

*例子*

julia> ascii("abcdeγfgh")
ERROR: ArgumentError: invalid ASCII at index 6 in "abcdeγfgh"
Stacktrace:
[...]

julia> ascii("abcdefgh")
"abcdefgh"
Regex(pattern[, flags]) <: AbstractPattern

表示正则表达式的类型。 正则表达式 对象可用于将字符串与 比赛.

正则表达式 对象可以使用 @r_str字符串宏。 该 正则表达式(模式[,标志]) 构造函数通常用于 模式 字符串需要进行插值。 有关标志的详细信息，请参阅字符串宏的文档。

注释转义插值变量使用 \Q 和 \E （例如 正则表达式("\\Q$x\\E"))

 
@r_str -> Regex

构造一个正则表达式，如 r"^[a-z]&ast;$"，没有插值和unescaping（引号除外 " 其中仍然必须逃脱）。 正则表达式还接受一个或多个标志，列在结束引号后，以改变其行为:

* i 启用不区分大小写的匹配 * m 对待 ^ 和 $ 标记为匹配单个行的开始和结束，而不是整个字符串。 * s 允许 . 修饰符以匹配换行符。 * x 启用"自由间距模式"：正则表达式标记之间的空格被忽略，除非用 \，而 # 在正则表达式中被视为开始一个注释（它被忽略到行结尾）。 * a 启用ASCII模式（禁用 UTF-8 和 UCP 模式）。 默认情况下 \B, \b, \D, \d, \S的, \s的, \W, \w 等。 基于Unicode字符属性进行匹配。 使用此选项，这些序列只匹配ASCII字符。 这包括 \u 此外，它将直接将指定的字符值作为单个字节发出，而不是尝试将其编码为UTF-8。 重要的是，此选项允许匹配无效的UTF-8字符串，方法是将匹配器和目标视为简单字节（就好像它们是ISO/IEC8859-1/Latin-1字节）而不是字符编码。 在这种情况下，此选项通常与 s. 通过使用(_UCP)或(_UTF)启动模式，可以进一步细化此选项。

见 正则表达式如果需要插值。

*例子*

julia> match(r"a+.&ast;b+.&ast;?d$"ism, "Goodbye,\nOh, angry,\nBad world\n")
RegexMatch("angry,\nBad world")

此正则表达式启用了前三个标志。

SubstitutionString(substr) <: AbstractString

存储给定的字符串 子产 作为一个 替换字符串，以用于正则表达式替换。 最常见的构造使用 @s_str宏。

*例子*

julia> SubstitutionString("Hello \\g<name>, it's \\1")
s"Hello \g<name>, it's \1"

julia> subst = s"Hello \g<name>, it's \1"
s"Hello \g<name>, it's \1"

julia> typeof(subst)
SubstitutionString{String}
@s_str -> SubstitutionString

构造一个替换字符串，用于正则表达式替换。 在字符串中，表单的序列 \N 引用正则表达式中的第N个捕获组，并 \g<组名> 指具有名称的已命名捕获组 组名.

*例子*

julia> msg = "#Hello# from Julia";

julia> replace(msg, r"#(.+)# from (?<from>\w+)" => s"FROM: \g<from>; MESSAGE: \1")
"FROM: Julia; MESSAGE: Hello"
@raw_str -> String

创建一个没有插值和非缩放的原始字符串。 例外情况是引号仍然必须转义。 反斜杠转义引号和其他反斜杠，但仅当反斜杠序列位于引号字符之前时。 因此，2n个反斜杠后跟一个引号编码n个反斜杠和文字的结尾，而2n+1个反斜杠后跟一个引号编码n个反斜杠后跟一个引号字符。

*例子*

julia> println(raw"\ $x")
\ $x

julia> println(raw"\"")
"

julia>println（raw"\\\""）
\"

julia>println（raw"\\x\\\""）
\\x\"
@b_str

创建一个不可变的字节（UInt8）使用字符串语法的向量。

*例子*

julia> v = b"12\x01\x02"
4-element Base.CodeUnits{UInt8, String}:
 0x31
 0x32
 0x01
 0x02

julia> v[2]
0x32
@html_str -> Docs.HTML

创建一个 HTML格式 来自字面字符串的对象。

*例子*

julia> html"Julia"
HTML{String}("Julia")
@text_str -> Docs.Text

创建一个 文本 来自字面字符串的对象。

*例子*

julia> text"Julia"
Julia
isvalid(value) -> Bool

回来吧 真的 如果给定的值对其类型有效，则当前可以是 摘要: 或 字符串 或 子字符串{String}.

*例子*

julia> isvalid(Char(0xd800))
false

julia> isvalid(SubString(String(UInt8[0xfe,0x80,0x80,0x80,0x80,0x80]),1,2))
false

朱莉娅>isvalid（Char（0xd799））
真的
isvalid(T, value) -> Bool

回来吧 真的 如果给定的值对该类型有效。 目前的类型可以是 摘要: 或 字符串. 价值 摘要: 可以是类型 摘要: 或 UInt32. 价值 字符串 可以是那种类型的, 子字符串{String}, 向量{UInt8}，或其连续子阵列。

*例子*

julia> isvalid(Char, 0xd800)
false

julia> isvalid(String, SubString("thisisvalid",1,5))
true

julia> isvalid(Char, 0xd799)
true
兼容性

Julia1.6在Julia1.6中添加了对子阵列值的支持。

 
isvalid(s::AbstractString, i::Integer) -> Bool

谓词，指示给定的索引是否是一个字符的编码的开始 s 或者不是。 如果 isvalid(s,i) 那么是真的吗？ s[i] 将返回其编码从该索引开始的字符，如果为false，则 s[i] 将引发无效索引错误或边界错误，具体取决于 i 在边界内。 为了 isvalid(s,i) 作为一个O(1)函数，编码 s 必须是https://en.wikipedia.org/wiki/Self-synchronizing_code[自同步].这是Julia泛型字符串支持的一个基本假设。

请参阅 getindex,getindex, 迭代, 这个问题, 下一篇, 上一页, 长度.

*例子*

julia> str = "αβγdef";

julia> isvalid(str, 1)
true

julia> str[1]
'α': Unicode U+03B1 (category Ll: Letter, lowercase)

julia> isvalid(str, 2)
false

julia> str[2]
ERROR: StringIndexError: invalid index [2], valid nearby indices [1]=>'α', [3]=>'β'
Stacktrace:
[...]
match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])

搜索正则表达式的第一个匹配项 r 在 s 并返回一个 正则表达式匹配包含匹配的对象，如果匹配失败则不包含。 可选项 idx 参数指定开始搜索的索引。 匹配的子字符串可以通过访问来检索 m.比赛，捕获的序列可以通过访问检索 m.捕获. 由此产生的 正则表达式匹配对象可用于构造其他集合：例如 元组(m), 名称(m).

兼容性

Julia1.11构造NamedTuples和Dicts需要Julia1.11

*例子*

julia> rx = r"a(.)a"
r"a(.)a"

julia> m = match(rx, "cabac")
RegexMatch("aba", 1="b")

julia>m.捕获
1元素向量{Union{Nothing, SubString{String}}}:
 "b"

朱莉娅>m.匹配
"阿坝"

julia>match(rx,"cabac",3)===无
真的
eachmatch(r::Regex, s::AbstractString; overlap::Bool=false)

搜索正则表达式的所有匹配项 r 在 s 并返回匹配项的迭代器。 如果 重叠 是 真的，允许匹配序列在原始字符串中重叠索引，否则它们必须来自不同的字符范围。

*例子*

julia> rx = r"a.a"
r"a.a"

julia> m = eachmatch(rx, "a1a2a3a")
Base.RegexMatchIterator{String}(r"a.a", "a1a2a3a", false)

julia> collect(m)
2-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a3a")

julia> collect(eachmatch(rx, "a1a2a3a", overlap = true))
3-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a2a")
 RegexMatch("a3a")
RegexMatch <: AbstractMatch

表示与 正则表达式在字符串中找到。 通常由 比赛功能。

该 比赛 字段存储整个匹配字符串的子字符串。 该 捕获 字段存储每个捕获组的子字符串，按编号索引。 要按捕获组名称编制索引，应改为对整个match对象编制索引，如示例中所示。 匹配开始的位置存储在 偏移量 场。 该 偏移量 字段存储每个捕获组的开始位置，0表示未捕获的组。

此类型可以用作捕获组的迭代器 正则表达式，产生每个组中捕获的子串。 因此，匹配的捕获可以被破坏。 如果没有捕获一组, 什么都没有 将产生而不是子字符串。

接受a的方法 正则表达式匹配 对象被定义为 迭代, 长度, eltype,eltype, 钥匙, 哈斯基，和 getindex,getindex，其中键是捕获组的名称或编号。 见 钥匙了解更多信息。

元组(m), 名称(m)，而 Dict(m) 可用于构造更灵活的集合类型 正则表达式匹配 物体。

兼容性

Julia1.11从RegexMatches构造NamedTuples和Dicts需要Julia1.11

*例子*

julia> m = match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30 in the morning")
RegexMatch("11:30", hour="11", minute="30", 3=nothing)

julia> m.match
"11:30"

julia> m.captures
3-element Vector{Union{Nothing, SubString{String}}}:
 "11"
 "30"
 nothing


julia> m["minute"]
"30"

julia> hr, min, ampm = m; # destructure capture groups by iteration

julia> hr
"11"

julia> Dict(m)
Dict{Any, Union{Nothing, SubString{String}}} with 3 entries:
  "hour"   => "11"
  3        => nothing
  "minute" => "30"
keys(m::RegexMatch) -> Vector

返回基础正则表达式的所有捕获组的键向量。 即使捕获组无法匹配，也会包含密钥。 那就是, idx 将在返回值，即使 m[idx]==无.

未命名的捕获组将具有与其索引相对应的整数键。 命名的捕获组将具有字符串键。

兼容性

Julia1.7在Julia1.7中添加了此方法

*例子*

julia> keys(match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30"))
3-element Vector{Any}:
  "hour"
  "minute"
 3
isless(a::AbstractString, b::AbstractString) -> Bool

测试是否字符串 a 在字符串之前 b 按字母顺序（从技术上讲，按Unicode代码点的字典顺序）。

*例子*

julia> isless("a", "b")
true

julia> isless("β", "α")
false

茱莉亚>isless("a","a")
错误
==(a::AbstractString, b::AbstractString) -> Bool

测试两个字符串是否逐字符相等（从技术上讲，Unicode代码点逐代码点）。 任何一个字符串都应该是 注释字符串字符串属性也必须匹配。

*例子*

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false
cmp(a::AbstractString, b::AbstractString) -> Int

比较两个字符串。 回来吧 0 如果两个字符串具有相同的长度，并且每个索引处的字符在两个字符串中都是相同的。 回来吧 -1 如果 a 是一个前缀 b，或者如果 a 来之前 b 按字母顺序排列。 回来吧 1 如果 b 是一个前缀 a，或者如果 b 来之前 a 按字母顺序（从技术上讲，按Unicode代码点的字典顺序）。

*例子*

julia> cmp("abc", "abc")
0

julia>cmp("ab","abc")
-1

julia>cmp("abc","ab")
1

julia>cmp("ab","ac")
-1

julia>cmp("ac","ab")
1

julia>cmp（"α"，"a"）
1

朱莉娅>cmp（"b"，"β"）
-1
lpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ') -> String

Stringify拢潞 s 并将产生的字符串垫在左边 p 使之 n 字符(在 文本宽度）长。 如果 s 已经是 n 字符长，返回相等的字符串。 默认情况下用空格填充。

*例子*

julia> lpad("March", 10)
"     March"
兼容性

Julia1.7在Julia1.7中，这个函数被改为使用 文本宽度 而不是原始字符（codepoint）计数。

 
rpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ') -> String

Stringify拢潞 s 并在右侧填充产生的字符串 p 使之 n 字符(在 文本宽度）长。 如果 s 已经是 n 字符长，返回相等的字符串。 默认情况下用空格填充。

*例子*

julia> rpad("March", 20)
"March               "
兼容性

Julia1.7在Julia1.7中，这个函数被改为使用 文本宽度 而不是原始字符（codepoint）计数。

 
ltruncate(str::AbstractString, maxwidth::Integer, replacement::Union{AbstractString,AbstractChar} = '…')

截断,截断 斯特拉 到最多 最大宽度 列（按估计 文本宽度)，将第一个字符替换为 更换 如有必要。 默认替换字符串为"。..".

*例子*

julia> s = ltruncate("🍕🍕 I love 🍕", 10)
"…I love 🍕"

julia> textwidth(s)
10

julia> ltruncate("foo", 3)
"foo"
兼容性

Julia1.12这个函数是在Julia1.12中添加的。

请参阅 [医隆颅]和 ctruncate,ctruncate.

rtruncate(str::AbstractString, maxwidth::Integer, replacement::Union{AbstractString,AbstractChar} = '…')

截断,截断 斯特拉 到最多 最大宽度 列（按估计 文本宽度)，将最后一个字符替换为 更换 如有必要。 默认替换字符串为"。..".

*例子*

julia> s = rtruncate("🍕🍕 I love 🍕", 10)
"🍕🍕 I lo…"

julia> textwidth(s)
10

julia> rtruncate("foo", 3)
"foo"
兼容性

Julia1.12这个函数是在Julia1.12中添加的。

请参阅 [医扁桃体]和 ctruncate,ctruncate.

ctruncate(str::AbstractString, maxwidth::Integer, replacement::Union{AbstractString,AbstractChar} = '…'; prefer_left::Bool = true)

截断,截断 斯特拉 到最多 最大宽度 列（按估计 文本宽度)，将中间字符替换为 更换 如有必要。 默认替换字符串为"。..". 默认情况下，截断首选保留左边的字符，但这可以通过设置来更改 首选_left 到 错误.

*例子*

julia> s = ctruncate("🍕🍕 I love 🍕", 10)
"🍕🍕 …e 🍕"

julia> textwidth(s)
10

julia> ctruncate("foo", 3)
"foo"
兼容性

Julia1.12这个函数是在Julia1.12中添加的。

请参阅 [医扁桃体]和 [医隆颅].

findfirst(pattern::AbstractString, string::AbstractString)
findfirst(pattern::AbstractPattern, string::String)

找到第一次出现的 模式 在 字符串. 相当于 findnext(模式,字符串,firstindex(s)).

*例子*

julia> findfirst("z", "Hello to the world") # returns nothing, but not printed in the REPL

julia> findfirst("Julia", "JuliaLang")
1:5
findnext(pattern::AbstractString, string::AbstractString, start::Integer)
findnext(pattern::AbstractPattern, string::String, start::Integer)

查找下一个出现的 模式 在 字符串 从职位开始 开始. 模式 可以是字符串，也可以是正则表达式，在这种情况下 字符串 必须是类型 字符串.

返回值是找到匹配序列的索引范围，例如 s[findnext(x,s,i)]==x: findnext("子字符串",字符串,i) == 开始：停止 这样， 字符串[开始：停止]=="子字符串" 和 i<=开始，或 什么都没有 如果不匹配。

*例子*

julia> findnext("z", "Hello to the world", 1) === nothing
true

julia> findnext("o", "Hello to the world", 6)
8:8

julia> findnext("Lang", "JuliaLang", 2)
6:9
findnext(ch::AbstractChar, string::AbstractString, start::Integer)

查找字符的下一个匹配项 ch 在 字符串 从职位开始 开始.

兼容性

Julia1.3此方法至少需要Julia1.3。

*例子*

julia> findnext('z', "Hello to the world", 1) === nothing
true

julia> findnext('o', "Hello to the world", 6)
8
findlast(pattern::AbstractString, string::AbstractString)

找到最后出现的 模式 在 字符串. 相当于 findprev(pattern,string,lastindex(string)).

*例子*

julia> findlast("o", "Hello to the world")
15:15

julia> findfirst("Julia", "JuliaLang")
1:5
findlast(ch::AbstractChar, string::AbstractString)

查找字符的最后一次出现 ch 在 字符串.

兼容性

Julia1.3此方法至少需要Julia1.3。

*例子*

julia> findlast('p', "happy")
4

julia> findlast('z', "happy") === nothing
true
findprev(pattern::AbstractString, string::AbstractString, start::Integer)

查找之前出现的 模式 在 字符串 从职位开始 开始.

返回值是找到匹配序列的索引范围，例如 s[findprev(x,s,i)]==x: findprev（"子字符串"，字符串，i） == 开始：停止 这样， 字符串[开始：停止]=="子字符串" 和 停止<=i，或 什么都没有 如果不匹配。

*例子*

julia> findprev("z", "Hello to the world", 18) === nothing
true

julia> findprev("o", "Hello to the world", 18)
15:15

julia> findprev("Julia", "JuliaLang", 6)
1:5
occursin(haystack)

创建一个函数，检查其参数是否出现在 干草堆，即等价于 针->发生（针，干草堆）.

返回的函数是类型 基地。修正2{typeof(occursin)}.

兼容性

Julia1.6此方法需要Julia1.6或更高版本。

*例子*

julia> search_f = occursin("JuliaLang is a programming language");

julia> search_f("JuliaLang")
true

julia> search_f("Python")
false
occursin(needle::Union{AbstractString,AbstractPattern,AbstractChar}, haystack::AbstractString)

确定第一个参数是否是第二个参数的子字符串。 如果 针头,针头 是正则表达式，检查是否 干草堆 包含匹配项。

*例子*

julia> occursin("Julia", "JuliaLang is pretty cool!")
true

julia> occursin('a', "JuliaLang is pretty cool!")
true

julia> occursin(r"a.a", "aba")
true

julia>occissin(r"a.a","abba")
错误

请参阅 包含.

reverse(s::AbstractString) -> AbstractString

反转字符串。 从技术上讲，此函数反转字符串中的代码点，其主要实用程序用于反转顺序字符串处理，特别是对于反转正则表达式搜索。 请参阅 反转,反转将指数转换为 s 至指数 反向(s) 反之亦然，以及 图形,图形 从模块 统一码 操作用户可见的"字符"（图形）而不是代码点。 请参阅 迭代器。反向用于逆序迭代而不进行复制。 自定义字符串类型必须实现 反向 函数本身，通常应该返回具有相同类型和编码的字符串。 如果它们返回具有不同编码的字符串，则还必须重写 反转,反转 要满足该字符串类型 s[反转(s,i)]==反转(s)[i].

*例子*

julia> reverse("JuliaLang")
"gnaLailuJ"

注意下面的示例可能在不同的系统上呈现不同。 这些评论表明了它们应该如何呈现

组合字符可能会导致令人惊讶的结果:

julia> reverse("ax̂e") # hat is above x in the input, above e in the output
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # reverses graphemes; hat is above x in both in- and output
"ex̂a"
replace([io::IO], s::AbstractString, pat=>r, [pat2=>r2, ...]; [count::Integer])

搜索给定的模式 帕特 在 s，并将每个出现替换为 r. 如果 计数 被提供，最多更换 计数 发生。 帕特 可以是单个字符、向量或一组字符、字符串或正则表达式。 如果 r 是一个函数，每次出现替换为 r(s) 哪里 s 是匹配的子字符串（当 帕特 是一个 [医]抽象模式 或 抽象字符串）或字符（当 帕特 是一个 摘要: 或集合 摘要:). 如果 帕特 是正则表达式和 r 是一个 替换字符串，然后在捕获组引用 r 被替换为相应的匹配文本。 删除 帕特 从 字符串，设置 r 到空 字符串 ("").

返回值是替换后的新字符串。 如果 io::IO 提供参数，转换后的字符串被写入 伊俄 （返回 伊俄). （例如，这可以与一个 IOBuffer的重新使用预先分配的缓冲区阵列。)

可以指定多个模式，并且它们将同时从左到右应用，因此只有一个模式将应用于任何字符，并且模式将只应用于输入文本，而不是替换。

兼容性

Julia1.7支持多种模式需要版本1.7。
兼容性

朱莉娅1.10 io::IO 参数需要版本1.10。

*例子*

julia> replace("Python is a programming language.", "Python" => "Julia")
"Julia is a programming language."

julia> replace("The quick foxes run quickly.", "quick" => "slow", count=1)
"The slow foxes run quickly."

julia> replace("The quick foxes run quickly.", "quick" => "", count=1)
"The  foxes run quickly."

julia> replace("The quick foxes run quickly.", r"fox(es)?" => s"bus\1")
"The quick buses run quickly."

julia> replace("abcabc", "a" => "b", "b" => "c", r".+" => "a")
"bca"
eachsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

分裂,分裂 斯特拉 出现分隔符时 dlm 并返回子字符串的迭代器。 dlm 可以是任何允许的格式 findnext的第一个参数（即作为字符串，正则表达式或函数），或作为单个字符或字符集合。

如果 dlm 被省略，它默认为 is空间.

可选的关键字参数是:

* 限额：结果的最大尺寸。 限制=0 表示没有最大值（默认值） * 守时,守时：结果中是否应保留空字段。 默认值为 错误 没有一个 dlm 论点, 真的 用一个 dlm 争论。

请参阅 分裂,分裂.

兼容性

朱莉娅1.8 每个分拆 函数至少需要Julia1.8。

*例子*

julia> a = "Ma.rch"
"Ma.rch"

julia> b = eachsplit(a, ".")
Base.SplitIterator{String, String}("Ma.rch", ".", 0, true)

julia> collect(b)
2-element Vector{SubString{String}}:
 "Ma"
 "rch"
eachrsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachrsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

返回迭代器 子字符串s的 斯特拉，在分隔符上分裂时产生 dlm，并以相反的顺序（从右到左）屈服。 dlm 可以是任何允许的格式 芬普雷夫的第一个参数（即字符串，单个字符或函数），或字符的集合。

如果 dlm 被省略，它默认为 is空间，和 守时,守时 默认为 错误.

可选的关键字参数是:

*如果 限额>0，迭代器最多会分裂 限制-1 返回字符串未拆分的其余部分之前的时间。 限制<1 意味着分裂没有上限（默认）。 * 守时,守时：迭代时是否应返回空字段默认为 错误 没有一个 dlm 论点, 真的 用一个 dlm 争论。

请注意，与 分裂,分裂, [医分裂]和 每个分拆，该函数迭代子字符串从右到左，因为它们在输入中出现。

请参阅 每个分拆, [医分裂].

兼容性

Julia1.11此功能需要Julia1.11或更高版本。

*例子*

julia> a = "Ma.r.ch";

julia> collect(eachrsplit(a, ".")) == ["ch", "r", "Ma"]
true

julia> collect(eachrsplit(a, "."; limit=2)) == ["ch", "Ma.r"]
true
split(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
split(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

分裂,分裂 斯特拉 在分隔符出现的子字符串数组中 dlm. dlm 可以是任何允许的格式 findnext的第一个参数（即作为字符串，正则表达式或函数），或作为单个字符或字符集合。

如果 dlm 被省略，它默认为 is空间.

可选的关键字参数是:

* 限额：结果的最大尺寸。 限制=0 表示没有最大值（默认值） * 守时,守时：结果中是否应保留空字段。 默认值为 错误 没有一个 dlm 论点, 真的 用一个 dlm 争论。

请参阅 [医分裂], 每个分拆.

*例子*

julia> a = "Ma.rch"
"Ma.rch"

julia> split(a, ".")
2-element Vector{SubString{String}}:
 "Ma"
 "rch"
rsplit(s::AbstractString; limit::Integer=0, keepempty::Bool=false)
rsplit(s::AbstractString, chars; limit::Integer=0, keepempty::Bool=true)

类似于 分裂,分裂，而是从字符串的末尾开始。

*例子*

julia> a = "M.a.r.c.h"
"M.a.r.c.h"

julia> rsplit(a, ".")
5-element Vector{SubString{String}}:
 "M"
 "a"
 "r"
 "c"
 "h"

julia> rsplit(a, "."; limit=1)
1-element Vector{SubString{String}}:
 "M.a.r.c.h"

julia> rsplit(a, "."; limit=2)
2-element Vector{SubString{String}}:
 "M.a.r.c"
 "h"
strip([pred=isspace,] str::AbstractString) -> SubString
strip(str::AbstractString, chars) -> SubString

删除前导和尾随字符 斯特拉，或由 字符 或那些为其功能 预审 申报表 真的.

默认行为是删除前导和尾随空格和分隔符：请参阅 is空间以获得精确的细节。

可选项 字符 参数指定要删除的字符：它可以是单个字符、向量或一组字符。

请参阅 lstrip和 rstrip.

兼容性

Julia1.2接受谓词函数的方法需要Julia1.2或更高版本。

*例子*

julia> strip("{3, 5}\n", ['{', '}', '\n'])
"3, 5"
lstrip([pred=isspace,] str::AbstractString) -> SubString
lstrip(str::AbstractString, chars) -> SubString

删除前导字符 斯特拉，或由 字符 或那些为其功能 预审 申报表 真的.

默认行为是删除前导空格和分隔符：请参阅 is空间以获得精确的细节。

可选项 字符 参数指定要删除哪些字符：它可以是单个字符，也可以是一个向量或一组字符。

请参阅 条带和 rstrip.

*例子*

julia> a = lpad("March", 20)
"               March"

julia> lstrip(a)
"March"
rstrip([pred=isspace,] str::AbstractString) -> SubString
rstrip(str::AbstractString, chars) -> SubString

删除尾随字符 斯特拉，或由 字符 或那些为其功能 预审 申报表 真的.

默认行为是删除尾随空格和分隔符：请参阅 is空间以获得精确的细节。

可选项 字符 参数指定要删除的字符：它可以是单个字符，也可以是一个向量或一组字符。

请参阅 条带和 lstrip.

*例子*

julia> a = rpad("March", 20)
"March               "

朱莉娅>rstrip（a）
"三月"
startswith(s::AbstractString, prefix::Regex)

回来吧 真的 如果 s 从正则表达式模式开始, 前缀.

注 开始，开始 不会将锚定编译为正则表达式，而是将锚定传递为 匹配-选择 到PCRE。 如果编译时间摊销, occinsin(r"^。..",s) 比…​…​ startswith(s,r"。..").

请参阅 发生,发生和 结束，结束.

兼容性

Julia1.2此方法至少需要Julia1.2。

*例子*

julia> startswith("JuliaLang", r"Julia|Romeo")
true
startswith(prefix)

创建一个函数，检查其参数是否以 前缀，即等价于 y->startswith(y,前缀).

返回的函数是类型 基地。修正2{typeof(startswith)}，从而可用于实施专门的方法。

兼容性

Julia1.5单一参数 startswith(前缀) 至少需要Julia1.5。

*例子*

julia> startswith("Julia")("JuliaLang")
true

julia> startswith("Julia")("Ends with Julia")
false
startswith(io::IO, prefix::Union{AbstractString,Base.Chars})

检查是否 伊俄 对象以前缀开头，前缀可以是字符串、字符或元组/向量/一组字符。 请参阅 偷看,偷看.

startswith(s::AbstractString, prefix::Union{AbstractString,Base.Chars})

回来吧 真的 如果 s 开始于 前缀，它可以是一个字符串，一个字符，或一个元组/向量/一组字符。 如果 前缀 是一个元组/向量/一组字符，测试是否第一个字符 s 属于那一套。

请参阅 结束，结束, 包含.

*例子*

julia> startswith("JuliaLang", "Julia")
true
endswith(s::AbstractString, suffix::Regex)

回来吧 真的 如果 s 以正则表达式模式结束, 后缀.

注 结束，结束 不会将锚定编译为正则表达式，而是将锚定传递为 匹配-选择 到PCRE。 如果编译时间摊销, occinsin(r"。..$",s) 比…​…​ endswith(s,r"。..").

请参阅 发生,发生和 开始，开始.

兼容性

Julia1.2此方法至少需要Julia1.2。

*例子*

julia> endswith("JuliaLang", r"Lang|Roberts")
true
endswith(suffix)

创建一个函数，检查其参数是否以 后缀，即等价于 y->endswith(y,后缀).

返回的函数是类型 基地。修正2{typeof(endswith)}，从而可用于实施专门的方法。

兼容性

Julia1.5单一参数 endswith（后缀） 至少需要Julia1.5。

*例子*

julia> endswith("Julia")("Ends with Julia")
true

julia> endswith("Julia")("JuliaLang")
false
endswith(s::AbstractString, suffix::Union{AbstractString,Base.Chars})

回来吧 真的 如果 s 以 后缀，它可以是一个字符串，一个字符，或一个元组/向量/一组字符。 如果 后缀 是一个元组/向量/一组字符，测试是否最后一个字符 s 属于那一套。

请参阅 开始，开始, 包含.

*例子*

julia> endswith("Sunday", "day")
true
contains(needle)

创建一个检查其参数是否包含的函数 针头,针头，即等价于 干草堆->包含（干草堆，针）.

返回的函数是类型 基地。修正2{typeof(contains)}，从而可用于实施专门的方法。

contains(haystack::AbstractString, needle)

回来吧 真的 如果 干草堆 包含 针头,针头. 这与 occissin（针，干草堆），但提供的一致性与 startswith（干草堆，针） 和 endswith（干草堆，针）.

请参阅 发生,发生, 在, 伊苏布塞特.

*例子*

julia> contains("JuliaLang is pretty cool!", "Julia")
true

julia> contains("JuliaLang is pretty cool!", 'a')
true

julia> contains("aba", r"a.a")
true

julia> contains("abba", r"a.a")
false
兼容性

朱莉娅1.5 包含 函数至少需要Julia1.5。

 
first(s::AbstractString, n::Integer)

获取由第一个字符串组成的字符串 n 的字符 s.

*例子*

julia> first("∀ϵ≠0: ϵ²>0", 0)
""

julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"
last(s::AbstractString, n::Integer)

获取由最后一个字符串组成的字符串 n 的字符 s.

*例子*

julia> last("∀ϵ≠0: ϵ²>0", 0)
""

julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"
uppercase(s::AbstractString)

回来吧 s 所有字符都转换为大写。

请参阅 小写, [医滴度酶], 上肢,上肢.

*例子*

julia> uppercase("Julia")
"JULIA"
uppercase(c::AbstractChar)

转换/转换 c 为大写。

请参阅 小写, [医滴度酶].

*例子*

julia> uppercase('a')
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)

julia> uppercase('ê')
'Ê': Unicode U+00CA (category Lu: Letter, uppercase)
lowercase(s::AbstractString)

回来吧 s 将所有字符转换为小写。

请参阅 大写;大写, [医滴度酶], [医低钙].

*例子*

julia> lowercase("STRINGS AND THINGS")
"strings and things"
lowercase(c::AbstractChar)

转换/转换 c 到小写。

请参阅 大写;大写, [医滴度酶].

*例子*

julia> lowercase('A')
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> lowercase('Ö')
'ö': Unicode U+00F6 (category Ll: Letter, lowercase)
titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true) -> String

将每个单词的第一个字符大写 s;如果 严格的 是真的，所有其他字符都转换为小写，否则它们保持不变。 默认情况下，所有以新字素开头的非字母都被视为单词分隔符；谓词可以作为 wordsep 关键字来确定哪些字符应该被视为单词分隔符。 请参阅 上肢,上肢只大写第一个字符 s.

请参阅 大写;大写, 小写, 上肢,上肢.

*例子*

julia> titlecase("the JULIA programming language")
"The Julia Programming Language"

julia> titlecase("ISS - international space station", strict=false)
"ISS - International Space Station"

julia> titlecase("a-a b-b", wordsep = c->c==' ')
"A-a B-b"
titlecase(c::AbstractChar)

转换/转换 c 到滴定酶。 这可能与有向图的大写不同，请比较下面的示例。

请参阅 大写;大写, 小写.

*例子*

julia> titlecase('a')
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)

julia> titlecase('dž')
'Dž': Unicode U+01C5 (category Lt: Letter, titlecase)

julia> uppercase('dž')
'DŽ': Unicode U+01C4 (category Lu: Letter, uppercase)
uppercasefirst(s::AbstractString) -> String

回来吧 s 随着第一个字符转换为大写（技术上是Unicode的"标题大小写"）。 请参阅 [医滴度酶]将每个单词的第一个字符大写 s.

请参阅 [医低钙], 大写;大写, 小写, [医滴度酶].

*例子*

julia> uppercasefirst("python")
"Python"
lowercasefirst(s::AbstractString)

回来吧 s 第一个字符转换为小写。

请参阅 上肢,上肢, 大写;大写, 小写, [医滴度酶].

*例子*

julia> lowercasefirst("Julia")
"julia"
join([io::IO,] iterator [, delim [, last]])

加入任何 迭代器 在单个字符串中，在相邻项之间插入给定的分隔符（如果有的话）。 如果 最后一次 被给出，它将被用来代替 德利姆 在最后两个项目之间。 每项 迭代器 通过以下方式转换为字符串 打印(io::IOBuffer,x). 如果 伊俄 被给出，结果被写入到 伊俄 而不是作为一个 字符串.

*例子*

julia> join(["apples", "bananas", "pineapples"], ", ", " and ")
"apples, bananas and pineapples"

julia> join([1,2,3,4,5])
"12345"
chop(s::AbstractString; head::Integer = 0, tail::Integer = 1)

删除第一个 头 最后一个 尾巴 字符从 s. 电话 印章(s) 删除最后一个字符 s. 如果要求删除比 长度(s) 然后返回一个空字符串。

请参阅 chomp, 开始，开始, 第一个.

*例子*

julia> a = "March"
"March"

julia> chop(a)
"Marc"

julia> chop(a, head = 1, tail = 2)
"ar"

julia> chop(a, head = 5, tail = 5)
""
chopprefix(s::AbstractString, prefix::Union{AbstractString,Regex}) -> SubString

删除前缀 前缀 从 s. 如果 s 不以开头 前缀，等于的字符串 s 被退回。

请参阅 [医杂碎].

兼容性

Julia1.8此功能自Julia1.8起可用。

*例子*

julia> chopprefix("Hamburger", "Ham")
"burger"

julia> chopprefix("Hamburger", "hotdog")
"Hamburger"
chopsuffix(s::AbstractString, suffix::Union{AbstractString,Regex}) -> SubString

删除后缀 后缀 从 s. 如果 s 不以结束 后缀，等于的字符串 s 被退回。

请参阅 chopprefix.

兼容性

Julia1.8此功能自Julia1.8起可用。

*例子*

julia> chopsuffix("Hamburger", "er")
"Hamburg"

julia> chopsuffix("Hamburger", "hotdog")
"Hamburger"
chomp(s::AbstractString) -> SubString

从字符串中删除单个尾随换行符。

请参阅 砍;砍.

*例子*

julia> chomp("Hello\n")
"Hello"
thisind(s::AbstractString, i::Integer) -> Int

如果 i 在边界内 s 返回其编码代码单元的字符开头的索引 i 是其中的一部分。 换句话说，如果 i 是一个字符的开始，返回 i;如果 i 不是字符的开始，倒回直到字符的开始并返回该索引。 如果 i 等于0或 ncodeunits（s）+1 回来吧 i. 在所有其他情况下抛出 BoundsError.

*例子*

julia> thisind("α", 0)
0

julia> thisind("α", 1)
1

julia> thisind("α", 2)
1

julia> thisind("α", 3)
3

julia> thisind("α", 4)
ERROR: BoundsError: attempt to access 2-codeunit String at index [4]
[...]

julia> thisind("α", -1)
ERROR: BoundsError: attempt to access 2-codeunit String at index [-1]
[...]
nextind(str::AbstractString, i::Integer, n::Integer=1) -> Int

*个案 n==1 如果 i 在边界内 s 返回其编码在索引之后开始的字符的开头的索引 i. 换句话说，如果 i 是一个字符的开头，返回下一个字符的开头；如果 i 不是字符的开始，向前移动直到字符的开始并返回该索引。 如果 i 等于 0 回来吧 1. 如果 i 是在边界，但大于或等于 lastindex(str) 回来吧 ncodeunits（str）+1. 否则扔 BoundsError. *个案 n>1 行为就像申请 n 时代 下一篇 为 n==1. 唯一的区别是，如果 n 是如此之大以至于申请 下一篇 会达到 ncodeunits（str）+1 然后，每个剩余的迭代将返回的值增加 1. 这意味着在这种情况下 下一篇 可以返回大于 ncodeunits（str）+1. *个案 n==0 回来吧 i 只有当 i 是一个有效的索引 s 或等于 0. 否则的话 StringIndexError 或 BoundsError 被抛出。

*例子*

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

朱莉娅>nextind（"α"，3）
错误：BoundsError：尝试访问索引[3]处的2-codeunit字符串
[...]

朱莉娅>nextind（"α"，0，2）
3

朱莉娅>nextind（"α"，1，2）
4
prevind(str::AbstractString, i::Integer, n::Integer=1) -> Int

*个案 n==1 如果 i 在边界内 s 返回其编码在索引之前开始的字符的开头的索引 i. 换句话说，如果 i 是一个字符的开头，返回前一个字符的开头；如果 i 不是字符的开始，倒回直到字符的开始并返回该索引。 如果 i 等于 1 回来吧 0. 如果 i 等于 ncodeunits（str）+1 回来吧 lastindex(str). 否则扔 BoundsError. *个案 n>1 行为就像申请 n 时代 上一页 为 n==1. 唯一的区别是，如果 n 是如此之大以至于申请 上一页 会达到 0 然后每个剩余的迭代将返回的值减少 1. 这意味着在这种情况下 上一页 可以返回负值。 *个案 n==0 回来吧 i 只有当 i 是一个有效的索引 斯特拉 或等于 ncodeunits（str）+1. 否则的话 StringIndexError 或 BoundsError 被抛出。

*例子*

julia> prevind("α", 3)
1

julia> prevind("α", 1)
0

julia> prevind("α", 0)
ERROR: BoundsError: attempt to access 2-codeunit String at index [0]
[...]

julia> prevind("α", 2, 2)
0

julia> prevind("α", 2, 3)
-1
textwidth(s::AbstractString)

给出打印字符串所需的列数。

*例子*

julia> textwidth("March")
5
textwidth(c)

给出打印字符所需的列数。

*例子*

julia> textwidth('α')
1

julia> textwidth('⛵')
2
isascii(cu::AbstractVector{CU}) where {CU <: Integer} -> Bool

测试向量中的所有值是否属于ASCII字符集（0x00到0x7f）。 此函数旨在用于需要快速ASCII检查的其他字符串实现。

isascii(c::Union{AbstractChar,AbstractString}) -> Bool

测试一个字符是否属于ASCII字符集，或者对于字符串的所有元素是否都是如此。

*例子*

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

例如, isascii 可以用作谓词函数 过滤器或 更换/更换分别删除或替换非ASCII字符:

julia> filter(isascii, "abcdeγfgh") # discard non-ASCII chars
"abcdefgh"

julia> replace("abcdeγfgh", !isascii=>' ') # replace non-ASCII chars with spaces
"abcde fgh"
iscntrl(c::AbstractChar) -> Bool

测试字符是否为控制字符。 控制字符是Unicode的Latin-1子集的非打印字符。

*例子*

julia> iscntrl('\x01')
true

朱莉娅>iscntrl('a')
错误
isdigit(c::AbstractChar) -> Bool

测试字符是否为ASCII十进制数字（0-9).

请参阅: 伊斯莱特.

*例子*

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false
isletter(c::AbstractChar) -> Bool

测试一个字符是否是一个字母。 如果字符属于Unicode通用类别字母，即类别代码以"L"开头的字符，则将其归类为字母。

请参阅: 伊斯迪吉特.

*例子*

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false
islowercase(c::AbstractChar) -> Bool

测试字符是否是小写字母（根据Unicode标准的 小写 派生属性）。

请参阅 全大写;全大写.

*例子*

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false
isnumeric(c::AbstractChar) -> Bool

测试字符是否为数字。 如果字符属于Unicode通用类别编号，则将其分类为数字，即类别代码以’N’开头的字符。

请注意，此广义类别包括¾和௰等字符。 使用方法 伊斯迪吉特检查一个字符是否是0到9之间的十进制数字。

*例子*

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false
isprint(c::AbstractChar) -> Bool

测试字符是否可打印，包括空格，但不是控制字符。

*例子*

julia> isprint('\x01')
false

julia> isprint('A')
true
ispunct(c::AbstractChar) -> Bool

测试字符是否属于Unicode通用类别标点符号，即类别代码以’P’开头的字符。

注意此行为不同于 [医]辅助性 c中的函数。

*例子*

julia> ispunct('α')
false

julia> ispunct('=')
false

julia> ispunct('/')
true

julia> ispunct(';')
true
isspace(c::AbstractChar) -> Bool

测试字符是否为任何空白字符。 包括ASCII字符'\t'，'\n'，'\v'，'\f'，'\r’和''，拉丁-1字符U+0085以及Unicode类别Zs中的字符。

*例子*

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true
isuppercase(c::AbstractChar) -> Bool

测试一个字符是否是大写字母（根据Unicode标准的 大写;大写 派生属性）。

请参阅 全大写;全大写.

*例子*

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia>isuppercase('❤')
错误
isxdigit(c::AbstractChar) -> Bool

测试字符是否是有效的十六进制数字。 请注意，这不包括 x （如标准 0x 前缀）。

*例子*

julia> isxdigit('a')
true

julia> isxdigit('x')
false
escape_string(str::AbstractString[, esc]; keep=(), ascii=false, fullhex=false)::AbstractString
escape_string(io, str::AbstractString[, esc]; keep=())::Nothing

传统C和Unicode转义序列的一般转义。 第一种形式返回转义的字符串，第二种形式将结果打印到 伊俄.

反斜杠（\）用双反斜杠转义（"\"). 不可打印的字符使用标准c转义码进行转义, "\0" 对于NUL（如果明确），unicode代码点（"\u" 前缀）或十六进制（"\x" 前缀）。

可选项 电调 参数指定任何其他字符，这些字符也应该由前面的反斜杠转义（" 在第一种形式中默认也被转义）。

论点 保持 指定要保持原样的字符集合。 请注意 电调 这里有优先权。

论点 ascii码 可以设置为 真的 转义所有非ASCII字符，而默认 ascii=错误 按原样输出可打印的Unicode字符。 (保持 优先于 ascii码.)

论点 富尔赫克斯 可以设置为 真的 要求所有 \u 转义以4个十六进制数字打印，以及 \U 转义以8个十六进制数字打印，而默认情况下（fullhex=错误）如果可能的话，它们会用更少的数字打印（省略前导零）。

请参阅 unescape_string进行反向操作。

兼容性

朱莉娅1.7 保持 自Julia1.7起，参数可用。
兼容性

朱莉娅1.12 ascii码 和 富尔赫克斯 参数需要Julia1.12。

*例子*

julia> escape_string("aaa\nbbb")
"aaa\\nbbb"

julia> escape_string("aaa\nbbb"; keep = '\n')
"aaa\nbbb"

julia> escape_string("\xfe\xff") # invalid utf-8
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # unambiguous
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0 would be ambiguous
"ℵ\\x000"
escape_raw_string(s::AbstractString, delim='"') -> AbstractString
escape_raw_string(io, s::AbstractString, delim='"')

以用于解析原始字符串字面量的方式转义字符串。 对于每个双引号（")输入字符串中的字符 s （或 德利姆 如果指定），此函数计算前一个反斜杠的数字_n_（\）字符，然后在那里增加从_n_到2n+1的反斜杠数量（即使对于_n_=0）。 它还将字符串末尾的反斜杠序列加倍。

此转义约定用于原始字符串和其他非标准字符串文本。 （它也恰好是Microsoft C/C所期望的转义约定++ 编译器运行时将命令行字符串解析为argv[]数组。)

请参阅 基地。escape_string().

unescape_string(str::AbstractString, keep = ())::AbstractString
unescape_string(io, s::AbstractString, keep = ())::Nothing

传统的C和Unicode转义序列的一般unescaping。 第一种形式返回转义的字符串，第二种形式将结果打印到 伊俄. 论点 保持 指定要保持原样的字符集合（以及背光）。

识别以下转义序列:

*转义反斜杠(\\) *转义双引号(\") *标准c转义序列（\一个, \b, \t, \n, \v, \f, \r, \e) *Unicode BMP码位（\u 带有1-4个尾随十六进制数字） *所有Unicode码位（\U 带有1-8个尾随十六进制数字;最大值=0010ffff) *十六进制字节(\x 带有1-2个尾随十六进制数字） *八进制字节(\ 带1-3尾八进制数字）

请参阅 escape_string.

*例子*

julia> unescape_string("aaa\\nbbb") # C escape sequence
"aaa\nbbb"

julia> unescape_string("\\u03c0") # unicode
"π"

julia> unescape_string("\\101") # octal
"A"

julia> unescape_string("aaa \\g \\n", ['g']) # using `keep` argument
"aaa \\g \n"

注释字符串s

请注意，AnnotatedStrings的API被认为是实验性的，并且可能会在Julia版本之间发生变化。

 
AnnotatedString{S <: AbstractString} <: AbstractString

带有元数据的字符串，以注释区域的形式。

更具体地说，这是一个简单的包装周围的任何其他 抽象字符串它允许包装字符串的区域使用标记值进行注释。

                           C
                    ┌──────┸─────────┐
  "this is an example annotated string"
  └──┰────────┼─────┘         │
     A        └─────┰─────────┘
                    B

上图表示一 注释字符串 其中三个范围已被注释（标记 A, B，而 C). 每个注释都包含一个标签（符号）和一个值（任何). 这三条信息作为一个 @NamedTuple{region::UnitRange{Int64},标签::符号,值}.

标签不需要是唯一的，同一个区域可以包含多个具有相同标签的注释。

为之编写的代码 注释字符串s一般应保存以下属性:

*注释应用于哪些字符 *注释应用于每个字符的顺序

额外的语义可以通过特定的使用引入 注释字符串s.

这些规则的推论是，相邻的、连续放置的、具有相同标签和值的注释等效于跨越组合范围的单个注释。

请参阅 注释文件, 注释字符串, 说明，和 注释！.

*构造函数*

AnnotatedString(s::S<:AbstractString) -> AnnotatedString{S}
AnnotatedString(s::S<:AbstractString, annotations::Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}})

注释字符串也可以用 注释字符串，其行为很像 字符串但保留参数中存在的任何注释。

*例子*

julia> AnnotatedString("this is an example annotated string",
                    [(1:18, :A, 1), (12:28, :B, 2), (18:35, :C, 3)])
"this is an example annotated string"
AnnotatedChar{S <: AbstractChar} <: AbstractChar

带有注释的Char。

更具体地说，这是一个简单的包装周围的任何其他 摘要:，其中包含任意标记注释的列表（@NamedTuple{label::Symbol, value}）与包装的字符。

请参阅: 注释字符串, 注释字符串, 说明，并 注释！.

*构造函数*

AnnotatedChar(s::S) -> AnnotatedChar{S}
AnnotatedChar(s::S, annotations::Vector{@NamedTuple{label::Symbol, value}})

*例子*

julia> AnnotatedChar('j', [(:label, 1)])
'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)
annotatedstring(values...)

创建一个 注释字符串 从任何数量的 价值 使用他们的 印刷业ed表示。

这就像 字符串，但注意保留存在的任何注释（以 注释字符串或 注释文件值）。

请参阅 注释字符串和 注释文件.

*例子*

julia> annotatedstring("now a AnnotatedString")
"now a AnnotatedString"

julia> annotatedstring(AnnotatedString("annotated", [(1:9, :label, 1)]), ", and unannotated")
"annotated, and unannotated"
annotations(chr::AnnotatedChar) -> Vector{@NamedTuple{label::Symbol, value}}

获取所有的注释 卫生署署长，以注释对的向量的形式。

annotations(str::Union{AnnotatedString, SubString{AnnotatedString}},
            [position::Union{Integer, UnitRange}]) ->
    Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}}

获取适用于 斯特拉. 应该 职位 提供，只提供与 职位 将被退回。

注释与它们应用于的区域一起提供，以区域—​注释元组的向量的形式。

按照文档中的语义 注释字符串，返回的注释顺序与应用它们的顺序相匹配。

请参阅: 注释！.

annotate!(char::AnnotatedChar, label::Symbol, value::Any)

注释,注释 查尔 带标签的值 （标签，值）.

annotate!(str::AnnotatedString, [range::UnitRange{Int}], label::Symbol, value)
annotate!(str::SubString{AnnotatedString}, [range::UnitRange{Int}], label::Symbol, value)

注释a 范围 的 斯特拉 （或整个字符串）带有标记的值 （标签，值）. 删除现有的 标签 注释，使用值为 什么都没有.

注释应用于的顺序 斯特拉 在语义上是有意义的，如 注释字符串.