文字列

Core.AbstractChar ──

AbstractChar は任意の文字の実装を表す上位型です。Julia において文字 (character) は Unicode 符号位置を表します。文字が表す符号位置は codepoint 関数で整数として取得でき、Char コンストラクタは整数で指定する符号位置を表す文字を作成します。符号位置を表す整数値は <== による文字の比較などで利用されます。新しい T <: AbstractChar 型は最低でも codepoint(::T) メソッドと T(::UInt32) コンストラクタを定義する必要があります。

Unicode の一部だけを表せる AbstractChar の部分型も定義でき、その場合はサポートされていない UInt32 からの変換でエラーを発生させることが許されています。逆に組み込みの Char 型が表すのは (正当でないバイト列を情報を失わずに表す必要があるために) Unicode の上位集合であり、Char から UInt32 への変換ではエラーが発生する可能性があります。与えられた AbstractChar の部分型で特定の符号位置が表現できるかどうかは isvalid で判定できます。

AbstractChar が内部で使うエンコーディングに制限はありません。ただし codepoint(char) は文字 char が表す Unicode 符号位置を返すので、codepoint(char) で文字を整数に変換するときエンコーディングは変換結果に影響しません。また c::AbstractChar に対する print(io, c)io が持つエンコーディング (組み込みの IO 型では UTF-8) のバイト列を生成し、そのとき必要なら Char への変換が行われます。

これに対して write(io, c) を使うと typeof(c) が持つエンコーディングで文字を書き出すことができます。同様に read(io, typeof(c))c と同じエンコーディングで読み込みを行います。新しい AbstractChar 型では writeread の実装が必要です。

Core.Char ──
Char(c::Union{Number,AbstractChar})

Char は 32 ビットの AbstractChar 型であり、Julia がデフォルトで使う文字の表現です。Char'x' のような文字リテラルの型であり、String の要素型でもあります。

String に格納されるバイトストリームを完全に表現するために、Char には Unicode 符号位置に変換できない情報も格納できるようになっています ──そのような CharUInt32 に変換するとエラーとなります。isvalid(c::Char) 関数を使うと c が正当な Unicode 文字を表すかどうかを判定できます。

Base.codepoint ── 関数
codepoint(c::AbstractChar) -> Integer

文字 c に対応する Unicode 符号位置を符号無し整数として返します。もし c が正当な Unicode 文字を表さなければエラーを送出します。Char に対する返り値は UInt32 ですが、Unicode の部分集合だけを表す AbstractChar 型では異なるサイズの符号無し整数 (UInt8 など) が返る可能性があります。

Base.length ── メソッド
length(s::AbstractString) -> Int
length(s::AbstractString, i::Integer, j::Integer) -> Int

s の位置 i から位置 j までの間に含まれる文字の個数を返します。これは符号単位に対する添え字 i から j の間で文字の開始位置として正当なものの個数として計算されます。文字列の引数 s だけを指定すると、文字列全体に含まれる文字の個数が計算されます。ij を指定すれば、ij の間 (境界含む) の整数で s の添え字として正当なものの個数が計算されます。境界内の値に加えて、i には境界を超えた値 ncodeunits(s) + 1 を指定でき、j には境界より前の値 0 を指定できます。

isvalid, ncodeunits, lastindex, thisind, nextind, prevind も参照してください。

julia> length("jμΛIα")
5
Base.sizeof ── メソッド
sizeof(str::AbstractString)

文字列 str のサイズを返します。単位はバイトです。返り値は str が使う符号単位のサイズと str に含まれる符号単位の個数を乗じた値と等しくなります。

julia> sizeof("")
0

julia> sizeof("∀")
3
Base.:* ── メソッド
*(s::Union{AbstractString, AbstractChar},
  t::Union{AbstractString, AbstractChar}...) -> AbstractString

複数の文字列または文字を連結し、String を作成します。これは同じ引数に対して string 関数を呼び出すのと等価です。組み込みの文字列型を連結すると必ず String 型が生成されますが、他の文字列型を使うと場合によっては引数と異なる文字列型が返る可能性があります。

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

julia> 'j' * "ulia"
"julia"
Base.:^ ── メソッド
^(s::Union{AbstractString,AbstractChar}, n::Integer)

文字列または文字 sn 回反復した文字列を返します。repeat(s, n) と書くこともできます。

repeat も参照してください。

julia> "Test "^3
"Test Test Test "
Base.string ── 関数
string(n::Integer; base::Integer = 10, pad::Integer = 1)

整数 nbase 進法で文字列に変換します。省略可能な引数 pad を指定すると、その桁までゼロ埋めされます。

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

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

nothing を除く任意の値から print 関数を使って文字列を作成します。

通常 string は直接定義するべきではなく、代わりに print(io::IO, x::MyType) というメソッドを定義するべきです。ただし特定の型に対する string(x) が非常に高速でなければならないなら、そのときは string にメソッドを追加した上で print(io::IO, x::MyType) = print(io, string(x)) として一貫した動作を行わせるのが理にかなっているでしょう。

julia> string("a", 1, true)
"a1true"
Base.repeat ── メソッド
repeat(s::AbstractString, r::Integer)

文字列 sr 回反復した文字列を返します。s^r と書くこともできます。

^ も参照してください。

julia> repeat("ha", 3)
"hahaha"
Base.repeat ── メソッド
repeat(c::AbstractChar, r::Integer) -> String

文字 cr 回反復した文字列を返します。c^r と書くこともできます。

julia> repeat('A', 3)
"AAA"
Base.repr ── メソッド
repr(x; context=nothing)

show 関数を使って任意の値から文字列を作成します。この関数の振る舞いを拡張するときは、repr ではなく show のメソッドを定義してください。

省略可能なキーワード引数 context には IO または IOContext オブジェクトを指定でき、このオブジェクトの属性が show に渡される IO ストリームの属性として使われます。

通常 repr(x) は Julia に値 x を入力するときに使える文字列を返すことに注意してください。人間にとって読みやすいように “整形された” バージョンの x を取得するには、repr(MIME("text/plain"), x) を使ってください。この二変数のバージョンは REPL で x を表示するときにも使われます。

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"

Core.String ── メソッド
String(s::AbstractString)

文字列を UTF-8 の連続バイト配列の表現に変換します。この表現は C に文字列を渡すときによく利用されます。

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

getindex と同様ですが、コピーを作らずにビューを返します。返るのは文字列 s の区間 i:j あるいは r に対するビューです。

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

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

julia> SubString("abc", 2)
"bc"
Base.transcode ── 関数
transcode(T, src)

文字列データを Unicode エンコーディング間で変換します。src には String または UTF-XX の符号単位からなる Vector{UIntXX} を指定します (後者で XX は 8, 16, 32 のいずれか)。T は返り値のエンコーディングを表します。TString とすれば (UTF-8 でエンコードされた) String が返り、UIntXX とすれば UTF-XX データからなる Vector{UIntXX} が返ります。外部 C ライブラリが使う wchar_t* 文字列を変換するときは、wchar_t* が表す整数型の別名として Cwchar_t を利用できます。

transcode 関数は入力データがターゲットのエンコーディングにおいて何らかの形で表現可能である限り成功します。特に UTF-XX エンコーディング間の変換は、不正な Unicode データが含まれていたとしても必ず成功します。

現在サポートされているのは UTF-8 が入力または出力となる変換だけです。

Base.unsafe_string ── 関数
unsafe_string(p::Ptr{UInt8}, [length::Integer])

UTF-8 でエンコードされた C スタイル (ヌル終端) の文字列を指定されたアドレスからコピーします (この関数が返った後、ポインタ p は安全に解放できます)。データの長さ (バイト数) length が指定されるなら文字列はヌル終端でなくて構いません。

この関数が unsafe (安全でない) とされているのは、p が要求された長さのデータを持たない不正なメモリアドレスだとクラッシュする可能性があるためです。

Base.ncodeunits ── メソッド
ncodeunits(s::AbstractString) -> Int

文字列に含まれる符号単位の個数を返します。文字列 s に対して境界内アクセスを行う添え字 i1 ≤ i ≤ ncodeunits(s) を満たす必要があります。ただしこの条件を満たす全ての i が正当なわけではありません ──文字の始まりを指さない添え字も存在します。一方で 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 も参照してください。

Base.codeunit ── 関数
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 も参照してください。

Base.codeunits ── 関数
codeunits(s::AbstractString)

文字列の符号単位からなるベクトルのようなオブジェクトを取得します。デフォルトでは CodeUnits という型のラッパーを返しますが、必要なら codeunits を新しい文字列に対して定義しても構いません。

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

文字列 sString 型に変換して返します。そのとき文字列が ASCII データだけを含むかどうかを判定し、もし ASCII でないバイトが含まれるならエラーを送出します。エラーには最初の非 ASCII バイトの位置が示されます。

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

julia> ascii("abcdefgh")
"abcdefgh"
[email protected]_str ── マクロ
@r_str -> Regex

r"^[a-z]*$" のようにして正規表現を構築します。補間とエスケープは行われません (ただし二重引用符 " だけはエスケープが必要です)。正規表現の最後の二重引用符の後には一つ以上のフラグを付与でき、正規表現の振る舞いを変更できます:

  • i: マッチングで大文字と小文字を区別しない。
  • m: トークン ^$ が (文字列全体ではなく) 各行の始まりと終わりにマッチする。
  • s: 修飾子 . が改行にもマッチする。
  • x: 「コメントモード」を有効にする。空白は \ でエスケープされない限り無視され、# は行コメントの開始とみなされる。
  • a: UCP モードを無効にする (ASCII モードを有効にする)。デフォルトでは \B, \b, \D, \d, \S, \s, \W, \w といったエスケープシーケンスは Unicode の文字プロパティに基づいてマッチするが、a オプションを付けると ASCII 文字だけにマッチする。

補間が必要なら Regex のコンストラクタを使ってください。

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

この正規表現では三つのフラグが有効になっています。

SubstitutionString(substr)

与えられた文字列 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}

[email protected]_str ── マクロ
@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"
[email protected]_str ── マクロ
@raw_str -> String

補間やエスケープを行わずに生の文字列を作成します。ただし二重引用符だけはエスケープが必要です。バックスラッシュが二重引用符とバックスラッシュをエスケープしますが、バックスラッシュにエスケープが必要になるのは二重引用符の前にバックスラッシュがあるときだけです。例えば 2n 個のバックスラッシュに二重引用符が続くと n 個のバックスラッシュとリテラルの終わりが表され、2n+1 個のバックスラッシュに二重引用符が続くと n 個のバックスラッシュと一つの二重引用符が表されます。

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

julia> println(raw"\"")
"

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

julia> println(raw"\\x \\\"")
\\x \"
[email protected]_str ── マクロ
@b_str

リテラル文字列からバイト (UInt8) の不変ベクトルを作成します。

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

julia> v[2]
0x32
[email protected]_str ── マクロ
@html_str -> Docs.HTML

リテラル文字列から HTML オブジェクトを作成します。

[email protected]_str ── マクロ
@text_str -> Docs.Text

リテラル文字列から Text オブジェクトを作成します。

Base.isvalid ── メソッド
isvalid(value) -> Bool

value がその型の値として正当なら true を返します。value の型は 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
Base.isvalid ── メソッド
isvalid(T, value) -> Bool

value が型 T の値として正当なら true を返します。T に指定できるのは AbstractCharString のいずれかです。TAbstractChar のとき value には AbstractChar 型または UInt32 型の値を指定でき、TString のとき value には String, Vector{UInt8}, SubString{String} のいずれかの型を持つ値を指定できます。

julia> isvalid(Char, 0xd800)
false

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

julia> isvalid(Char, 0xd799)
true
Base.isvalid ── メソッド
isvalid(s::AbstractString, i::Integer) -> Bool

s において位置 i が文字のエンコードの開始地点であるかどうかを判定します。isvalid(s, i)true なら、s[i] は位置 i から始まる文字を返します。isvalid(s, i)false なら、s[i]i が境界内なら StringIndexError を、境界外なら BoundsError を発生させます。isvalid(s, i) が O(1) の関数となるには、s のエンコーディングが自己同期的 (self-synchronizing) である必要があります。エンコーディングの自己同期性は 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("αβγdef", 2)
Stacktrace:
[...]
Base.match ── 関数
match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])

正規表現 r に対するマッチを s から検索し、見つかったなら最初のマッチに対する 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 Array{Union{Nothing, SubString{String}},1}:
 "b"

julia> m.match
"aba"

julia> match(rx, "cabac", 3) === nothing
true
Base.eachmatch ── 関数
eachmatch(r::Regex, s::AbstractString; overlap::Bool=false)

正規表現 r に対するマッチを s から全て検索し、マッチを生成する反復子を返します。overlaptrue にすると、マッチする部分文字列同士が s において重複する添え字を持つことが許可されます。overlapfalse だと、互いに重ならない部分文字列だけがマッチします。

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 Array{RegexMatch,1}:
 RegexMatch("a1a")
 RegexMatch("a3a")

julia> collect(eachmatch(rx, "a1a2a3a", overlap = true))
3-element Array{RegexMatch,1}:
 RegexMatch("a1a")
 RegexMatch("a2a")
 RegexMatch("a3a")
Base.isless ── メソッド
isless(a::AbstractString, b::AbstractString) -> Bool

アルファベット順 (正確には Unicode 符号位置の辞書順) で文字列 a が文字列 b より先に来るかどうかを判定します。

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

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

julia> isless("a", "a")
false
Base.:== ── メソッド
==(a::AbstractString, b::AbstractString) -> Bool

二つの文字列が等しいかどうかを文字ごと (正確には Unicode 符号位置ごと) に判定します。

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false
Base.cmp ── メソッド
cmp(a::AbstractString, b::AbstractString) -> Int

二つの文字列を比較します。ab が同じ長さを持ち全ての添え字で同じ文字を持つなら 0 を返し、ab の接頭語のとき、およびアルファベット順で ab より前にあるとき -1 を返し、ba の接頭語のとき、およびアルファベット順で ba より前にあるとき 1 を返します (正確に言うと、Unicode 符号位置の辞書式順序が使われます)。

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

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

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

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

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

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1
Base.lpad ── 関数
lpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ') -> String

s を文字列に変換し、結果が n 文字 (符号位置) になるよう p を左側に詰めます。s の変換結果が n 文字以上の長さを持つなら、変換結果をそのまま返します。詰められる文字 p のデフォルト値はスペースです。

julia> lpad("March", 10)
"     March"
Base.rpad ── 関数
rpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ') -> String

s を文字列に変換し、結果が n 文字 (符号位置) になるよう p を右側に詰めます。s の変換結果が n 文字以上の長さを持つなら、変換結果をそのまま返します。詰められる文字 p のデフォルト値はスペースです。

julia> rpad("March", 20)
"March               "
Base.findfirst ── メソッド
findfirst(pattern::AbstractString, string::AbstractString)
findfirst(pattern::Regex, string::String)

string に含まれる最初の pattern を見つけます。findnext(pattern, string, firstindex(s)) と等価です。

julia> findfirst("z", "Hello to the world") # nothing が返るが、REPL には表示されない。

julia> findfirst("Julia", "JuliaLang")
1:5
Base.findnext ── メソッド
findnext(pattern::AbstractString, string::AbstractString, start::Integer)
findnext(pattern::Regex, string::String, start::Integer)

string の位置 start 以降で最初に現れる pattern を見つけます。pattern には文字列と正規表現のいずれかを指定できます。pattern が正規表現なら stringString 型である必要があります。

返り値はマッチした部分文字列を示す区間です。例えば 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
Base.findnext ── メソッド
findnext(ch::AbstractChar, string::AbstractString, start::Integer)

string の位置 starts 以降で最初に現れる ch を見つけます。

Julia 1.3

このメソッドは Julia 1.3 以降でサポートされます。

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

julia> findnext('o', "Hello to the world", 6)
8
Base.findlast ── メソッド
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
Base.findlast ── メソッド
findlast(ch::AbstractChar, string::AbstractString)

string に含まれる最後の ch を見つけます。

Julia 1.3

このメソッドは Julia 1.3 以降でサポートされます。

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

julia> findlast('z', "happy") === nothing
true
Base.findprev ── メソッド
findprev(pattern::AbstractString, string::AbstractString, start::Integer)

string の位置 start 以前で最後に現れる pattern を見つけます。

返り値はマッチした部分文字列を示す区間です。例えば 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
Base.occursin ── 関数
occursin(needle::Union{AbstractString,Regex,AbstractChar}, haystack::AbstractString)

第一引数 needle が第二引数 haystack の中に現れるかどうかを判定します。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 も参照してください。

Base.reverse ── メソッド
reverse(s::AbstractString) -> AbstractString

文字列を反転します。正確に言うと、この関数は文字列中の符号位置を反転させるものであり、逆順の文字列処理 (特に逆順の正規表現検索) での利用が想定されています。s の添え字から reverse(s) の添え字への変換 (およびその逆) を行う reverseind 関数も参照してください。また Unicode モジュールの graphemes 関数を使うと、(符号単位ごとではなく) ユーザーが視覚的に認識する「文字」 (書記素, grapheme) ごとに処理が可能です。Iterators.reverse を使うとコピーを作成せずに逆順の反復が行えます。独自の文字列は reverse 関数を実装する必要があり、通常はそこで同じ型とエンコーディングを持つ文字列を返すべきです。異なるエンコーディングの文字列を返す場合は、s[reverseind(s,i)] == reverse(s)[i] が満たされるよう reverseind もオーバーライドするべきです。

julia> reverse("JuliaLang")
"gnaLailuJ"

julia> reverse("ax̂e") # 結合文字があると驚くような結果が得られることがある。
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # 書記素ごとに反転する。
"ex̂a"
Base.replace ── メソッド
replace(s::AbstractString, pat=>r; [count::Integer])

s に含まれるパターン pat を検索し、見つかったら r で置き換えます。count が指定されると、置換は最大でも count 回行われます。pat には単一の文字・文字のベクトルあるいは集合・文字列・正規表現を指定できます。r に関数を指定すると、見つかったパターンは r(s) で置換されます。ここで s にはマッチした部分文字列 (patRegex もしくは AbstractString のとき) あるいは文字 (patAbstractChar もしくは AbstractChar の集合のとき) が渡されます。pat が正規表現で rSubstitutionString だと、r に含まれるキャプチャグループの参照がマッチした文字列の対応する部分で置換されます。pat のインスタンスを string から取り除くには、r を空の String ("") にしてください。

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."
Base.split ── 関数
split(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
split(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

str を区切り文字 dlm で分け、部分文字列からなる配列を返します。dlm に指定できるフォーマットは findnext の第一引数と同じもの (つまり文字列・正規表現・関数)・単一の文字・文字のコレクションのいずれかです。

dlm を省略すると isspace がデフォルトで使われます。

省略可能なキーワード引数は次の通りです:

  • limit: 返り値の最大の長さを指定します。デフォルトの limit=0 は制限がないことを示します。
  • keepempty: 返り値に空のフィールドを格納するかどうかを制御します。デフォルトでは引数 dlm が与えられるとき false で、引数 dlm が与えられるとき true です。

rsplit も参照してください。

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

julia> split(a, ".")
2-element Array{SubString{String},1}:
 "Ma"
 "rch"
Base.rsplit ── 関数
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 Array{SubString{String},1}:
 "M"
 "a"
 "r"
 "c"
 "h"

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

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

str の先頭および末尾から特定の条件を満たす文字を削除します。削除する文字は chars が表す文字あるいは predtrue を返す文字として指定されます。

デフォルトでは先頭および末尾にある空白と区切り文字が削除されます。詳細は isspace を見てください。

省略可能な引数 chars は削除する文字を指定します。渡せるのは単一の文字もしくは文字のベクトル/集合です。

Julia 1.2

述語関数を渡す形の strip は Julia 1.2 以降でサポートされます。

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

str の先頭から特定の条件を満たす文字を削除します。削除する文字は chars が表す文字あるいは predtrue を返す文字として指定されます。

デフォルトでは先頭にある空白と区切り文字が削除されます。詳細は isspace を見てください。

省略可能な引数 chars は削除する文字を指定します。渡せるのは単一の文字もしくは文字のベクトル/集合です。

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

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

str の末尾から特定の条件を満たす文字を削除します。削除する文字は chars が表す文字あるいは predtrue を返す文字として指定されます。

デフォルトでは末尾にある空白が削除されます。詳細は isspace を見てください。

省略可能な引数 chars は削除する文字を指定します。渡せるのは単一の文字もしくは文字のベクトル/集合です。

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

julia> rstrip(a)
"March"
Base.startswith ── 関数
startswith(s::AbstractString, prefix::AbstractString)

sprefix で始まるなら true を返します。prefix が文字のベクトルまたは集合なら、s の最初の文字が prefix に属するかどうかを判定します。

endswith も参照してください。

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

引数が prefix で始まるかどうかを判定する関数、つまり y -> startswith(y, prefix) と等価な関数を返します。

返り値の関数は Base.Fix2{typeof(startswith)} という型を持ち、この型に対するメソッドの特殊化が可能です。

Julia 1.5

単一引数の startswith(prefix) は Julia 1.5 以降でサポートされます。

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

s が正規表現パターン prefix で始まるなら true を返します。

情報

startswith は文字列先頭を示すアンカーを正規表現としてコンパイルせず、マッチオプション (match_option) として PCRE に渡します。そのためコンパイル時間が償却されるなら occursin(r"^...", s) の方が startswith(s, r"...") より高速です。

occursin, endswith も参照してください。

Julia 1.2

このメソッドは Julia 1.2 以降でサポートされます。

julia> startswith("JuliaLang", r"Julia|Romeo")
true
Base.endswith ── 関数
endswith(s::AbstractString, suffix::AbstractString)

ssuffix で終わるなら true を返します。suffix が文字のベクトルまたは集合なら、s の最後の文字が prefix に属するかどうかを判定します。

startswith も参照してください。

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

引数が suffix で始まるかどうかを判定する関数、つまり y -> startswith(y, suffix) と等価な関数を返します。

返り値の関数は Base.Fix2{typeof(endswith)} という型を持ち、この型に対するメソッドの特殊化が可能です。

Julia 1.5

単一引数の endswith(suffix) は Julia 1.5 以降でサポートされます。

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

s が正規表現パターン prefix で終わるなら true を返します。

情報

endswith は文字列終端を示すアンカーを正規表現としてコンパイルせず、マッチオプション (match_option) として PCRE に渡します。そのためコンパイル時間が償却されるときは occursin(r"...$", s) の方が endswith(s, r"...") より高速です。

occursin, startswith も参照してください。

Julia 1.2

このメソッドは Julia 1.2 以降でサポートされます。

julia> endswith("JuliaLang", r"Lang|Roberts")
true
Base.contains ── 関数
contains(haystack::AbstractString, needle)

haystackneedle を含むかどうかを返します。これは occursin(needle, haystack) と等価ですが、startswith(haystack, needle) および endswith(haystack, needle) と引数の順序を一貫させた関数として提供されます。

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
Julia 1.5

contains 関数は Julia 1.5 以降でサポートされます。

contains(needle)

引数が needle を含むかどうかを判定する関数、つまり haystack -> contains(haystack, needle) と等価な関数を返します。

返り値の関数は Base.Fix2{typeof(contains)} という型を持ち、この型に対するメソッドの特殊化が可能です。

Base.first ── メソッド
first(s::AbstractString, n::Integer)

s の最初の n 文字からなる文字列を返します。

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

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

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"
Base.last ── メソッド
last(s::AbstractString, n::Integer)

s の最後の n 文字からなる文字列を返します。

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

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

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"
Base.Unicode.uppercase ── 関数
uppercase(s::AbstractString)

s の全ての文字を大文字に変換した文字列を返します。

julia> uppercase("Julia")
"JULIA"
Base.Unicode.lowercase ── 関数
lowercase(s::AbstractString)

s の全ての文字を小文字に変換した文字列を返します。

julia> lowercase("STRINGS AND THINGS")
"strings and things"
Base.Unicode.titlecase ── 関数
titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true) -> String

s に含まれる単語の最初の文字を大文字にした文字列を返します。structtrue なら単語の先頭以外の文字が小文字に変換されますが、false ならそのままとなります。デフォルトでは英字以外の全ての文字が単語の区切りとみなされますが、キーワード引数 wordsep に単語の区切りを判定する述語関数を渡すこともできます。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 のタイトルケース) に変換した文字列を返します。s に含まれる全ての単語の先頭を大文字にするには titlecase を使ってください。

lowercasefirst, uppercase, lowercase, titlecase も参照してください。

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

s の最初の文字を小文字にした文字列を返します。

uppercasefirst, uppercase, lowercase, titlecase も参照してください。

julia> lowercasefirst("Julia")
"julia"
Base.join ── 関数
join([io::IO,] strings [, delim [, last]])

文字列の配列 strings を一つの文字列に連結します。そのとき区切り文字 delim が与えられれば、それを要素の間に挟みます。last が与えられると、最後の二つの文字列の間では delim ではなく last が使われます。io が与えられると、結果は String として返るのではなく io に書き込まれるようになります。

stringsprint(io::IOBuffer, x) で文字列に変換できる要素 x を生成する反復可能オブジェクトであればどんなものでも構いません。

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

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

s の最初の head 文字と最後の tail 文字を取り除いた文字列を返します。chop(s) と呼び出すと s の最後の一文字を取り去った文字列が返ります。length(s) より長い文字数を指定したときの返り値は空文字列です。

julia> a = "March"
"March"

julia> chop(a)
"Marc"

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

julia> chop(a, head = 5, tail = 5)
""
Base.chomp ── 関数
chomp(s::AbstractString) -> SubString

文字列の末尾にある改行を一つだけ取り除いた文字列を返します。

julia> chomp("Hello\n")
"Hello"
Base.thisind ── 関数
thisind(s::AbstractString, i::Integer) -> Int

添え字 is の境界内なら、エンコーディングが符号単位 s[i] を含む文字が始まる添え字を返します。言い換えると、位置 i が文字の開始地点なら i が返り、位置 i が文字の開始地点でないなら開始地点を見つけるまで巻き戻った添え字を返します。i0 あるいは 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 String
  at index [4]
[...]

julia> thisind("α", -1)
ERROR: BoundsError: attempt to access String
  at index [-1]
[...]
Base.nextind ── 関数
nextind(str::AbstractString, i::Integer, n::Integer=1) -> Int
  • n == 1 のとき

    添え字 istr の境界内なら、エンコーディングが符号単位 str[i] より後ろで始まる最初の文字の添え字を返します。言い換えると、位置 i が文字の開始地点ならその次の文字の開始地点が返り、位置 i が文字の開始地点でないなら開始地点を見つけるまで先に進んだ添え字を返します。i0 のときは 1 を返し、i が境界内かつ ncodeunits(str) 以上のときは ncodeunits(str)+1 を返します。以上のどれにも当てはまらないときは BoundsError が送出されます。

  • n > 1 のとき

    n = 1nextindn 回適用するのに似た処理を行います。唯一の振る舞いが異なるのが n が大きいために途中で返り値が ncodeunits(str)+1 に達した場合で、この場合はそれ以降の nextind の適用が返り値を 1 ずつ増加させるものとみなされます。これは nextindncodeunits(str)+1 より大きい値を返す可能性があることを意味します。

  • n == 0 のとき

    istr に対する正当な添え字であるとき、または i0 である場合に限って i を返し、それ以外の場合は StringIndexError あるいは BoundsError を送出します。

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

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

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

julia> nextind("α", 1, 2)
4
Base.prevind ── 関数
prevind(str::AbstractString, i::Integer, n::Integer=1) -> Int
  • n == 1 のとき

    添え字 istr の境界内なら、エンコーディングが符号単位 str[i] より前で始まる最初の文字の添え字を返します。言い換えると、位置 i が文字の開始地点ならその次の文字の開始地点が返り、位置 i が文字の開始地点でないなら開始地点を見つけるまで前に進んだ添え字を返します。i1 のときは 0 を返し、incodeunits(str)+1 のときは lastindex(str) を返します。以上のどれにも当てはまらないときは BoundsError が送出されます。

  • n > 1 のとき

    n = 1previndn 回適用するのに似た処理を行います。唯一の振る舞いが異なるのが n が大きいために途中で返り値が 0 に達した場合で、この場合はそれ以降の nextind の適用が返り値を 1 ずつ減少させるものとみなされます。これは prevind が負の値を返す可能性があることを意味します。

  • n == 0 のとき

    istr に対する正当な添え字であるとき、または incodeunits(str)+1 である場合に限って i を返し、それ以外の場合は StringIndexError あるいは BoundsError を送出します。

julia> prevind("α", 3)
1

julia> prevind("α", 1)
0

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

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

julia> prevind("α", 2, 3)
-1
Base.Unicode.textwidth ── 関数
textwidth(c)

文字を出力するのに必要な横幅を返します。

julia> textwidth('α')
1

julia> textwidth('⛵')
2
textwidth(s::AbstractString)

文字列を出力するのに必要な横幅を返します。

julia> textwidth("March")
5
Base.isascii ── 関数
isascii(c::Union{AbstractChar,AbstractString}) -> Bool

文字 (あるいは文字列に含まれる全ての文字) が ASCII 文字集合に属するかどうかを判定します。

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false
Base.Unicode.iscntrl ── 関数
iscntrl(c::AbstractChar) -> Bool

文字が制御文字かどうかを判定します。制御文字とは Unicode ブロックのラテン 1 補助 (Latin-1 Supplement) に属する出力できない文字のことです。

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false
Base.Unicode.isdigit ── 関数
isdigit(c::AbstractChar) -> Bool

文字が十進数字 (0-9) かどうかを判定します。

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false
Base.Unicode.isletter ── 関数
isletter(c::AbstractChar) -> Bool

文字がレターかどうかを判定します。レターとは Unicode の一般カテゴリ Letter (L で始まるカテゴリ) に属する文字のことです。

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false
Base.Unicode.islowercase ── 関数
islowercase(c::AbstractChar) -> Bool

文字が小文字のレターかどうかを判定します。小文字のレターとは Unicode のカテゴリ Ll (Letter, lowercase) に属する文字のことです。

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false
Base.Unicode.isnumeric ── 関数
isnumeric(c::AbstractChar) -> Bool

文字が数字かどうかを判定します。数字とは Unicode の一般カテゴリ Number (N で始まるカテゴリ) に属する文字のことです。

この広いカテゴリには ¾ や ௰ のような文字が含まれることに注意してください。文字が十進数字 (0-9) かどうかを判定するには isdigit を使ってください。

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false
Base.Unicode.isprint ── 関数
isprint(c::AbstractChar) -> Bool

文字が印字可能かどうかを判定します。スペースは印字可能文字に含まれますが、制御文字は含まれません。

julia> isprint('\x01')
false

julia> isprint('A')
true
Base.Unicode.ispunct ── 関数
ispunct(c::AbstractChar) -> Bool

Unicode の一般カテゴリ Punctuation (P で始まるカテゴリ) に属するかどうかを判定します。

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true
Base.Unicode.isspace ── 関数
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
Base.Unicode.isuppercase ── 関数
isuppercase(c::AbstractChar) -> Bool

文字が大文字のレターかどうかを判定します。大文字とは Unicode カテゴリ Lu (Letter, Uppercase) もしくは Lt (Letter, Titlecase) に属する文字のことです。

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false
Base.Unicode.isxdigit ── 関数
isxdigit(c::AbstractChar) -> Bool

文字が正当な十六進文字かどうかを判定します。十六進リテラルの先頭に付く 0x で使われる x は十六進文字に含まれません。

julia> isxdigit('a')
true

julia> isxdigit('x')
false
Base.escape_string ── 関数
escape_string(str::AbstractString[, esc])::AbstractString
escape_string(io, str::AbstractString[, esc::])::Nothing

伝統的な C および Unicode エスケープシーケンスを使ったエスケープを行います。一つ目の形式はエスケープされた文字列を返し、二つ目の形式は結果を io に書き込みます。

バックスラッシュ \ は二つのバックスラッシュ \\ でエスケープされます。印字不可文字は標準の C エスケープコードでエスケープされ、ヌル文字は (曖昧でなければ) \0 になり、Unicode 符号位置は \u... になり、バイトは十六進数で \x... になります。

省略可能な引数 esc にはバックスラッシュでエスケープすべき追加の文字を指定します (一つ目の形式では指定しなくても " がデフォルトでエスケープされます)。

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

julia> escape_string("\xfe\xff") # 無効な UTF-8 文字列
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # \0 を使っても曖昧にならない
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # 曖昧になるので \0 は使えない
"ℵ\\x000"

参照:

この関数と逆の操作は unescape_string で行えます。

Base.unescape_string ── 関数
unescape_string(str::AbstractString, keep = ())::AbstractString
unescape_string(io, s::AbstractString, keep = ())::Nothing

伝統的な C および Unicode エスケープシーケンスを使ったアンエスケープを行います。一つ目の形式はアンエスケープされた文字列を返し、二つ目の形式は結果を io に書き込みます。

次のエスケープシーケンスが認識されます:

  • エスケープされたバックスラッシュ (\\)
  • エスケープされた二重引用符 (\")
  • 標準の C エスケープシーケンス (\a, \b, \t, \n, \v, \f, \r, \e)
  • Unicode BMP 符号位置 (\u に一つ以上四つ以下の十六進数が続くもの)
  • 任意の Unicode 符号位置 (\U に一つ以上八つ以下の十六進数が続くもの/最大値は 0010fffff)
  • 十六進数で表される単一バイト (\x に一つまたは二つの十六進数が続くもの)
  • 八進数で表される単一バイト (\ に一つ以上三つ以下の八進数が続くもの)

julia> unescape_string("aaa\\nbbb") # C エスケープシーケンス
"aaa\nbbb"

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

julia> unescape_string("\\101") # 八進数
"A"

julia> unescape_string("aaa \\g \\n", ['g']) # keep 引数の利用
"aaa \\g \n"

参照: