Engee 文档

线条

类型`AbstractString’是Julia中所有字符串实现的超类型。 字符串是字符代码序列的编码https://unicode.org /[Unicode]由`AbstractChar`类型表示。 Julia对字符串做了几个假设:

  • 字符串被编码为固定大小的"代码单位"。 可以使用`codeunit(s,i)'提取代码单元。 代码的第一个单元具有索引'1'。 最后一个代码单元具有索引’ncodeunits`s)'。 任何索引’i’使得`1≤i≤ncodeunits(s)'在边界内。

  • 字符串的索引是根据这些代码单元来执行的。 使用`s[i]提取字符，有效字符串索引为`i。 字符串中的每个字符’AbstractChar’都使用一个或多个代码单元进行编码。 只有’AbstractChar’代码的第一个单元的索引有效。 字符编码’AbstractChar’它不依赖于它前面或后面的内容。 **字符串编码是https://en.wikipedia.org/wiki/Self-synchronizing_code [自同步]，即’isvalid(s,i)`的计算复杂度为O(1)。

从字符串中提取代码单元、字符或子字符串的某些字符串函数会在传递越界或无效的字符串索引时产生错误。 这些包括`codeunit(s,i)和`s[i]'。 使用字符串索引执行算术运算的函数使用简化的索引方法，并在边界内输出最近的有效字符串索引。 如果它超出了边界，它们的行为就好像字符串的每一边都有无限多的字符。 通常，这些假想填充字符的代码单元的长度是'1，但是字符串类型可以选择不同大小的"假想"字符，如果它对它们的实现有意义（例如，子字符串可以将索引算 非严格索引函数包括那些为索引算术设计的函数：thisind，`nextind'，`prevent'。 此模型允许索引算术将越界索引用作中间值，只要它们不用于提取字符，这通常有助于避免需要编码来绕过边缘情况。

另请参阅说明 'codeunit', 'ncodeunits', 'thisind', '下一个', 'prevind'。

类型’AbstractChar’是Julia中所有符号实现的超类型。 字符表示Unicode代码位置。 使用函数 'codepoint'可以获得代码位置的整数值。 相反的情况也是如此：字符可以通过代码位置来识别。 例如，基于这些数值，使用运算符`<`和`=='比较字符。 在新类型’T<:AbstractChar’中，至少必须定义方法`codepoint(::T)和构造函数`T(::UInt32)。

子类型’AbstractChar’只能表示Unicode字符的子集。 在这种情况下，尝试转换不受支持的’UInt32’值将导致错误。 反之亦然，内置类型 'Char'是Unicode字符的_set_（这对于具有无效字节的流的无损编码是必需的）。 在这种情况下，将Unicode中不匹配的值转换为’UInt32’将导致错误。 使用函数 isvalid可以检查哪些代码位置可以由这种类型的`AbstractChar’表示。

在"AbstractChar"类型的实现中可以使用各种编码。 使用`codepoint(char)'函数进行转换时，内部编码无关紧要，因为始终返回字符的Unicode代码位置。 当对任何字符`c::AbstractChar`调用`print(io,c)时，编码由参数`io（UTF-8用于所有内置类型`IO`）确定。 如有必要，将执行转换为’Char'。

相比之下，当调用’write(io,c)`时，编码可能取决于`typeof(c)`的值，而调用`read(io,typeof(c))`必须以与`write’相同的编码接收数据。 新的’AbstractChar’类型需要自己的`write`和`read’实现。

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

'Char’是32位类型。 'AbstractChar'，默认表示Julia中的字符。 'Char’类型用于字符文字，例如 ，以及对于类型的元素 '字符串'。

要在无损字符串对象中表示任意字节流，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’可以取越界值’ncodeunits(s)+1`，参数`j`可以取越界值`0'。

该操作的时间复杂度一般是线性的。 换句话说，执行时间与字符串中的字节数或字符数成正比，因为该值是动态计算的。 这种情况与确定数组长度的方法不同，数组的执行时间是恒定的。

另请参阅说明 'isvalid`, 'ncodeunits', 'lastindex', 'thisind', '下一个', '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

通过返回对象执行字符串和/或字符连接 '字符串'或 'AnnotatedString'（视情况而定）。 这相当于调用一个函数。 '字符串'或 'annotatedstring'具有相同的参数。 连接内置类型的字符串时，总是返回’String’类型的值，但对于其他类型的字符串，结果可能具有不同的类型。

例子

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

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

重复字符串或字符`n’次。 也可以写成’repeat(s,n)'。

另请参阅说明 '重复'。

例子

julia> "Test "^3
"Test Test Test "
string(n::Integer; base::Integer = 10, pad::Integer = 1)

将整数`n’转换为基于指定基数的字符串。 您可以指定应执行填充的位数。

另请参阅说明 '数字', 'bitstring'和 'count_zeros'。

例子

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

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

使用函数创建任何值的字符串 '打印'。

通常不应该直接定义`string`函数。 而是定义’print(io::IO,x::MyType)`方法。 如果某种类型的函数`string(x)`应该非常有效，那么在`string`中添加一个方法并定义`print(io::IO,x::MyType)=print(io,string(x))'以便函数一致是有意义的。

另请参阅说明 '字符串', 'repr', '冲刺', '显示'。

例子

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)

使用函数从任何值创建字符串 '显示'。 您不应该向`repr`添加方法;相反，定义’show’方法。

可选的命名参数’context’可以分配对`:key=>value'，对元组':key=>value'或对象’IO’或 IOContext，其属性用于传递给’show’的I/O流。

请注意，调用`repr(x)的结果通常类似于在Julia中输入值`x`的方式。 相反，你可以打电话 'repr(mime("text/plain"),x)获取更易于阅读的格式化版本的`x`。 正是以这种形式，`x`的值显示在REPL中。

兼容性：Julia1.7

要在命名的"上下文"参数中传递元组，需要至少1.7的Julia版本。

例子

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`，但分别返回范围`i：j`或`r`中的父字符串`s’的表示形式，而不是创建副本。

宏 '@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'。

兼容性：Julia1.8

LazyString需要至少1.8的Julia版本。

高级帮助

并行程序的安全特性

就其本身而言，延迟行不会产生并行性问题，即使它是在几个Julia任务中输出的。 但是，如果在不同步调用时对记录值中的’print’方法可能发生并发错误，则延迟行的输出可能会导致问题。 此外，可以多次调用写入值的`print’方法，尽管只会返回一个结果。

兼容性：Julia1.9

在Julia不低于1.9的版本中，使用`LazyString’在上述意义上是安全的。

 
lazy"str"

创建 'LazyString'，使用常规字符串插值语法。 请注意，插值是在LazyString的构造过程中确定的，但是输出被推迟到第一次访问字符串。

有关并行程序的安全属性的信息，请参阅 'LazyString'。

例子

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

julia> typeof(str)
LazyString
兼容性：Julia1.8

懒惰的"str"需要至少1.8的Julia版本。

 
transcode(T, src)

将字符串数据从一种Unicode编码转换为另一种编码。 'src`是`String`或'Vector'类型的对象{UIntXX}'，包含UTF-XX代码单元，其中’XX’是数字8、16或32。 T’参数指示返回值的编码：如果要返回字符串`String（在UTF-8编码中），则为`String`，如果要返回向量`Vector`，则为`UIntXX'。{UIntXX}UTF编码数据的'-'XX'。 （您也可以使用整数类型别名 Cwchar_t用于转换外部C库使用的`wchar_t*'字符串。)

如果输入数据可以在目标编码中充分表示，则"转码"函数将成功执行。 对于从一种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字符）复制字符串。 （然后可以安全地释放指针。)如果指定了’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', '支票箱', '大小', '长度', '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}

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

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)

返回包含字符串的代码单元的类向量对象。 默认情况下，它返回shell’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’对象可用于使用函数匹配字符串 '匹配'。

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

要转义插值变量，请使用'\Q’和'\E`（例如，`Regex("\\Q$x\\E")'）。

 
@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/IEC8859-1或Latin-1字节一样），而不是字符编码。 在这种情况下，该标志经常与`s’组合。 您可以通过使用(UCP)或(UTF)启动模板来进一步细化此标志。

如果需要插值，请参阅类型的描述 '正则表达式'。

例子

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

此正则表达式的前三个标志被激活。

SubstitutionString(substr) <: AbstractString

将指定的字符串"substr"保存为"Substitution String"类型的对象，以便在正则表达式替换中使用。 它通常使用宏创建 '@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

创建一个基于文字字符串的"文本"对象。

例子

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}`,'+向量{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)`设置为true，`s[i]`将返回一个字符，其编码从该索引开始。 如果为false，`s[i]`将导致无效索引错误或越界错误，具体取决于索引`i’是否在可接受的范围内。 对于函数’isvalid(s,i)'具有O(1)复杂度级别，字符串`s`的编码必须是https://en.wikipedia.org/wiki/Self-synchronizing_code [自同步]。 这是Julia中支持通用字符串的基本假设。

另请参阅说明 'getindex', '迭代', 'thisind', '下一个', 'prevind`, '长度'。

例子

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{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'在字符串中找到。 通常由函数创建 '匹配'。

整个匹配字符串的子字符串存储在"匹配"字段中。 "捕获"字段存储具有数字索引的每个记录组的子字符串。 要按记录组名称编制索引，应改为对整个映射对象编制索引，如示例中所示。 映射开始的位置存储在"偏移"字段中。 "偏移"字段存储每个记录组开始的位置。 值为0表示尚未记录的组。

这种类型可以用作’Regex’记录的组迭代器，它输出每个组中记录的子字符串。 这允许您将映射记录分解为它们的组件。 如果没有记录组，则给出值"nothing"而不是子字符串。

接受’RegexMatch’对象的方法定义为 '迭代', '长度', 'eltype', '钥匙`, `haskey'和 'getindex'，其中键是记录组的名称或数字。 有关详细信息，请参阅说明 '钥匙'。

例子

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

返回基本正则表达式的所有条目组的键的向量。 即使与记录组没有匹配项，也会启用密钥。 换句话说，'idx’将在返回值中，即使’m[idx]==nothing'。

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

兼容性：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

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

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

返回`s`的字符串表示形式，并用字符`p’填充左边的结果字符串，最大长度为’n’字符（in 'textwidth')。 如果`s’的长度已经等于’n’个字符，则返回相等的字符串。 默认情况下，字符串填充空格。

例子

julia> lpad("March", 10)
"     March"
兼容性：Julia1.7

在Julia1.7中，该函数开始使用值’textwidth'，而不是简单地计算字符（代码位置）。

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

返回`s`的字符串表示形式，并用字符`p’填充右侧的结果字符串，长度为’n’字符（in 'textwidth')。 如果`s’的长度已经等于’n’个字符，则返回相等的字符串。 默认情况下，该行填充空格。

例子

julia> rpad("March", 20)
"March               "
兼容性：Julia1.7

在Julia1.7中，该函数开始使用值’textwidth'，而不是简单地计算字符（代码位置）。

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

在`string’中查找`pattern’的第一个匹配项。 相当于 'findnext(pattern,string,firstindex(s))`.

例子

julia> findfirst("z", "Hello to the world") # возвращает nothing, но не выводится в REPL

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

查找从"开始"位置开始的"字符串"中下一个出现的"模式"。 'Pattern’可以是字符串或正则表达式。 在后一种情况下，'string’参数必须是`String’类型。

返回的值是在其中找到匹配序列的索引范围，使得’s[findnext(x,s,i)]==x`:

'findnext("substring",string,i)=='start:stop,so`string[start:stop]=="substring"`and`+i⇐start+`,or’nothing’if there are no matches.

例子

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

此方法需要1.3或更高版本的Julia。

例子

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’中的最后一个匹配项。

兼容性：Julia1.3

此方法需要1.3或更高版本的Julia。

例子

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("substring",string,i)==`start:stop,so`string[start:stop]=="substring"`and`+stop⇐i+`,or`nothing’if there are no matches.

例子

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

另请参阅说明 '包含'。

occursin(haystack)

创建一个函数，用于检查其参数是否包含在’haystack’中，即相当于`needle->occissin(needle,haystack)`的函数。

返回的函数类型为"Base"。修正2{typeof(occursin)}`.

兼容性：Julia1.6

此方法需要至少1.6的Julia版本。

例子

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

julia> search_f("JuliaLang")
true

julia>search_f（"Python"）
错误
reverse(s::AbstractString) -> AbstractString

把线倒过来。 更严格地说，此函数反转字符串中代码位置的顺序。 它的主要目的是以相反的顺序处理字符串，特别是在向后搜索正则表达式匹配时。 另请参阅功能说明 'reverseind'，它将`s’的索引转换为`reverse（s）的索引，反之亦然，以及来自Unicode模块的graphemes函数的描述，该模块使用用户可见字符（graphemes）而不是代码位置。 另外，请参阅功能说明。 '迭代器。reverse'，它允许以相反的顺序迭代而不创建副本。 自定义字符串类型应该有自己的`reverse`函数实现，它通常应该返回相同类型和相同编码的字符串。 如果以不同的编码返回字符串，则还必须为此字符串类型重新定义`reverse’函数，以便满足条件`s[reverse(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 — '替换字符串'，对`r`中的记录组的引用被替换为匹配的文本。 要从`string`中删除`pat’的实例，请为`r`分配空字符串’String`(`""')。

返回的值是替换后的新字符串。 如果指定了参数’io::IO'，则转换后的字符串将改为写入`io`（并返回`io`）。 （例如，这可以与 'IOBuffer'重新使用预先分配的缓冲区数组。)

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

兼容性：Julia1.7

版本1.7需要使用多个模板。
兼容性：Julia1.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)

字符串"str"由分隔符"dlm"的出现分隔，迭代器由子字符串返回。 'Dlm’参数可以具有方法的第一个参数允许的任何格式。 'findnext'（即字符串、正则表达式或函数），或包含单个字符或字符集合。

如果未指定`dlm’参数，则默认值为 'isspace'。

可选的命名参数:

  • 'limit'：结果的最大大小;'limit=0’表示无限大小（默认值）;

  • 'keepempty'：是否应在结果中保存空字段。 如果指定了`dlm’参数，则默认值为`false`；如果未指定`dlm`参数，则默认值为`true`。

另请参阅说明 '分裂'。

兼容性：Julia1.8

'Eachsplit’函数需要至少1.8的Julia版本。

例子

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'。

请注意，与函数不同 '分裂', `rsplit'和 'eachsplit'，该函数从右到左遍历输入子字符串。

另请参阅说明 `eachsplit'和 'rsplit'。

兼容性：Julia1.11

此功能要求Julia的版本不低于1.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"的出现将字符串"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'。

兼容性：Julia1.2

接受预测函数的方法需要至少1.2的Julia版本。

例子

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’参数定义要删除的字符。：它可以是单个字符，矢量或一组字符。

另请参阅说明 '条'和 '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’参数定义要删除的字符。：它可以是单个字符，矢量或一组字符。

另请参阅说明 '条'和 'lstrip'。

例子

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

julia> rstrip(a)
"March"
startswith(s::AbstractString, prefix::Union{AbstractString,Base.Chars})

如果字符串`s`以`prefix`参数的值开头，则返回值`true`，该参数可以是字符串、字符或元组、向量或一组字符。 如果’prefix’是元组，向量或一组字符，它会检查字符串`s`的第一个字符是否包含在此集合中。

另请参阅说明 endswith'和 '包含。

例子

julia> startswith("JuliaLang", "Julia")
true
startswith(io::IO, prefix::Union{AbstractString,Base.Chars})

检查对象"IO"是否以前缀开头，前缀可以是字符串、字符或元组、向量或一组字符。 另请参阅说明 '偷看'。

startswith(prefix)

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

返回的函数类型为"Base"。修正2{typeof(startswith)}`并可用于实施专门的方法。

兼容性：Julia1.5

要将`startswith(prefix)`函数与一个参数一起使用，需要至少1.5的Julia版本。

例子

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

julia> startswith("Julia")("Ends with Julia")
false
startswith(s::AbstractString, prefix::Regex)

如果字符串"s"以正则表达式模板"前缀"开头，则返回值"true"。

'startswith’不会将绑定编译为正则表达式，而是将其作为`match_option`传递给PCRE。 如果编译时间被摊销’发生在(r"^。.."，s）比'startswith（s，r"运行得更快。..").

另请参阅说明 `发生'和 'endswith'。

兼容性：Julia1.2

此方法需要至少1.2的Julia版本。

例子

julia> startswith("JuliaLang", r"Julia|Romeo")
true
endswith(s::AbstractString, suffix::Union{AbstractString,Base.Chars})

如果字符串`s`以`suffix`参数的值结尾，则返回值`true`，该参数可以是字符串、字符或元组、向量或一组字符。 如果’后缀’是一个元组、向量或一组字符，它会检查字符串`s`的最后一个字符是否包含在此集合中。

另请参阅说明 startswith'和 '包含。

例子

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

创建一个函数，检查其参数是否以`suffix`结束，即相当于`y->endswith(y,suffix)`的函数。

返回的函数类型为"Base"。修正2{typeof(endswith)}`并可用于实施专门的方法。

兼容性：Julia1.5

要将`endswith(suffix)'函数与一个参数一起使用，需要至少1.5的Julia版本。

例子

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

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

如果字符串`s`以正则表达式模式`suffix`结尾，则返回值`true'。

'endswith`不会将绑定编译为正则表达式，而是将其作为`match_option’传递给PCRE。 如果编译时间摊销’occurrin(r"。..$",s)'跑得比`endswith(s,r"快。..")`.

另请参阅说明 `发生'和 'startswith'。

兼容性：Julia1.2

此方法需要至少1.2的Julia版本。

例子

julia> endswith("JuliaLang", r"Lang|Roberts")
true
contains(haystack::AbstractString, needle)

如果`haystack`包含`needle'，则返回`true'。 类似于’occensin(needle,haystack)`调用，但提供了与`startswith(haystack,needle)`和`endswith(haystack,needle)'的一致性。

另请参阅说明 '发生', `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
兼容性：Julia1.5

'Contains’函数要求Julia版本至少为1.5。

 
contains(needle)

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

返回的函数类型为"Base"。修正2{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’转换为大写。

另请参阅说明 '小写'和 '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'，所有字符都转换为大写。

另请参阅说明 '小写', 'titlecase'和 'uppercasefirst'。

例子

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

将`c’转换为小写。

另请参阅说明 '大写'和 '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'，所有字符都转换为小写。

另请参阅说明 '大写', 'titlecase'和 'lowercasefirst'。

例子

julia> lowercase("STRINGS AND THINGS")
"strings and things"
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)
titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true) -> String

将字符串"s"中每个单词的第一个字符大写。 如果’strict’参数为true，则所有其他字符都转换为小写;否则，它们保持不变。 默认情况下，开始新字素的所有非字母字符都被视为单词分隔符。 在命名参数’wordsep`中，您可以传递一个谓词来定义应该被视为单词分隔符的字符。 另请参阅功能说明 'uppercasefirst'，它允许您只大写字符串`s`中的第一个字符。

另请参阅说明 '大写', '小写'和 '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`, '大写', '小写'和 'titlecase'。

例子

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

返回字符串’s'，并将第一个字符转换为小写。

另请参阅说明 '高年级', '大写', '小写'和 'titlecase'。

例子

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

通过在元素之间插入分隔符（如果指定），将迭代器对象组合成一行。 如果指定了’last’参数，则将使用其值而不是最后两个元素之间的`delim'。 'Iterator’对象的每个元素都使用`print(io::IOBuffer,x)'转换为字符串。 如果指定了’io’参数，则结果将写入’io’流，而不是作为字符串返回。

例子

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'和 '第一。

例子

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`不以’prefix’开头，则返回等于`s`的字符串。

另请参阅说明 'chopsuffix'。

兼容性：Julia1.8

此功能首先在Julia1.8中实现。

例子

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

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

从字符串`s`中删除后缀`suffix`。 如果字符串’s`不以’suffix’结尾，则返回等于`s`的字符串。

另请参阅说明 'chopprefix'。

兼容性：Julia1.8

此功能首先在Julia1.8中实现。

例子

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`应用`nextind``n’次。 唯一的区别是，如果`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`使用`prevent``n’次。 唯一的区别是，如果`n`的值太大，以至于当使用`prevent`时，达到`0`的值，那么在每次剩余的迭代中，返回值减少`1`。 这意味着在这种情况下，'prevent’可以返回负值。

  • 如果’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编码。

例子

julia> isascii('a')
true

朱莉娅>isascii('α')
错误

朱莉娅>isascii（"abc"）
真的

julia>isascii("αβγ")
错误

例如，'isascii’可以用作预测函数 '过滤器'或 `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

检查字符是否为控制字符。 控制字符是Latin-1Unicode子集的不可打印字符。

例子

julia> iscntrl('\x01')
true

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

检查字符是否为数字(0—​9)。

另请参阅说明 'isletter`。

例子

julia> isdigit('❤')
false

julia> isdigit('9')
true

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

检查字符是否是字母。 一个字符如果属于一般Unicode类别"Letter"，即其类别代码以"L"开头，则被视为字母。

另请参阅说明 'isdigit'。

例子

julia> isletter('❤')
false

julia> isletter('α')
true

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

检查字符是否是小写字母（根据Unicode标准中的"小写"属性）。

另请参阅说明 'isuppercase'。

例子

julia> islowercase('α')
true

julia> islowercase('Γ')
false

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

检查字符是否为数字。 一个字符如果属于一般Unicode类别"数字"，即其类别代码以"N"开头，则被视为一个数字。

请记住，这个广泛的类别包括符号，如¾和௰。 要检查字符是否是从0到9的数字，请使用函数 'isdigit'。

例子

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`属性）。

另请参阅说明 '全大写'。

例子

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'，执行相反的动作。

兼容性：Julia1.7

'Keep’论点首先在Julia1.7中实现。

例子

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'，如果指定）此函数计算反斜杠（\`）前面的_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") # escape-последовательность C
"aaa\nbbb"

julia> unescape_string("\\u03c0") # Юникод
"π"

julia> unescape_string("\\101") # восьмеричная форма
"A"

julia> unescape_string("aaa \\g \\n", ['g']) # используется аргумент `keep`
"aaa \\g \n"

'AnnotatedString’对象

AnnotatedString对象的API被认为是实验性的，可以在Julia的不同版本中进行修改。

 
AnnotatedString{S <: AbstractString} <: AbstractString

带注释区域形式的元数据的行。

更准确地说，它是任何其他字符串的简单包装。 'AbstractString'，它允许您使用项目符号值注释封装字符串的区域。

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

上图显示了带有三个注释区域（指定为`A`，B`和`C）的字符串`AnnotatedString`。 每个注释都包含一个标签（'Symbol`）和一个值（Any'）。 这三条信息存储为'+@NamedTuple{region::UnitRange{Int64},标签::符号,值}+.

标签不一定是唯一的：同一个区域可以有多个具有相同标签的注释。

通常，为`AnnotatedString`编写的代码中应保留以下属性:

  • 注记应用于的符号;

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

在使用`AnnotatedString`的特定情况下，可能会引入额外的语义。

这些规则的结果是，具有相同标签和值的相邻注释等同于复盖组合范围的单个注释。

另请参阅说明 '注释', '注释字符串', '注释'和 '注释！`.

构造函数

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

注释字符串也可以使用函数创建 `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

带有注解的Char对象。

更准确地说，它是任何其他字符的简单包装。 'AbstractChar'，其中包含任意项目符号注释的列表（'@NamedTuple{label::Symbol, value}`)连同封装的符号。

另请参阅说明 '注释字符串', '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...)

使用任意数量的"值"使用其输出表示形式创建"AnnotatedString"字符串（'打印')。

它的工作原理类似 'string'，但保留所有可用的注释（作为值 '注释字符串'或 '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'，返回的注释的顺序对应于它们被应用的顺序。

另请参阅说明 '注释！`.

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`（或整个字符串）中的范围。 要删除现有的"label"注释，请使用"nothing"值。

注释应用于"str"的顺序具有语义含义，如 '注释字符串'。

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

用对"标签=>值"注释字符"char"。