字符串

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

• 字符串以固定大小的“代码单元”进行编码
  • 代码单元可以使用 codeunit(s, i) 提取
  • 第一个代码单元的索引为 1
  • 最后一个代码单元的索引为 ncodeunits(s)
  • 任何满足 1 ≤ i ≤ ncodeunits(s) 的索引 i 都在范围内
• 字符串索引使用这些代码单元进行
  • 使用有效的字符串索引 i 通过 s[i] 提取字符
  • 字符串中的每个 AbstractChar 都由一个或多个代码单元编码
  • 只有 AbstractChar 的第一个代码单元的索引是有效的索引
  • AbstractChar 的编码独立于它之前或之后的内容
  • 字符串编码是 [自同步的] - 也就是说 isvalid(s, i) 为 O(1)

[自同步]: https://en.wikipedia.org/wiki/Self-synchronizing_code

一些从字符串中提取代码单元、字符或子字符串的字符串函数，如果传递给它们的是超出范围或无效的字符串索引，则会报错。这包括 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 值。print(io, c) 的任何 c::AbstractChar 都产生由 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 参数时，它计算从 i 到 j（包括）的索引数量，这些索引是字符串 s 中的有效索引。除了在范围内的值之外，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。这等效于对参数调用 string 函数。内置字符串类型的连接始终生成一个类型为 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) 通常类似于 x 的值在 Julia 中的输入方式。另请参阅 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 函数就会成功；它始终成功用于在 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])

从 C 风格（以 NUL 结尾）字符串的地址复制一个字符串，该字符串编码为 UTF-8。（指针可以在之后安全地释放。）如果指定了 length（数据的长度，以字节为单位），则字符串不必以 NUL 结尾。

此函数被标记为“不安全”，因为它会在 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。代码单元类型不必局限于这三种类型，但很难想到广泛使用的字符串编码不使用其中之一。codeunit(s) 与 typeof(codeunit(s,1)) 相同，当 s 是一个非空字符串时。

另请参阅 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 字符串宏创建。Regex(pattern[, flags]) 构造函数通常在 pattern 字符串需要插值时使用。有关标志的详细信息，请参阅字符串宏的文档。

@r_str -> Regex

构造正则表达式，例如 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) 为 true，则 s[i] 将返回编码在该索引处开始的字符，如果为 false，则 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 对象，如果匹配失败则返回无。匹配的子字符串可以通过访问 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)

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

示例

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

julia> m = eachmatch(rx, "a1a2a3a")
Base.RegexMatchIterator(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 而不是子字符串。

为 iterate、length、eltype、keys、haskey 和 getindex 定义了接受 RegexMatch 对象的方法，其中键是捕获组的名称或编号。有关更多信息，请参阅 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; # destructure capture groups by iteration

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 代码点逐个相等）。

示例

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") # 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)

在 string 中从位置 start 开始查找 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)

在 string 中查找字符 ch 的最后一次出现。

示例

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

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

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

在 string 中从位置 start 开始查找 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") # 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 中搜索给定的模式 pat，并将每个匹配项替换为 r。如果提供了 count，则最多替换 count 个匹配项。pat 可以是单个字符、字符向量或集合、字符串或正则表达式。如果 r 是函数，则每个匹配项将被替换为 r(s)，其中 s 是匹配的子串（当 pat 是 AbstractPattern 或 AbstractString 时）或字符（当 pat 是 AbstractChar 或 AbstractChar 集合时）。如果 pat 是正则表达式，而 r 是 SubstitutionString，则 r 中的捕获组引用将被替换为相应的匹配文本。要从 string 中删除 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"

split(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
split(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

在 dlm 的匹配项上将 str 拆分为子串数组。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::AbstractString)

如果 s 以 prefix 开头，则返回 true。如果 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::AbstractString)

如果 s 以 suffix 结尾，则返回 true。如果 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 (category Lu: Letter, uppercase)

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

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 (category Ll: Letter, lowercase)

julia> lowercase('Ö')
'ö': Unicode U+00F6 (category Ll: Letter, lowercase)

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

返回将第一个字符转换为大写（从技术上讲是 Unicode 的“标题大小写”）的 s。另请参见 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

  行为类似于对 n==1 应用 n 次 nextind。唯一的区别是，如果 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

  行为类似于对 n==1 应用 n 次 prevind。唯一的区别是，如果 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") # discard non-ASCII chars
"abcdefgh"

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

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

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

iscntrl(c::AbstractChar) -> Bool

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

示例

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 通用类别数字，即其类别代码以 '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' 和 ' '，Latin-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 转义代码转义，"\0" 用于 NUL（如果明确），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") # 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"

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