Strings

AbstractString 类型是 Julia 中所有字符串实现的超类型。字符串是由 AbstractChar 类型表示的 Unicode 代码点序列的编码。Julia 对字符串做了一些假设：

• 字符串是以固定大小的“代码单元”进行编码的

  • 可以使用 codeunit(s, i) 提取代码单元
  • 第一个代码单元的索引为 1
  • 最后一个代码单元的索引为 ncodeunits(s)
  • 任何索引 i 满足 1 ≤ i ≤ ncodeunits(s) 都是有效的

• 字符串索引是基于这些代码单元进行的：

  • 可以通过 s[i] 使用有效的字符串索引 i 提取字符
  • 字符串中的每个 AbstractChar 由一个或多个代码单元编码
  • 只有 AbstractChar 的第一个代码单元的索引是有效的索引
  • AbstractChar 的编码与其前后内容无关
  • 字符串编码是 自同步 的 – 即 isvalid(s, i) 的时间复杂度为 O(1)

一些从字符串中提取代码单元、字符或子字符串的字符串函数，如果传入超出范围或无效的字符串索引，会报错。这包括 codeunit(s, i) 和 s[i]。进行字符串索引运算的函数对索引采取更宽松的处理方式，当在范围内时会给出最接近的有效字符串索引，或者在超出范围时，表现得好像字符串的每一侧都有无限数量的字符进行填充。通常这些虚构的填充字符的代码单元长度为 1，但字符串类型可以根据其实现选择不同的“虚构”字符大小（例如，子字符串可能将索引运算传递给它们提供视图的底层字符串）。宽松索引函数包括那些用于索引运算的函数：thisind、nextind 和 prevind。该模型允许索引运算与超出范围的索引作为中间值一起工作，只要不使用它们来检索字符，这通常有助于避免需要处理边缘情况。

另请参见 codeunit、ncodeunits、thisind、nextind、prevind。

AbstractChar 类型是 Julia 中所有字符实现的超类型。字符表示一个 Unicode 代码点，可以通过 codepoint 函数转换为整数，以获取代码点的数值，或从相同的整数构造。这些数值决定了字符如何与 < 和 == 进行比较，例如。新的 T <: AbstractChar 类型至少应定义一个 codepoint(::T) 方法和一个 T(::UInt32) 构造函数。

给定的 AbstractChar 子类型可能只能表示 Unicode 的一个子集，在这种情况下，从不支持的 UInt32 值转换可能会抛出错误。相反，内置的 Char 类型表示 Unicode 的 超集（以无损编码无效字节流），在这种情况下，将非 Unicode 值 转换 为 UInt32 会抛出错误。可以使用 isvalid 函数检查给定 AbstractChar 类型中哪些代码点是可表示的。

在内部，AbstractChar 类型可能使用多种编码。通过 codepoint(char) 的转换不会揭示这种编码，因为它始终返回字符的 Unicode 值。任何 c::AbstractChar 的 print(io, c) 产生的编码由 io 决定（所有内置 IO 类型均为 UTF-8），如有必要，通过转换为 Char。

相反，write(io, c) 可能会根据 typeof(c) 发出编码，而 read(io, typeof(c)) 应该读取与 write 相同的编码。新的 AbstractChar 类型必须提供自己的 write 和 read 实现。

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

Char 是一个 32 位的 AbstractChar 类型，是 Julia 中字符的默认表示。Char 是用于字符字面量的类型，如 'x'，它也是 String 的元素类型。

为了无损地表示存储在 String 中的任意字节流，Char 值可能存储无法转换为 Unicode 代码点的信息 — 将这样的 Char 转换为 UInt32 将抛出错误。可以使用 isvalid(c::Char) 函数查询 c 是否表示有效的 Unicode 字符。

codepoint(c::AbstractChar) -> Integer

返回与字符 c 对应的 Unicode 代码点（一个无符号整数）（如果 c 不代表有效字符，则抛出异常）。对于 Char，这是一个 UInt32 值，但仅表示 Unicode 子集的 AbstractChar 类型可能返回不同大小的整数（例如 UInt8）。

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

返回字符串 s 中从索引 i 到 j 的字符数量。

这被计算为从 i 到 j 的代码单元索引中有效字符索引的数量。仅使用单个字符串参数时，这将计算整个字符串中的字符数量。使用 i 和 j 参数时，它计算在字符串 s 中有效索引的 i 和 j 之间（包括 i 和 j）的索引数量。除了在范围内的值，i 可以取超出范围的值 ncodeunits(s) + 1，而 j 可以取超出范围的值 0。

另请参见 isvalid, ncodeunits, lastindex, thisind, nextind, prevind。

示例

julia> length("jμΛIα")
5

sizeof(str::AbstractString)

字符串 str 的大小（以字节为单位）。等于 str 中代码单元的数量乘以 str 中一个代码单元的大小（以字节为单位）。

示例

julia> sizeof("")
0

julia> sizeof("∀")
3

*(s::Union{AbstractString, AbstractChar}, t::Union{AbstractString, AbstractChar}...) -> AbstractString

连接字符串和/或字符，生成一个 String 或 AnnotatedString（视情况而定）。这相当于对参数调用 string 或 annotatedstring 函数。内置字符串类型的连接总是产生类型为 String 的值，但其他字符串类型可能会选择返回适当的不同类型的字符串。

示例

julia> "Hello " * "world"
"Hello world"

julia> 'j' * "ulia"
"julia"

^(s::Union{AbstractString,AbstractChar}, n::Integer) -> AbstractString

将字符串或字符重复 n 次。这也可以写作 repeat(s, n)。

另见 repeat。

示例

julia> "Test "^3
"Test Test Test "

string(n::Integer; base::Integer = 10, pad::Integer = 1)

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

另见 digits, bitstring, count_zeros.

示例

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

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

string(xs...)

使用print函数从任何值创建一个字符串。

string 通常不应该直接定义。相反，定义一个方法 print(io::IO, x::MyType)。如果某种类型的 string(x) 需要高效，那么添加一个方法到 string 并定义 print(io::IO, x::MyType) = print(io, string(x)) 以确保函数的一致性是有意义的。

另请参见：String, repr, sprint, show。

示例

julia> string("a", 1, true)
"a1true"

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)

使用 show 函数从任何值创建一个字符串。您不应向 repr 添加方法；而应定义一个 show 方法。

可选的关键字参数 context 可以设置为 :key=>value 对，:key=>value 对的元组，或一个 IO 或 IOContext 对象，其属性用于传递给 show 的 I/O 流。

请注意，repr(x) 通常与在 Julia 中输入 x 的值相似。另请参见 repr(MIME("text/plain"), x)，以返回一个更适合人类消费的 x 的“美观打印”版本，相当于 x 的 REPL 显示。

示例

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)

从现有的 AbstractString 创建一个新的 String。

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

像 getindex 一样，但返回父字符串 s 在范围 i:j 或 r 内的视图，而不是创建副本。

@views 宏将任何字符串切片 s[i:j] 转换为子字符串 SubString(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。

扩展帮助

并发程序的安全属性

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

lazy"str"

使用常规字符串插值语法创建一个 LazyString。请注意，插值在 LazyString 构造时被 评估，但 打印 被延迟到第一次访问字符串时。

有关并发程序的安全属性，请参见 LazyString 文档。

示例

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

julia> typeof(str)
LazyString

transcode(T, src)

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

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

目前仅支持与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 结尾）字符串的地址复制字符串。（指针可以在之后安全释放。）如果指定了 length（以字节为单位的数据长度），则字符串不必以 NUL 结尾。

此函数被标记为“unsafe”，因为如果 p 不是有效的内存地址，指向请求长度的数据，则会崩溃。

ncodeunits(s::AbstractString) -> Int

返回字符串中的代码单元数量。访问此字符串的有效索引必须满足 1 ≤ i ≤ ncodeunits(s)。并非所有这样的索引都是有效的——它们可能不是字符的开始，但在调用 codeunit(s,i) 时会返回一个代码单元值。

示例

julia> ncodeunits("The Julia Language")
18

julia> ncodeunits("∫eˣ")
6

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

另请参见 codeunit, checkbounds, sizeof, length, lastindex.

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

返回给定字符串对象的代码单元类型。对于 ASCII、Latin-1 或 UTF-8 编码的字符串，这将是 UInt8；对于 UCS-2 和 UTF-16，它将是 UInt16；对于 UTF-32，它将是 UInt32。代码单元类型不必仅限于这三种类型，但很难想到不使用这些单位的广泛使用的字符串编码。当 s 是一个非空字符串时，codeunit(s) 与 typeof(codeunit(s,1)) 是相同的。

另请参见 ncodeunits。

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

返回字符串 s 在索引 i 处的代码单元值。注意

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

即 codeunit(s, i) 返回的值是 codeunit(s) 返回的类型。

示例

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

julia> typeof(a)
UInt8

另请参见 ncodeunits, checkbounds.

codeunits(s::AbstractString)

获取一个包含字符串代码单元的类似向量的对象。默认情况下返回一个 CodeUnits 包装器，但如果需要，可以为新的字符串类型可选地定义 codeunits。

示例

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

ascii(s::AbstractString)

将字符串转换为 String 类型，并检查它是否仅包含 ASCII 数据，否则抛出 ArgumentError，指示第一个非 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

一个表示正则表达式的类型。Regex 对象可以用于与 match 匹配字符串。

Regex 对象可以使用 @r_str 字符串宏创建。如果需要插入 pattern 字符串，通常使用 Regex(pattern[, flags]) 构造函数。有关标志的详细信息，请参见字符串宏的文档。

@r_str -> 正则表达式

构造一个正则表达式，例如 r"^[a-z]*$"，不进行插值和反转义（除了引号 " 仍需转义）。正则表达式还接受一个或多个标志，这些标志在结束引号后列出，以改变其行为：

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

如果需要插值，请参见 Regex。

示例

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

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

SubstitutionString(substr) <: AbstractString

将给定的字符串 substr 存储为 SubstitutionString，以便在正则表达式替换中使用。最常通过 @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<groupname> 指的是名称为 groupname 的命名捕获组。

示例

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

从字面字符串创建一个 Text 对象。

示例

julia> text"Julia"
Julia

isvalid(value) -> Bool

如果给定的值对于其类型有效，则返回 true，目前可以是 AbstractChar 或 String 或 SubString{String}。

示例

julia> isvalid(Char(0xd800))
false

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

julia> isvalid(Char(0xd799))
true

isvalid(T, value) -> Bool

如果给定的值对于该类型是有效的，则返回 true。当前类型可以是 AbstractChar 或 String。AbstractChar 的值可以是 AbstractChar 类型或 UInt32。String 的值可以是该类型、SubString{String}、Vector{UInt8} 或其连续子数组。

示例

julia> isvalid(Char, 0xd800)
false

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

julia> isvalid(Char, 0xd799)
true

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

谓词指示给定索引是否是 s 中字符编码的起始位置。如果 isvalid(s, i) 为真，则 s[i] 将返回该索引处编码开始的字符；如果为假，则 s[i] 将引发无效索引错误或边界错误，具体取决于 i 是否在有效范围内。为了使 isvalid(s, i) 成为 O(1) 函数，s 的编码必须是 自同步的。这是 Julia 通用字符串支持的基本假设。

另请参见 getindex, iterate, thisind, nextind, prevind, length。

示例

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]])

在字符串 s 中搜索正则表达式 r 的第一个匹配，并返回一个 RegexMatch 对象，其中包含匹配项，如果匹配失败则返回 nothing。可以通过访问 m.match 来检索匹配的子字符串，通过访问 m.captures 来检索捕获的序列。可选的 idx 参数指定开始搜索的索引。

示例

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

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

julia> m.captures
1-element Vector{Union{Nothing, SubString{String}}}:
 "b"

julia> m.match
"aba"

julia> match(rx, "cabac", 3) === nothing
true

eachmatch(r::Regex, s::AbstractString; overlap::Bool=false)

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

示例

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

一个表示在字符串中找到的单个Regex匹配的类型。通常通过match函数创建。

match字段存储整个匹配字符串的子字符串。captures字段存储每个捕获组的子字符串，按编号索引。要按捕获组名称索引，应该索引整个匹配对象，如示例所示。匹配开始的位置存储在offset字段中。offsets字段存储每个捕获组开始的位置，0表示未捕获的组。

此类型可以用作Regex的捕获组的迭代器，生成每个组中捕获的子字符串。因此，匹配的捕获可以被解构。如果某个组未被捕获，则会返回nothing而不是子字符串。

接受RegexMatch对象的方法定义在iterate、length、eltype、keys、haskey和getindex中，其中键是捕获组的名称或编号。有关更多信息，请参见keys。

示例

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; # 通过迭代解构捕获组

julia> hr
"11"

keys(m::RegexMatch) -> Vector

返回一个包含所有底层正则表达式捕获组的键的向量。即使捕获组未能匹配，键也会被包含在内。也就是说，即使 m[idx] == nothing，idx 也会在返回值中。

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

示例

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 是否在字母顺序上（严格来说，是按 Unicode 代码点的字典顺序）排在字符串 b 之前。

示例

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

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

julia> isless("a", "a")
false

==(a::AbstractString, b::AbstractString) -> Bool

测试两个字符串是否逐字符相等（从技术上讲，是逐Unicode代码点相等）。如果任一字符串是AnnotatedString，则字符串属性也必须匹配。

示例

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false

cmp(a::AbstractString, b::AbstractString) -> Int

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

示例

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

julia> cmp("b", "β")
-1

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

将 s 转换为字符串，并用 p 在左侧填充结果字符串，使其长度为 n 个字符（在 textwidth 中）。如果 s 已经是 n 个字符长，则返回相等的字符串。默认情况下用空格填充。

示例

julia> lpad("March", 10)
"     March"

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

将 s 转换为字符串，并在右侧用 p 填充结果字符串，使其长度为 n 个字符（在 textwidth 中）。如果 s 已经是 n 个字符长，则返回相等的字符串。默认情况下用空格填充。

示例

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

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

在 string 中查找 pattern 的第一次出现。等同于 findnext(pattern, string, firstindex(s))。

示例

julia> findfirst("z", "Hello to the world") # 返回无，但在 REPL 中不打印

julia> findfirst("Julia", "JuliaLang")
1:5

findnext(pattern::AbstractString, string::AbstractString, start::Integer)
findnext(pattern::AbstractPattern, string::String, start::Integer)

在位置 start 开始查找 string 中 pattern 的下一个出现。pattern 可以是一个字符串，或者一个正则表达式，在这种情况下 string 必须是 String 类型。

返回值是一个索引范围，其中找到匹配序列，使得 s[findnext(x, s, i)] == x：

findnext("substring", string, i) == start:stop，使得 string[start:stop] == "substring" 且 i <= start，如果没有匹配则返回 nothing。

示例

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)

在字符串 string 中从位置 start 开始查找字符 ch 的下一个出现位置。

示例

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

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

findlast(pattern::AbstractString, string::AbstractString)

查找 string 中 pattern 的最后一个出现位置。等价于 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 在 string 中的最后一次出现。

示例

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

julia> findlast('z', "happy") === nothing
true

findprev(pattern::AbstractString, string::AbstractString, start::Integer)

在位置 start 开始的 string 中查找 pattern 的上一个出现。

返回值是一个索引范围，其中找到匹配序列，使得 s[findprev(x, s, i)] == x：

findprev("substring", string, i) == start:stop，使得 string[start:stop] == "substring" 且 stop <= i，如果没有匹配则返回 nothing。

示例

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(needle::Union{AbstractString,AbstractPattern,AbstractChar}, haystack::AbstractString)

确定第一个参数是否是第二个参数的子字符串。如果 needle 是正则表达式，则检查 haystack 是否包含匹配项。

示例

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

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

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

julia> occursin(r"a.a", "abba")
false

另见 contains.

occursin(haystack)

创建一个函数，检查其参数是否出现在 haystack 中，即一个等效于 needle -> occursin(needle, haystack) 的函数。

返回的函数类型为 Base.Fix2{typeof(occursin)}。

示例

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

julia> search_f("JuliaLang")
true

julia> search_f("Python")
false

reverse(s::AbstractString) -> AbstractString

反转一个字符串。从技术上讲，这个函数反转字符串中的代码点，其主要用途是进行反向字符串处理，特别是反向正则表达式搜索。另请参见 reverseind 将 s 中的索引转换为 reverse(s) 中的索引，反之亦然，以及来自 Unicode 模块的 graphemes，以便对用户可见的“字符”（字形）而不是代码点进行操作。另请参见 Iterators.reverse 以无须复制的方式进行反向迭代。自定义字符串类型必须自行实现 reverse 函数，并通常应返回具有相同类型和编码的字符串。如果它们返回具有不同编码的字符串，则必须覆盖该字符串类型的 reverseind 以满足 s[reverseind(s,i)] == reverse(s)[i]。

示例

julia> reverse("JuliaLang")
"gnaLailuJ"

组合字符可能会导致意外结果：

julia> reverse("ax̂e") # 帽子在输入中位于 x 上方，在输出中位于 e 上方
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # 反转字形；帽子在输入和输出中都位于 x 上方
"ex̂a"

replace([io::IO], s::AbstractString, pat=>r, [pat2=>r2, ...]; [count::Integer])

在s中搜索给定的模式pat，并用r替换每个出现的实例。如果提供了count，则最多替换count个实例。pat可以是单个字符、字符向量或字符集合、字符串或正则表达式。如果r是一个函数，则每个出现的实例将被替换为r(s)，其中s是匹配的子字符串（当pat是AbstractPattern或AbstractString时）或字符（当pat是AbstractChar或AbstractChar的集合时）。如果pat是正则表达式并且r是一个SubstitutionString，则r中的捕获组引用将被相应的匹配文本替换。要从字符串中删除pat的实例，将r设置为空String（""）。

返回值是替换后的新字符串。如果提供了io::IO参数，则转换后的字符串将写入io（返回io）。 （例如，这可以与IOBuffer结合使用，以在原地重用预分配的缓冲区数组。）

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

示例

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 出现的地方拆分 str，并返回一个子字符串的迭代器。dlm 可以是 findnext 的第一个参数允许的任何格式（即作为字符串、正则表达式或函数），或者作为单个字符或字符集合。

如果省略 dlm，则默认为 isspace。

可选的关键字参数有：

• limit：结果的最大大小。limit=0 表示没有最大值（默认）
• keepempty：是否应在结果中保留空字段。没有 dlm 参数时默认是 false，有 dlm 参数时默认是 true。

另见 split。

示例

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)

返回一个迭代器，迭代 str 的 SubString，当在分隔符 dlm 上拆分时生成，并以相反的顺序（从右到左）返回。dlm 可以是 findprev 的第一个参数允许的任何格式（即字符串、单个字符或函数），或字符集合。

如果省略 dlm，则默认为 isspace，并且 keepempty 默认为 false。

可选的关键字参数有：

• 如果 limit > 0，迭代器最多将在返回其余未拆分的字符串之前拆分 limit - 1 次。limit < 1 意味着没有拆分限制（默认）。
• keepempty：在迭代时是否应返回空字段。默认情况下，如果没有 dlm 参数，则为 false，如果有 dlm 参数，则为 true。

请注意，与 split、rsplit 和 eachsplit 不同，此函数按输入中出现的顺序从右到左迭代子字符串。

另请参见 eachsplit、rsplit。

示例

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)

将 str 按照分隔符 dlm 的出现位置拆分为一个子字符串数组。 dlm 可以是 findnext 的第一个参数允许的任何格式（即作为字符串、正则表达式或函数），或者是单个字符或字符集合。

如果省略 dlm，则默认为 isspace。

可选的关键字参数有：

• limit：结果的最大大小。 limit=0 表示没有最大值（默认）
• keepempty：是否在结果中保留空字段。 默认情况下，如果没有 dlm 参数，则为 false，如果有 dlm 参数，则为 true。

另请参见 rsplit，eachsplit。

示例

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)

类似于 split，但从字符串的末尾开始。

示例

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

从 str 中移除前导和尾随字符，可以是由 chars 指定的字符，或者是 pred 函数返回 true 的字符。

默认行为是移除前导和尾随的空白和分隔符：有关详细信息，请参见 isspace。

可选的 chars 参数指定要移除的字符：它可以是单个字符、字符向量或字符集合。

另请参见 lstrip 和 rstrip。

示例

julia> strip("{3, 5}\n", ['{', '}', '\n'])
"3, 5"

lstrip([pred=isspace,] str::AbstractString) -> SubString
lstrip(str::AbstractString, chars) -> SubString

从 str 中移除前导字符，可以是由 chars 指定的字符，或者是 pred 函数返回 true 的字符。

默认行为是移除前导空白和分隔符：有关详细信息，请参见 isspace。

可选的 chars 参数指定要移除的字符：它可以是单个字符，或字符的向量或集合。

另请参见 strip 和 rstrip。

示例

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

julia> lstrip(a)
"March"

rstrip([pred=isspace,] str::AbstractString) -> SubString
rstrip(str::AbstractString, chars) -> SubString

从 str 中移除尾部字符，可以是由 chars 指定的字符，或者是函数 pred 返回 true 的字符。

默认行为是移除尾部的空白和分隔符：有关详细信息，请参见 isspace。

可选的 chars 参数指定要移除的字符：它可以是单个字符，或字符的向量或集合。

另请参见 strip 和 lstrip。

示例

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

julia> rstrip(a)
"March"

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

如果 s 以 prefix 开头，则返回 true，其中 prefix 可以是字符串、字符或字符的元组/向量/集合。如果 prefix 是字符的元组/向量/集合，则测试 s 的第一个字符是否属于该集合。

另请参见 endswith, contains.

示例

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

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

检查一个 IO 对象是否以一个前缀开始，该前缀可以是字符串、字符，或字符的元组/向量/集合。另见 peek。

startswith(prefix)

创建一个函数，检查其参数是否以 prefix 开头，即一个等价于 y -> startswith(y, prefix) 的函数。

返回的函数类型为 Base.Fix2{typeof(startswith)}，可以用于实现专门的方法。

示例

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

julia> startswith("Julia")("Ends with Julia")
false

startswith(s::AbstractString, prefix::Regex)

如果 s 以正则表达式模式 prefix 开头，则返回 true。

另请参见 occursin 和 endswith。

示例

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

endswith(s::AbstractString, suffix::Union{AbstractString,Base.Chars})

如果 s 以 suffix 结尾，则返回 true，其中 suffix 可以是字符串、字符或字符的元组/向量/集合。如果 suffix 是字符的元组/向量/集合，则测试 s 的最后一个字符是否属于该集合。

另请参见 startswith, contains.

示例

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

endswith(suffix)

创建一个函数，检查其参数是否以 suffix 结尾，即一个等价于 y -> endswith(y, suffix) 的函数。

返回的函数类型为 Base.Fix2{typeof(endswith)}，可用于实现专门的方法。

示例

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

julia> endswith("Julia")("JuliaLang")
false

endswith(s::AbstractString, suffix::Regex)

如果 s 以正则表达式模式 suffix 结尾，则返回 true。

另请参见 occursin 和 startswith。

示例

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

contains(haystack::AbstractString, needle)

如果 haystack 包含 needle，则返回 true。这与 occursin(needle, haystack) 相同，但为了与 startswith(haystack, needle) 和 endswith(haystack, needle) 一致而提供。

另请参见 occursin, in, issubset。

示例

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

contains(needle)

创建一个函数，检查其参数是否包含 needle，即一个等价于 haystack -> contains(haystack, needle) 的函数。

返回的函数类型为 Base.Fix2{typeof(contains)}，可以用来实现专门的方法。

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

获取由s的前n个字符组成的字符串。

示例

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

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

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

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

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

示例

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

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

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

uppercase(c::AbstractChar)

将 c 转换为大写。

另见 lowercase, titlecase。

示例

julia> uppercase('a')
'A': ASCII/Unicode U+0041 (类别 Lu: 字母，大写)

julia> uppercase('ê')
'Ê': Unicode U+00CA (类别 Lu: 字母，大写)

uppercase(s::AbstractString)

返回 s，将所有字符转换为大写。

另见 lowercase，titlecase，uppercasefirst。

示例

julia> uppercase("Julia")
"JULIA"

lowercase(c::AbstractChar)

将 c 转换为小写。

另见 uppercase, titlecase。

示例

julia> lowercase('A')
'a': ASCII/Unicode U+0061 (类别 Ll: 字母, 小写)

julia> lowercase('Ö')
'ö': Unicode U+00F6 (类别 Ll: 字母, 小写)

lowercase(s::AbstractString)

返回 s，将所有字符转换为小写。

另见 uppercase，titlecase，lowercasefirst。

示例

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

titlecase(c::AbstractChar)

将 c 转换为标题大小写。这可能与双音字母的大写形式不同，请参见下面的示例。

另请参阅 uppercase, lowercase.

示例

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)

titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true) -> String

将s中每个单词的首字母大写；如果strict为真，则其他字符都转换为小写，否则保持不变。默认情况下，所有非字母字符开始的新图形都被视为单词分隔符；可以通过wordsep关键字传递一个谓词来确定哪些字符应被视为单词分隔符。另请参见uppercasefirst以仅将s中的第一个字符大写。

另请参见uppercase，lowercase，uppercasefirst。

示例

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"

uppercasefirst(s::AbstractString) -> String

返回 s，其首个字符转换为大写（在技术上是 Unicode 的“标题大小”）。另请参见 titlecase 以将 s 中每个单词的首个字符大写。

另请参见 lowercasefirst，uppercase，lowercase，titlecase。

示例

julia> uppercasefirst("python")
"Python"

lowercasefirst(s::AbstractString)

返回 s，其第一个字符转换为小写。

另见 uppercasefirst，uppercase，lowercase，titlecase。

示例

julia> lowercasefirst("Julia")
"julia"

join([io::IO,] iterator [, delim [, last]])

将任何 iterator 连接成一个单一的字符串，在相邻项之间插入给定的分隔符（如果有的话）。如果给定了 last，它将用于最后两个项之间，而不是 delim。iterator 的每个项通过 print(io::IOBuffer, x) 转换为字符串。如果给定了 io，结果将写入 io 而不是作为 String 返回。

示例

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中移除前head个字符和后tail个字符。调用chop(s)会移除s的最后一个字符。如果请求移除的字符数量超过了length(s)，则返回一个空字符串。

另请参见 chomp, startswith, first.

示例

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 中移除前缀 prefix。如果 s 不以 prefix 开头，则返回一个与 s 相等的字符串。

另见 chopsuffix。

示例

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

julia> chopprefix("Hamburger", "hotdog")
"Hamburger"

chopsuffix(s::AbstractString, suffix::Union{AbstractString,Regex}) -> SubString

从 s 中移除后缀 suffix。如果 s 不以 suffix 结尾，则返回一个与 s 相等的字符串。

另见 chopprefix。

示例

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

julia> chopsuffix("Hamburger", "hotdog")
"Hamburger"

chomp(s::AbstractString) -> SubString

从字符串中移除一个尾随换行符。

另见 chop。

示例

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

  行为类似于将 nextind 应用 n 次，针对 n==1。唯一的区别是，如果 n 大到应用 nextind 会达到 ncodeunits(str)+1，那么每次剩余的迭代都会将返回值增加 1。这意味着在这种情况下，nextind 可以返回一个大于 ncodeunits(str)+1 的值。

• 情况 n == 0

  仅当 i 是 s 中的有效索引或等于 0 时返回 i。否则抛出 StringIndexError 或 BoundsError。

示例

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

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

julia> nextind("α", 0, 2)
3

julia> 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

  行为类似于将 prevind 应用 n 次，针对 n==1。唯一的区别是，如果 n 大到应用 prevind 会达到 0，那么每次剩余的迭代都会将返回值减少 1。这意味着在这种情况下，prevind 可以返回负值。

• 情况 n == 0

  仅当 i 是 str 中的有效索引或等于 ncodeunits(str)+1 时返回 i。否则抛出 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(c)

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

示例

julia> textwidth('α')
1

julia> textwidth('⛵')
2

textwidth(s::AbstractString)

给定一个字符串，返回打印该字符串所需的列数。

示例

julia> textwidth("March")
5

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

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

示例

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

例如，isascii 可以作为 filter 或 replace 的谓词函数，分别用于移除或替换非 ASCII 字符：

julia> filter(isascii, "abcdeγfgh") # 丢弃非 ASCII 字符
"abcdefgh"

julia> replace("abcdeγfgh", !isascii=>' ') # 用空格替换非 ASCII 字符
"abcde fgh"

isascii(cu::AbstractVector{CU}) where {CU <: Integer} -> Bool

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

iscntrl(c::AbstractChar) -> Bool

测试一个字符是否是控制字符。控制字符是拉丁-1子集Unicode的非打印字符。

示例

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

isdigit(c::AbstractChar) -> Bool

测试一个字符是否为十进制数字（0-9）。

另见：isletter。

示例

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

isletter(c::AbstractChar) -> Bool

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

另请参见: isdigit。

示例

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

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

另见 isuppercase。

示例

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

测试一个字符是否为数字。如果一个字符属于 Unicode 一般类别 Number，则该字符被归类为数字，即其类别代码以 'N' 开头的字符。

请注意，这个广泛的类别包括字符如 ¾ 和 ௰。使用 isdigit 来检查一个字符是否是 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' 开头的字符。

示例

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标准的Uppercase派生属性）。

另见 islowercase。

示例

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

isxdigit(c::AbstractChar) -> Bool

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

示例

julia> isxdigit('a')
true

julia> isxdigit('x')
false

escape_string(str::AbstractString[, esc]; keep = ())::AbstractString
escape_string(io, str::AbstractString[, esc]; keep = ())::Nothing

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

反斜杠 (\) 被转义为双反斜杠 ("\\")。不可打印字符要么用其标准 C 转义码转义，NUL 用 "\0"（如果不模糊），unicode 代码点（"\u" 前缀）或十六进制（"\x" 前缀）转义。

可选的 esc 参数指定任何其他也应通过前置反斜杠转义的字符（在第一种形式中，" 也默认被转义）。

参数 keep 指定要保持原样的字符集合。请注意，esc 在这里具有优先权。

另请参见 unescape_string 以进行反向操作。

示例

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

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

julia> escape_string("\xfe\xff") # 无效的 utf-8
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # 不模糊
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0 会模糊
"ℵ\\x000"

escape_raw_string(s::AbstractString, delim='"') -> AbstractString
escape_raw_string(io, s::AbstractString, delim='"')

以解析原始字符串字面量的方式转义字符串。对于输入字符串 s 中的每个双引号 (") 字符（如果指定了 delim 则使用 delim），此函数计算前面反斜杠 (\) 字符的数量 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 转义序列的一般解码。第一种形式返回解码后的字符串，第二种形式将结果打印到 io。参数 keep 指定了一组字符（连同反斜杠）应保持原样。

以下转义序列被识别：

• 转义反斜杠 (\\)
• 转义双引号 (\")
• 标准 C 转义序列 (\a, \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 转义序列
"aaa\nbbb"

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

julia> unescape_string("\\101") # 八进制
"A"

julia> unescape_string("aaa \\g \\n", ['g']) # 使用 `keep` 参数
"aaa \\g \n"

AnnotatedString{S <: AbstractString} <: AbstractString

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

更具体地说，这是对任何其他 AbstractString 的简单包装，允许将被包装字符串的区域注释为带标签的值。

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

上面的图表示一个 AnnotatedString，其中三个范围已被注释（标记为 A、B 和 C）。每个注释包含一个标签（Symbol）和一个值（Any）。这三条信息作为 @NamedTuple{region::UnitRange{Int64}, label::Symbol, value} 保存。

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

为 AnnotatedString 编写的代码通常应保持以下属性：

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

特定使用 AnnotatedString 可能会引入额外的语义。

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

另请参见 AnnotatedChar、annotatedstring、annotations 和 annotate!。

构造函数

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

也可以使用 annotatedstring 创建 AnnotatedString，它的作用类似于 string，但保留参数中存在的任何注释。

示例

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

带注释的字符。

更具体地说，这是一个简单的包装器，围绕任何其他 AbstractChar，它与被包装的字符一起保存一组任意标记的注释（@NamedTuple{label::Symbol, value}）。

另请参见：AnnotatedString，annotatedstring，annotations 和 annotate!。

构造函数

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...)

使用它们的 print 表示从任意数量的 values 创建一个 AnnotatedString。

这类似于 string，但会处理以 AnnotatedString 或 AnnotatedChar 值的形式存在的任何注释。

另请参见 AnnotatedString 和 AnnotatedChar。

示例

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

julia> annotatedstring(AnnotatedString("annotated", [(1:9, :label => 1)]), ", and unannotated")
"annotated, and unannotated"

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

获取适用于 str 的所有注释。如果提供了 position，则仅返回与 position 重叠的注释。

注释与其适用的区域一起提供，以区域–注释元组的向量形式。

根据 AnnotatedString 中记录的语义，返回的注释顺序与它们被应用的顺序相匹配。

另见: annotate!.

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

获取 chr 的所有注释，以注释对的向量形式返回。

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

用带标签的值（label => value）注释str的range（或整个字符串）。要删除现有的label注释，请使用值nothing。

注释应用于str的顺序在语义上是有意义的，如AnnotatedString中所述。

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

用 label => value 对 char 进行注释。