字串

AbstractString 類型是 Julia 中所有字串實作的超類型。字串是 Unicode 碼點序列的編碼，由 AbstractChar 類型表示。Julia 對字串做了幾個假設

• 字串以固定大小的「碼元」編碼
  • 可以使用 codeunit(s, i) 萃取碼元
  • 第一個碼元索引為 1
  • 最後一個碼元索引為 ncodeunits(s)
  • 任何索引 i 只要符合 1 ≤ i ≤ ncodeunits(s) 都是有效的
• 字串索引是根據這些碼元進行
  • 字元透過有效字串索引 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 值。任何 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 可以採用界外值 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，但會傳回一個檢視，檢視範圍 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。

延伸說明

並發程式設計的安全屬性

即使在多個 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])

從以 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、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 來比對字串。

可以使用 @r_str 字串巨集來建立 Regex 物件。如果 pattern 字串需要內插，通常會使用 Regex(pattern[, flags]) 建構函式。有關旗標的詳細資訊，請參閱字串巨集的說明文件。

@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) 為真，則 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)

在 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，而不是子字串。

接受 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; # destructure capture groups by iteration

julia> hr
"11"

keys(m::RegexMatch) -> Vector

傳回底層 regex 所有擷取群組的鍵向量。即使擷取群組無法配對，也會包含鍵。也就是說，即使 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 是否在字母順序中出現在字串 b 之前（技術上來說，是依 Unicode 碼點的字典順序）。

範例

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)

從位置 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)

從位置 start 開始，在 string 中找出字元 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)

從位置 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") # 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 設定為空字串（""）。

傳回值是替換後的字串。如果提供 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 為 true，則每個其他字元都轉換為小寫，否則則保持不變。預設情況下，所有非字母開頭新字素都被視為單字分隔符號；可以傳遞謂詞作為 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

  表現得像對 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 應用 prevind n 次。唯一的差別是，如果 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 字元集，或字串中所有元素是否都是如此。

範例

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 逸出碼、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") # 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"