Strings
Core.AbstractString — Type
AbstractString 型は、Julia におけるすべての文字列実装のスーパータイプです。文字列は、AbstractChar 型で表される Unicode コードポイントの列をエンコードしたものです。Julia の文字列には、いくつかの前提があります。
文字列は、固定サイズの「コードユニット」でエンコードされます。
- コードユニットは
codeunit(s, i)で取り出せます。 - 最初のコードユニットのインデックスは
1です。 - 最後のコードユニットのインデックスは
ncodeunits(s)です。 1 ≤ i ≤ ncodeunits(s)が範囲内であるようなインデックスiは、すべて有効です。
- コードユニットは
文字列のインデックス付けは、これらのコードユニットを基準に行われます。
- 有効な文字列インデックス
iを指定してs[i]を呼び出すと、文字を取り出せます。 - 文字列内の各
AbstractCharは、1つ以上のコードユニットでエンコードされます。 AbstractCharの最初のコードユニットのインデックスだけが有効なインデックスです。AbstractCharのエンコードは、その前後にある内容に依存しません。- 文字列のエンコードは self-synchronizing です。つまり、
isvalid(s, i)は O(1) です。
- 有効な文字列インデックス
文字列からコードユニット、文字、部分文字列を取り出す関数の中には、範囲外または無効な文字列インデックスを渡すとエラーになるものがあります。codeunit(s, i) と s[i] もこれに該当します。一方、文字列インデックスの算術演算を行う関数は、より緩やかな方法でインデックスを扱います。範囲内では最も近い有効な文字列インデックスを返し、範囲外では、文字列の両側に無限個の文字が埋め込まれているかのように動作します。通常、これらの仮想的な埋め込み文字のコードユニット長は 1 ですが、文字列型によっては、実装に適した別の「仮想」文字サイズを選ぶこともできます(たとえば、部分文字列では、インデックス算術をビュー先の元の文字列に委ねる場合があります)。インデックス算術を目的とする thisind、nextind、prevind などが、こうした緩やかなインデックス処理を行う関数です。このモデルでは、範囲外のインデックスを中間値として使っても、文字の取得に使わない限りインデックス算術を行えます。そのため、境界条件に対処するコードを避けられることがよくあります。
関連項目: codeunit、ncodeunits、thisind、nextind、prevind。
Core.AbstractChar — Type
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) は、必要に応じて Char に変換したうえで、io によって決まるエンコーディングを生成します(組み込みの IO 型ではすべて UTF-8 です)。
これに対して、write(io, c) は typeof(c) に応じたエンコーディングを出力することがあります。また、read(io, typeof(c)) は write と同じエンコーディングを読み取る必要があります。新しい AbstractChar 型では、write と read をそれぞれ独自に実装する必要があります。
Core.Char — Type
Char(c::Union{Number,AbstractChar})Charは、Juliaで文字を表すデフォルトの32ビットAbstractChar型です。Charは、'x'のような文字リテラルに使われる型であり、Stringの要素型でもあります。
Stringに格納された任意のバイトストリームを損失なく表現するため、Charの値には、Unicodeコードポイントに変換できない情報が含まれる場合があります。そのようなCharをUInt32に変換すると、エラーが発生します。isvalid(c::Char)関数を使うと、cが有効なUnicode文字を表しているかどうかを調べられます。
Base.codepoint — Function
codepoint(c::AbstractChar)::Integer文字 c に対応する Unicode コードポイント(符号なし整数)を返します(c が有効な文字を表していない場合は、例外をスローします)。Char の場合、これは UInt32 の値ですが、Unicode の一部のみを表す AbstractChar 型では、異なるサイズの整数が返されることがあります(例:UInt8)。
Base.length — Method
length(s::AbstractString)::Int
length(s::AbstractString, i::Integer, j::Integer)::Int文字列sの、インデックスiからjまでの文字数を返します。
これは、iからjまでのコード単位インデックスのうち、有効な文字インデックスの数として計算されます。文字列引数が1つだけの場合は、文字列全体の文字数を計算します。引数にiとjを指定すると、文字列s内で有効なインデックスのうち、iからjまでの範囲にあるものの数を計算します。範囲内の値に加えて、iには範囲外の値ncodeunits(s) + 1を、jには範囲外の値0を指定できます。
関連項目: isvalid、ncodeunits、lastindex、thisind、nextind、prevind。
Examples
julia> length("jμΛIα")
5Base.sizeof — Method
sizeof(str::AbstractString)文字列 str のバイト単位でのサイズ。str のコード単位数に、str の1コード単位あたりのバイト数を掛けた値です。
Examples
julia> sizeof("")
0
julia> sizeof("∀")
3Base.:* — Method
*(s::Union{AbstractString, AbstractChar}, t::Union{AbstractString, AbstractChar}...)::AbstractString文字列や文字を連結し、適切な String または AnnotatedString を生成します。これは、引数に対して string または annotatedstring 関数を呼び出すのと同じです。組み込みの文字列型を連結すると、常に String 型の値が生成されます。ただし、その他の文字列型では、適切に異なる型の文字列を返す場合があります。
Examples
julia> "Hello " * "world"
"Hello world"
julia> 'j' * "ulia"
"julia"Base.string — Function
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。
Examples
julia> string("a", 1, true)
"a1true"string(n::Integer; base::Integer = 10, pad::Integer = 1)整数 n を、指定した base の文字列に変換します。必要に応じて、パディングする桁数も指定できます。
関連項目: digits、bitstring、count_zeros、および Printf 標準ライブラリ。
Examples
julia> string(5, base = 13, pad = 4)
"0005"
julia> string(-13, base = 5, pad = 4)
"-0023"
julia> using Printf
julia> @sprintf("%04i", 5)
"0005"
julia> @sprintf("%4i", 5)
" 5"Base.repeat — Method
repeat(s::AbstractString, r::Integer)文字列をr回繰り返します。これはs^rと記述できます。
^も参照してください。
Examples
julia> repeat("ha", 3)
"hahaha"Base.repeat — Method
repeat(c::AbstractChar, r::Integer)::String文字をr回繰り返します。これは、c^rを呼び出すことでも同様に実現できます。
Examples
julia> repeat('A', 3)
"AAA"Base.repr — Method
repr(x; context=nothing)2引数のshow(io, x)関数を使うと、任意の値を文字列表現にできます。この関数は、可能な場合にJuliaコードとして解析できる文字列を生成することを目指しています。つまり、eval(Meta.parse(repr(x))) == xが成り立つ必要があります。reprにメソッドを追加してはいけません。代わりに、showメソッドを定義してください。
省略可能なキーワード引数contextには、:key=>valueのペア、:key=>valueのペアのタプル、またはIOやIOContextのオブジェクトを指定できます。これらの属性は、showに渡されるI/Oストリームに使用されます。
repr(x)は通常、xの値をJuliaで入力する方法に似ています。人が読みやすい形式で「整形表示」したxを返すには、repr(MIME("text/plain"), x)も参照してください。これは、xのREPL表示に相当し、3引数のshow(io, mime, x)を使います。
Examples
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 — Method
String(s::AbstractString)既存のAbstractStringから新しいStringを作成します。
Base.SubString — Type
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)に変換します。
Examples
julia> SubString("abc", 1, 2)
"ab"
julia> SubString("abc", 1:2)
"ab"
julia> SubString("abc", 2)
"bc"Base.LazyString — Type
LazyString <: AbstractString文字列補間を遅延評価する表現です。実際の補間や文字列の構築が不要、または望ましくない状況(関数のエラー処理など)で文字列を構築する場合に便利です。
この型は、実行時の構築コストを抑えるよう設計されています。可能な限り多くの処理をマクロまたは後続の出力処理に委ねます。
Examples
julia> n = 5; str = LazyString("n is ", n)
"n is 5"@lazy_strも参照してください。
Extended help
Safety properties for concurrent programs
遅延文字列自体は、複数のJuliaタスクで出力しても並行処理上の問題を引き起こしません。ただし、キャプチャされた値に対するprintメソッドが、同期なしで呼び出された場合に並行処理上の問題を起こし得るなら、遅延文字列の出力によって問題が発生することがあります。また、キャプチャされた値に対するprintメソッドは複数回呼び出されることがありますが、返される結果は必ず1つだけです。
Base.@lazy_str — Macro
lazy"str"通常の文字列補間構文を使ってLazyStringを作成します。補間はLazyStringの構築時に評価されますが、文字列の出力は、文字列に初めてアクセスするまで遅延される点に注意してください。
並行プログラムにおける安全性については、LazyStringのドキュメントを参照してください。
Examples
julia> n = 5; str = lazy"n is $n"
"n is 5"
julia> typeof(str)
LazyStringBase.transcode — Function
transcode(T, src)Unicode エンコーディング間で文字列データを変換します。src は、UTF-XX コード単位の String または Vector{UIntXX} であり、XX は 8、16、または 32 です。T は戻り値のエンコーディングを指定します。String は(UTF-8 でエンコードされた)String を返し、UIntXX は UTF-XX データの Vector{UIntXX} を返します。(外部 C ライブラリで使用される wchar_t* 文字列を変換する場合は、整数型としてエイリアス Cwchar_t も使用できます。)
transcode 関数は、入力データを変換先のエンコーディングで妥当に表現できる限り成功します。UTF-XX エンコーディング間の変換では、不正な Unicode データであっても常に成功します。
現在サポートされているのは、UTF-8 との変換のみです。
Examples
julia> str = "αβγ"
"αβγ"
julia> transcode(UInt16, str)
3-element Vector{UInt16}:
0x03b1
0x03b2
0x03b3
julia> transcode(String, transcode(UInt16, str))
"αβγ"Base.unsafe_string — Function
unsafe_string(p::Ptr{T}, [length::Integer]) where {T<:Union{UInt16,UInt32,Cwchar_t}}
unsafe_string(p::Cwstring)UTF-16(T=UInt16)、UTF-32(T=UInt32)、またはシステム依存のwchar_t(T=Cwchar_tまたはCwstring)でエンコードされたC形式(NUL終端)の文字列について、そのアドレスから文字列をトランスコードし、UTF-8エンコーディングのStringを返します。transcodeと似ていますが、ポインターから直接読み取ります。(ポインターは、その後安全に解放できます。)length(エンコーディング単位で表したデータの長さ)を指定した場合、文字列をNUL終端にする必要はありません。
pが、指定された長さのデータ(またはNUL終端データ)を指す有効なメモリアドレスでない場合、この関数はクラッシュするため、「unsafe」とされています。
unsafe_string(p::Ptr{UInt8}, [length::Integer])
unsafe_string(p::Cstring)UTF-8でエンコードされたC形式(NUL終端)文字列のアドレスから文字列をコピーします(コピー後、ポインターは安全に解放できます)。length(データのバイト長)を指定した場合、文字列をNUL終端する必要はありません。
pが、指定された長さのデータを格納する有効なメモリアドレスでない場合、この関数はクラッシュするため、「unsafe」とされています。
Base.ncodeunits — Method
ncodeunits(s::AbstractString)::Int文字列内のコードユニット数を返します。この文字列にアクセスするために範囲内となるインデックスは、1 ≤ i ≤ ncodeunits(s)を満たす必要があります。ただし、範囲内のインデックスがすべて有効とは限りません。文字の先頭を指していない場合もありますが、codeunit(s,i)を呼び出すとコードユニット値が返されます。
Examples
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 — Function
codeunit(s::AbstractString, i::Integer)::Union{UInt8, UInt16, UInt32}文字列 s のインデックス i にあるコード単位の値を返します。なお、
codeunit(s, i) :: codeunit(s)つまり、codeunit(s, i) が返す値の型は、codeunit(s) が返す型です。
Examples
julia> a = codeunit("Hello", 2)
0x65
julia> typeof(a)
UInt8ncodeunits、checkbounds も参照してください。
codeunit(s::AbstractString)::Type{<:Union{UInt8, UInt16, UInt32}}指定された文字列オブジェクトのコード単位型を返します。ASCII、Latin-1、UTF-8でエンコードされた文字列の場合はUInt8、UCS-2およびUTF-16の場合はUInt16、UTF-32の場合はUInt32です。コード単位型はこの3種類に限られませんが、これらのいずれの単位も使わない、広く使われている文字列エンコーディングを思い浮かべるのは困難です。codeunit(s)は、sが空でない文字列の場合、typeof(codeunit(s,1))と同じです。
ncodeunitsも参照してください。
Base.codeunits — Function
codeunits(s::AbstractString)文字列のコード単位を含む、ベクトルに似たオブジェクトを取得します。デフォルトでは CodeUnits ラッパーを返しますが、必要に応じて、新しい文字列型に対して codeunits を定義できます。
Examples
julia> codeunits("Juλia")
6-element Base.CodeUnits{UInt8, String}:
0x4a
0x75
0xce
0xbb
0x69
0x61Base.ascii — Function
ascii(s::AbstractString)文字列をString型に変換し、ASCIIデータのみを含むことを確認します。ASCII以外のデータが含まれている場合は、最初の非ASCIIバイトの位置を示すArgumentErrorをスローします。
ASCII以外の文字をフィルタリングまたは置換するには、isascii述語も参照してください。
Examples
julia> ascii("abcdeγfgh")
ERROR: ArgumentError: invalid ASCII at index 6 in "abcdeγfgh"
Stacktrace:
[...]
julia> ascii("abcdefgh")
"abcdefgh"Base.Regex — Type
Regex(pattern[, flags]) <: AbstractPattern正規表現を表す型です。Regexオブジェクトを使うと、文字列をmatchで照合できます。
Regexオブジェクトは、@r_str文字列マクロを使って作成できます。pattern文字列に補間が必要な場合は、通常Regex(pattern[, flags])コンストラクターを使います。フラグの詳細については、文字列マクロのドキュメントを参照してください。
Base.@r_str — Macro
@r_str -> Regex補間やエスケープ処理を行わずに正規表現を作成します。たとえば r"^[a-z]*$" のように記述します(ただし、引用符 " はエスケープする必要があります)。終了引用符の後に1つ以上のフラグを指定すると、正規表現の動作を変更できます。
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 を参照してください。
Examples
julia> match(r"a+.*b+.*?d$"ism, "Goodbye,\nOh, angry,\nBad world\n")
RegexMatch("angry,\nBad world")この正規表現では、最初の3つのフラグが有効になっています。
Base.SubstitutionString — Type
SubstitutionString(substr) <: AbstractString正規表現による置換で使用するため、指定された文字列 substr を SubstitutionString として格納します。通常は @s_str マクロを使って構築します。
Examples
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}Base.@s_str — Macro
@s_str -> SubstitutionString正規表現による置換に使う置換文字列を作成します。文字列内の \N という形式の並びは、正規表現の N 番目のキャプチャグループを参照します。また、\g<groupname> は、名前が groupname の名前付きキャプチャグループを参照します。
Examples
julia> msg = "#Hello# from Julia";
julia> replace(msg, r"#(.+)# from (?<from>\w+)" => s"FROM: \g<from>; MESSAGE: \1")
"FROM: Julia; MESSAGE: Hello"Base.@raw_str — Macro
@raw_str -> String補間やエスケープ処理を行わない生文字列を作成します。ただし、引用符はエスケープする必要があります。バックスラッシュは、引用符の前に連続している場合に限り、引用符とほかのバックスラッシュの両方をエスケープします。したがって、引用符の前に2n個のバックスラッシュがある場合は、n個のバックスラッシュとリテラルの終端を表し、2n+1個ある場合は、n個のバックスラッシュに続く引用符文字を表します。
Examples
julia> println(raw"\ $x")
\ $x
julia> println(raw"\"")
"
julia> println(raw"\\\"")
\"
julia> println(raw"\\x \\\"")
\\x \"Base.@b_str — Macro
@b_str文字列構文を使って、不変のバイト(UInt8)ベクトルを作成します。
Examples
julia> v = b"12\x01\x02"
4-element Base.CodeUnits{UInt8, String}:
0x31
0x32
0x01
0x02
julia> v[2]
0x32Base.takestring! — Function
takestring!(io::IOBuffer)::Stringio の内容を String として返し、バッファを初期状態にリセットします。IOBuffer から文字列を作成するために String(take!(io)) を呼び出すよりも、この方法が推奨されます。
Examples
julia> io = IOBuffer();
julia> write(io, [0x61, 0x62, 0x63]);
julia> s = takestring!(io)
"abc"
julia> isempty(take!(io)) # io is now empty
truetakestring!(x)::AbstractStringxの内容から文字列を作成し、xを空にします。
Examples
julia> v = [0x61, 0x62, 0x63];
julia> s = takestring!(v)
"abc"
julia> isempty(v)
trueBase.Docs.@html_str — Macro
@html_str -> Docs.HTMLリテラル文字列からHTMLオブジェクトを作成します。
Examples
julia> html"Julia"
HTML{String}("Julia")Base.Docs.@text_str — Macro
@text_str -> Docs.Textリテラル文字列からTextオブジェクトを作成します。
Examples
julia> text"Julia"
JuliaBase.isvalid — Method
isvalid(value)::Bool指定された値がその型として有効な場合は、trueを返します。現在、型はAbstractChar、String、またはSubString{String}のいずれかです。
Examples
julia> isvalid(Char(0xd800))
false
julia> isvalid(SubString(String(UInt8[0xfe,0x80,0x80,0x80,0x80,0x80]),1,2))
false
julia> isvalid(Char(0xd799))
trueBase.isvalid — Method
isvalid(T, value)::Bool指定された値がその型として有効な場合、trueを返します。型は現在、AbstractCharまたはStringのいずれかです。AbstractCharの値は、AbstractChar型またはUInt32型にできます。Stringの値は、その型、SubString{String}、Vector{UInt8}、またはそれらの連続した部分配列にできます。
Examples
julia> isvalid(Char, 0xd800)
false
julia> isvalid(String, SubString("thisisvalid",1,5))
true
julia> isvalid(Char, 0xd799)
trueBase.isvalid — Method
isvalid(s::AbstractString, i::Integer)::Bool指定されたインデックスが、s 内の文字のエンコーディングの開始位置かどうかを示す述語です。isvalid(s, i) が true の場合、s[i] はそのインデックスからエンコーディングが始まる文字を返します。false の場合、i が範囲内にあるかどうかに応じて、s[i] は無効なインデックスエラーまたは範囲外エラーを発生させます。isvalid(s, i) を O(1) の関数にするには、s のエンコーディングが self-synchronizing である必要があります。これは Julia の汎用文字列サポートにおける基本的な前提です。
関連項目: getindex、iterate、thisind、nextind、prevind、length。
Examples
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:
[...]Base.match — Function
match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])正規表現 r の最初の一致を s から検索し、一致した場合はその一致を含む RegexMatch オブジェクトを返します。一致しなかった場合は何も返しません。省略可能な idx 引数には、検索を開始するインデックスを指定します。一致した部分文字列は m.match にアクセスして取得でき、キャプチャされたシーケンスは m.captures にアクセスして取得できます。結果の RegexMatch オブジェクトを使って、ほかのコレクションを構築できます。例: Tuple(m)、NamedTuple(m)。
Examples
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
trueSee also
Base.eachmatch — Function
eachmatch(r::Regex, s::AbstractString; overlap::Bool=false)正規表現 r に一致するすべての箇所を s から検索し、一致した箇所を反復処理できるイテレーターを返します。overlap が true の場合、一致する文字列は元の文字列内でインデックスが重複してもかまいません。それ以外の場合は、異なる文字範囲に含まれている必要があります。
Examples
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")See also
Base.RegexMatch — Type
RegexMatch <: AbstractMatch文字列内で見つかったRegexへの単一のマッチを表す型です。通常はmatch関数によって作成されます。
matchフィールドには、マッチした文字列全体の部分文字列が格納されます。capturesフィールドには、各キャプチャグループの部分文字列が番号をインデックスとして格納されます。キャプチャグループ名でインデックスを指定するには、例に示すように、マッチオブジェクト全体をインデックス指定します。マッチの開始位置はoffsetフィールドに格納されます。offsetsフィールドには、各キャプチャグループの開始位置が格納されます。キャプチャされなかったグループは0で示されます。
この型は、Regexのキャプチャグループを反復処理するイテレータとして使用でき、各グループでキャプチャされた部分文字列を順に返します。そのため、マッチのキャプチャを分割代入できます。グループがキャプチャされなかった場合は、部分文字列の代わりにnothingが返されます。
RegexMatchオブジェクトを受け取るメソッドは、iterate、length、eltype、keys、haskey、getindexに対して定義されています。キーには、キャプチャグループの名前または番号を指定します。詳しくはkeysを参照してください。
Tuple(m)、NamedTuple(m)、Dict(m)を使うと、RegexMatchオブジェクトから、より柔軟なコレクション型を構築できます。
Examples
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"
julia> Dict(m)
Dict{Any, Union{Nothing, SubString{String}}} with 3 entries:
"hour" => "11"
3 => nothing
"minute" => "30"Base.keys — Method
keys(m::RegexMatch)::Vector基になる正規表現のすべてのキャプチャグループについて、キーのベクトルを返します。キャプチャグループがマッチしなかった場合でも、そのキーは含まれます。つまり、idx は、m[idx] == nothing であっても戻り値に含まれます。
名前のないキャプチャグループのキーは、インデックスに対応する整数です。名前付きキャプチャグループのキーは文字列です。
Examples
julia> keys(match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30"))
3-element Vector{Any}:
"hour"
"minute"
3Base.isless — Method
isless(a::AbstractString, b::AbstractString)::Bool文字列 a が、文字列 b よりアルファベット順(厳密には、Unicodeコードポイントによる辞書順)で前に来るかどうかを判定します。
Examples
julia> isless("a", "b")
true
julia> isless("β", "α")
false
julia> isless("a", "a")
falseBase.:(==) — Method
==(a::AbstractString, b::AbstractString)::Bool2つの文字列が、文字ごと(厳密には Unicode コードポイントごと)に等しいかどうかを判定します。いずれかの文字列が AnnotatedString の場合は、文字列のプロパティも一致している必要があります。
Examples
julia> "abc" == "abc"
true
julia> "abc" == "αβγ"
falseBase.cmp — Method
cmp(a::AbstractString, b::AbstractString)::Int2つの文字列を比較します。両方の文字列の長さが同じで、各インデックスの文字も同じ場合は、0を返します。aがbの接頭辞である場合、またはaがアルファベット順でbより前に来る場合は、-1を返します。bがaの接頭辞である場合、またはbがアルファベット順(厳密にはUnicodeコードポイント順)でaより前に来る場合は、1を返します。
Examples
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", "β")
-1Base.ltruncate — Function
ltruncate(str::AbstractString, maxwidth::Integer, replacement::Union{AbstractString,AbstractChar} = '…')str を、textwidth による推定で最大 maxwidth 列に切り詰めます。必要に応じて先頭の文字を replacement に置き換えます。デフォルトの置換文字列は「…」です。
Examples
julia> s = ltruncate("🍕🍕 I love 🍕", 10)
"…I love 🍕"
julia> textwidth(s)
10
julia> ltruncate("foo", 3)
"foo"Base.rtruncate — Function
rtruncate(str::AbstractString, maxwidth::Integer, replacement::Union{AbstractString,AbstractChar} = '…')str を、(textwidth による推定で)最大 maxwidth 列に切り詰めます。必要に応じて末尾の文字を replacement に置き換えます。デフォルトの置換文字列は「…」です。
Examples
julia> s = rtruncate("🍕🍕 I love 🍕", 10)
"🍕🍕 I lo…"
julia> textwidth(s)
10
julia> rtruncate("foo", 3)
"foo"Base.ctruncate — Function
ctruncate(str::AbstractString, maxwidth::Integer, replacement::Union{AbstractString,AbstractChar} = '…'; prefer_left::Bool = true)strを最大maxwidth列(textwidthによる推定)に切り詰めます。必要に応じて中央の文字をreplacementに置き換えます。デフォルトの置換文字列は「…」です。デフォルトでは左側の文字を優先して残しますが、prefer_leftをfalseに設定すると変更できます。
Examples
julia> s = ctruncate("🍕🍕 I love 🍕", 10)
"🍕🍕 …e 🍕"
julia> textwidth(s)
10
julia> ctruncate("foo", 3)
"foo"Base.findfirst — Method
findfirst(pattern::AbstractString, string::AbstractString)
findfirst(pattern::AbstractPattern, string::String)string 内で pattern が最初に出現する位置を検索します。findnext(pattern, string, firstindex(s)) と同等です。
Examples
julia> findfirst("z", "Hello to the world") # returns nothing, but not printed in the REPL
julia> findfirst("Julia", "JuliaLang")
1:5Base.findnext — Method
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 です。
Examples
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:9Base.findnext — Method
findnext(ch::AbstractChar, string::AbstractString, start::Integer)位置 start から検索を開始し、string 内で文字 ch が次に現れる位置を探します。
Examples
julia> findnext('z', "Hello to the world", 1) === nothing
true
julia> findnext('o', "Hello to the world", 6)
8Base.findlast — Method
findlast(pattern::AbstractString, string::AbstractString)pattern が string 内に最後に現れる位置を検索します。findprev(pattern, string, lastindex(string)) と同等です。
Examples
julia> findlast("o", "Hello to the world")
15:15
julia> findfirst("Julia", "JuliaLang")
1:5Base.findlast — Method
findlast(ch::AbstractChar, string::AbstractString)ch の中で、string に最後に現れる文字を検索します。
Examples
julia> findlast('p', "happy")
4
julia> findlast('z', "happy") === nothing
trueBase.findprev — Method
findprev(pattern::AbstractString, string::AbstractString, start::Integer)位置 start を起点に、string 内で pattern が直前に出現する箇所を検索します。
戻り値は、一致するシーケンスが見つかったインデックスの範囲であり、s[findprev(x, s, i)] == x を満たします。
string[start:stop] == "substring" および stop <= i を満たす findprev("substring", string, i) == start:stop。一致しない場合は nothing を返します。
Examples
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:5Base.occursin — Function
occursin(haystack)引数がhaystackに含まれているかを判定する関数を作成します。つまり、needle -> occursin(needle, haystack)と同等の関数です。
返される関数の型はBase.Fix2{typeof(occursin)}です。
Examples
julia> search_f = occursin("JuliaLang is a programming language");
julia> search_f("JuliaLang")
true
julia> search_f("Python")
falseoccursin(needle::Union{AbstractString,AbstractPattern,AbstractChar}, haystack::AbstractString)第1引数が第2引数の部分文字列かどうかを判定します。needleが正規表現の場合は、haystackに一致する部分が含まれているかどうかを判定します。
Examples
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")
falseBase.reverse — Method
reverse(s::AbstractString)::AbstractString文字列を反転します。厳密には、この関数は文字列内のコードポイントを反転します。主な用途は、文字列を逆順に処理すること、特に正規表現による逆方向検索です。reverseindも参照してください。これは、s内のインデックスをreverse(s)内のインデックスに変換し、その逆も行います。また、コードポイントではなく、ユーザーに見える「文字」(書記素)を扱うには、モジュールUnicodeのgraphemesを参照してください。コピーを作成せずに逆順で反復するには、Iterators.reverseも参照してください。独自の文字列型では、reverse関数を実装する必要があります。通常は、同じ型とエンコーディングの文字列を返すようにしてください。異なるエンコーディングの文字列を返す場合は、s[reverseind(s,i)] == reverse(s)[i]を満たすため、その文字列型に対してreverseindもオーバーライドする必要があります。
Examples
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"Base.replace — Method
replace([io::IO], s::AbstractString, pat=>r, [pat2=>r2, ...]; [count::Integer])s 内で指定されたパターン pat を検索し、一致する各箇所を r に置き換えます。count が指定されている場合、置換する箇所は最大 count 個です。pat には、単一の文字、文字のベクトルまたは集合、文字列、正規表現を指定できます。r が関数の場合、一致する各箇所は r(s) に置き換えられます。ここで s は、pat が AbstractPattern または AbstractString の場合は一致した部分文字列、pat が AbstractChar または AbstractChar のコレクションの場合は一致した文字です。pat が正規表現で、r が SubstitutionString の場合、r 内のキャプチャグループへの参照は、対応する一致テキストに置き換えられます。string から pat に一致する箇所を削除するには、r に空の String("")を設定します。
戻り値は、置換後の新しい文字列です。io::IO 引数が指定されている場合は、代わりに変換後の文字列を io に書き込み、io を返します。(たとえば、IOBuffer と組み合わせることで、事前に確保したバッファ配列をその場で再利用できます。)
複数のパターンを指定できます。入力文字列は先頭(左)から末尾(右)まで一度だけ走査され、各部分文字列には最初に一致した置換が適用されます。入力文字列の同じ位置から始まる部分文字列に複数のパターンが一致する場合は、指定された引数の順に置換が適用されます。したがって、各文字に適用されるパターンは1つだけであり、パターンは入力テキストにのみ適用され、置換後のテキストには適用されません。
Examples
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"Base.eachsplit — Function
eachsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)strを区切り文字dlmで分割し、部分文字列のイテレータを返します。dlmには、findnextの第1引数で使用できる形式(文字列、正規表現、関数)のほか、単一の文字または文字のコレクションを指定できます。
dlmを省略した場合、デフォルト値はisspaceです。
省略可能なキーワード引数は次のとおりです。
limit: 結果の最大サイズ。limit=0を指定すると上限なし(デフォルト)keepempty: 結果に空のフィールドを含めるかどうか。デフォルトは、dlm引数を指定しない場合はfalse、dlm引数を指定した場合はtrueです。
関連項目: split。
Examples
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"Base.eachrsplit — Function
eachrsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachrsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)SubString のイテレーターを返します。これは str を区切り文字 dlm で分割して得られるもので、右から左の順に返されます。dlm には、findprev の第1引数で使用できる形式(文字列、単一の文字、関数)のほか、文字のコレクションも指定できます。
dlm を省略した場合は isspace が使われ、keepempty の既定値は false です。
省略可能なキーワード引数は次のとおりです。
limit > 0の場合、残りの文字列を分割せずに返すまでの分割回数をlimit - 1回までに制限します。limit < 1は分割回数を制限しないことを意味します(既定)。keepempty: イテレーション時に空のフィールドを返すかどうか。dlm引数を指定しない場合の既定値はfalse、dlm引数を指定した場合の既定値はtrueです。
split、rsplit、eachsplit とは異なり、この関数は入力内の部分文字列を、出現順とは逆の右から左の順にイテレーションすることに注意してください。
Examples
julia> a = "Ma.r.ch";
julia> collect(eachrsplit(a, ".")) == ["ch", "r", "Ma"]
true
julia> collect(eachrsplit(a, "."; limit=2)) == ["ch", "Ma.r"]
trueBase.split — Function
split(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
split(str::AbstractString; limit::Integer=0, keepempty::Bool=false)strを、区切り文字dlmが現れる位置で分割し、部分文字列の配列を返します。dlmには、findnextの第1引数で使用できる形式(文字列、正規表現、関数)のほか、単一の文字または文字のコレクションを指定できます。
dlmを省略した場合、デフォルトはisspaceです。
省略可能なキーワード引数は次のとおりです。
limit: 結果の最大サイズ。limit=0は上限なしを意味します(デフォルト)。keepempty: 空のフィールドを結果に含めるかどうか。dlm引数を指定しない場合のデフォルトはfalse、dlm引数を指定した場合のデフォルトはtrueです。
Examples
julia> a = "Ma.rch"
"Ma.rch"
julia> split(a, ".")
2-element Vector{SubString{String}}:
"Ma"
"rch"Base.rsplit — Function
rsplit(s::AbstractString; limit::Integer=0, keepempty::Bool=false)
rsplit(s::AbstractString, chars; limit::Integer=0, keepempty::Bool=true)splitと同様ですが、文字列の末尾から開始します。
Examples
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"Base.strip — Function
strip([pred=isspace,] str::AbstractString)::SubString
strip(str::AbstractString, chars)::SubStringstr の先頭および末尾から、chars で指定した文字、または関数 pred が true を返す文字を削除します。
デフォルトでは、先頭および末尾の空白文字と区切り文字が削除されます。詳しくは、isspace を参照してください。
省略可能な chars 引数で、削除する文字を指定します。単一の文字、文字のベクトル、または文字の集合を指定できます。
Examples
julia> strip("{3, 5}\n", ['{', '}', '\n'])
"3, 5"Base.lstrip — Function
lstrip([pred=isspace,] str::AbstractString)::SubString
lstrip(str::AbstractString, chars)::SubStringstr の先頭から、chars で指定した文字、または関数 pred が true を返す文字を削除します。
デフォルトでは、先頭の空白文字と区切り文字を削除します。詳しくは isspace を参照してください。
省略可能な chars 引数で、削除する文字を指定します。単一の文字、または文字のベクトルや集合を指定できます。
Examples
julia> a = lpad("March", 20)
" March"
julia> lstrip(a)
"March"Base.rstrip — Function
rstrip([pred=isspace,] str::AbstractString)::SubString
rstrip(str::AbstractString, chars)::SubStringstr の末尾から、chars で指定した文字、または関数 pred が true を返す文字を削除します。
デフォルトでは、末尾の空白文字と区切り文字を削除します。詳しくは isspace を参照してください。
省略可能な chars 引数で、削除する文字を指定します。単一の文字、または文字のベクトルや集合を指定できます。
Examples
julia> a = rpad("March", 20)
"March "
julia> rstrip(a)
"March"Base.startswith — Function
startswith(s::AbstractString, prefix::Regex)sが正規表現パターンprefixで始まる場合、trueを返します。
startswithはアンカーを正規表現にコンパイルするのではなく、match_optionとしてPCREに渡します。コンパイル時間を償却できる場合、occursin(r"^...", s)はstartswith(s, r"...")より高速です。
Examples
julia> startswith("JuliaLang", r"Julia|Romeo")
truestartswith(prefix)引数が prefix で始まるかどうかを判定する関数を作成します。つまり、y -> startswith(y, prefix) と同等の関数です。
返される関数の型は Base.Fix2{typeof(startswith)} で、これを使って特化メソッドを実装できます。
Examples
julia> startswith("Julia")("JuliaLang")
true
julia> startswith("Julia")("Ends with Julia")
falsestartswith(io::IO, prefix::Union{AbstractString,Base.Chars})IO オブジェクトが、文字列、文字、または文字のタプル・ベクター・集合のいずれかである接頭辞で始まるかどうかを確認します。peek も参照してください。
startswith(s::AbstractString, prefix::Union{AbstractString,Base.Chars})s が prefix(文字列、文字、または文字のタプル・ベクター・集合)で始まる場合、true を返します。prefix が文字のタプル・ベクター・集合の場合は、s の最初の文字がその集合に含まれるかどうかを判定します。
Examples
julia> startswith("JuliaLang", "Julia")
trueBase.endswith — Function
endswith(s::AbstractString, suffix::Regex)s が正規表現パターン suffix で終わる場合、true を返します。
endswith はアンカーを正規表現にコンパイルせず、代わりにアンカーを match_option として PCRE に渡します。コンパイル時間を償却できる場合、occursin(r"...$", s) は endswith(s, r"...") より高速です。
関連項目: occursin、startswith、match
Examples
julia> endswith("JuliaLang", r"Lang|Roberts")
trueendswith(suffix)引数が suffix で終わるかどうかを判定する関数を作成します。つまり、y -> endswith(y, suffix) と同等の関数です。
返される関数の型は Base.Fix2{typeof(endswith)} であり、これを使って特化メソッドを実装できます。
Examples
julia> endswith("Julia")("Ends with Julia")
true
julia> endswith("Julia")("JuliaLang")
falseendswith(s::AbstractString, suffix::Union{AbstractString,Base.Chars})s が suffix で終わる場合、true を返します。ここで、末尾として指定できるのは文字列、文字、または文字のタプル・ベクトル・集合です。suffix が文字のタプル・ベクトル・集合の場合は、s の最後の文字がその集合に含まれるかどうかを判定します。
startswith、contains も参照してください。
Examples
julia> endswith("Sunday", "day")
trueBase.contains — Function
contains(needle)引数にneedleが含まれているかどうかを判定する関数、つまりhaystack -> contains(haystack, needle)と同等の関数を作成します。
返される関数の型はBase.Fix2{typeof(contains)}であり、これを使って特化したメソッドを実装できます。
contains(haystack::AbstractString, needle)haystackにneedleが含まれている場合は、trueを返します。これはoccursin(needle, haystack)と同じですが、startswith(haystack, needle)およびendswith(haystack, needle)との一貫性を保つために用意されています。
Examples
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")
falseBase.first — Method
first(s::AbstractString, n::Integer)sの先頭からn文字を取り出した文字列を取得します。
Examples
julia> first("∀ϵ≠0: ϵ²>0", 0)
""
julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"
julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"Base.Unicode.uppercase — Function
uppercase(s::AbstractString)すべての文字を大文字に変換したsを返してください。
lowercase、titlecase、uppercasefirstも参照してください。
Examples
julia> uppercase("Julia")
"JULIA"uppercase(c::AbstractChar)cを大文字に変換します。
Examples
julia> uppercase('a')
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)
julia> uppercase('ê')
'Ê': Unicode U+00CA (category Lu: Letter, uppercase)Base.Unicode.lowercase — Function
lowercase(s::AbstractString)すべての文字を小文字に変換した s を返します。
こちらも参照してください:uppercase、titlecase、lowercasefirst。
Examples
julia> lowercase("STRINGS AND THINGS")
"strings and things"lowercase(c::AbstractChar)cを小文字に変換します。
Examples
julia> lowercase('A')
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
julia> lowercase('Ö')
'ö': Unicode U+00F6 (category Ll: Letter, lowercase)Base.Unicode.titlecase — Function
titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true)::Strings の各単語の先頭文字を大文字にします。strict が true の場合は、それ以外の文字をすべて小文字に変換し、そうでない場合は変更しません。デフォルトでは、新しい書記素の先頭にある文字以外のすべての文字が単語の区切りとみなされます。単語の区切りとみなす文字を指定するには、述語を wordsep キーワード引数に渡します。s の先頭文字だけを大文字にするには、uppercasefirst も参照してください。
uppercase、lowercase、uppercasefirst も参照してください。
Examples
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"titlecase(c::AbstractChar)c をタイトルケースに変換します。二重音字の場合は大文字とは異なることがあります。以下の例を参照してください。
Examples
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)Base.Unicode.uppercasefirst — Function
uppercasefirst(s::AbstractString)::String最初の文字を大文字(厳密には Unicode の「タイトルケース」)に変換した s を返します。titlecase も参照してください。これは s の各単語の最初の文字を大文字にします。
lowercasefirst、uppercase、lowercase、titlecase も参照してください。
Examples
julia> uppercasefirst("python")
"Python"Base.Unicode.lowercasefirst — Function
lowercasefirst(s::AbstractString)先頭の文字を小文字に変換した s を返します。
関連項目: uppercasefirst、uppercase、lowercase、titlecase。
Examples
julia> lowercasefirst("Julia")
"julia"Base.join — Function
join([io::IO,] iterator [, delim [, last]])iteratorを1つの文字列に連結します。隣接する項目の間には、指定された区切り文字があれば挿入します。lastが指定されている場合、最後の2項目の間にはdelimの代わりにそれを使用します。iteratorの各項目は、print(io::IOBuffer, x)によって文字列に変換されます。ioが指定されている場合、結果は返されず、ioに書き込まれます。戻り値はStringです。
Examples
julia> join(["apples", "bananas", "pineapples"], ", ", " and ")
"apples, bananas and pineapples"
julia> join([1,2,3,4,5])
"12345"Base.chop — Function
chop(s::AbstractString; head::Integer = 0, tail::Integer = 1)s から先頭の head 文字と末尾の tail 文字を削除します。chop(s) を呼び出すと、s の末尾の文字が削除されます。length(s) より多くの文字を削除するよう指定した場合は、空文字列が返されます。
関連項目: chomp、startswith、first。
Examples
julia> a = "March"
"March"
julia> chop(a)
"Marc"
julia> chop(a, head = 1, tail = 2)
"ar"
julia> chop(a, head = 5, tail = 5)
""Base.chopprefix — Function
chopprefix(s::AbstractString, prefix::Union{AbstractString,Regex,AbstractChar})::SubStrings から prefix を取り除きます。s が prefix で始まらない場合は、s と等しい文字列が返されます。
関連項目: chopsuffix。
Examples
julia> chopprefix("Hamburger", "Ham")
"burger"
julia> chopprefix("Hamburger", "hotdog")
"Hamburger"Base.chopsuffix — Function
chopsuffix(s::AbstractString, suffix::Union{AbstractString,Regex,AbstractChar})::SubStrings から suffix を取り除きます。s が suffix で終わっていない場合は、s と等しい文字列が返されます。
関連項目: chopprefix。
Examples
julia> chopsuffix("Hamburger", "er")
"Hamburg"
julia> chopsuffix("Hamburger", "hotdog")
"Hamburger"Base.chomp — Function
chomp(s::AbstractString)::SubString文字列の末尾にある改行を1つ(つまり「\r\n」または「\n」)削除します。
関連項目:chop。
Examples
julia> chomp("Hello\n")
"Hello"
julia> chomp("World\r\n")
"World"
julia> chomp("Julia\r\n\n")
"Julia\r\n"Base.thisind — Function
thisind(s::AbstractString, i::Integer)::Inti が s の範囲内にある場合、エンコーディングのコード単位 i が属する文字の開始位置のインデックスを返します。つまり、i が文字の開始位置であれば i を返します。i が文字の開始位置でなければ、文字の開始位置まで戻ってそのインデックスを返します。i が 0 または ncodeunits(s)+1 と等しい場合は、i を返します。それ以外の場合は BoundsError をスローします。
Examples
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]
[...]Base.nextind — Method
nextind(str::AbstractString, i::Integer, n::Integer=1)::Intケース
n == 1iがstrの範囲内にある場合、インデックスiより後からエンコーディングが始まる文字の開始位置のインデックスを返します。つまり、iが文字の開始位置であれば、次の文字の開始位置を返します。iが文字の開始位置でない場合は、次の文字の開始位置まで進み、そのインデックスを返します。iが0と等しい場合は、1を返します。iが範囲内にあり、lastindex(str)以上の場合は、ncodeunits(str)+1を返します。それ以外の場合はBoundsErrorをスローします。ケース
n > 1n==1に対してnをnextind回適用した場合と同様に動作します。唯一の違いは、nが非常に大きく、nextindを適用するとncodeunits(str)+1に達する場合、残りの各反復で返される値が1ずつ増加することです。したがって、この場合、nextindはncodeunits(str)+1より大きい値を返すことがあります。ケース
n == 0iがstrの有効なインデックスであるか、0と等しい場合に限り、iを返します。それ以外の場合は、StringIndexErrorまたはBoundsErrorがスローされます。
Examples
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)
4Base.prevind — Method
prevind(str::AbstractString, i::Integer, n::Integer=1)::Intケース
n == 1iがstrの範囲内にある場合、インデックスiより前にエンコーディングが始まる文字の開始位置のインデックスを返します。つまり、iが文字の開始位置なら、その前の文字の開始位置を返します。iが文字の開始位置でない場合は、文字の開始位置まで巻き戻して、そのインデックスを返します。iが1と等しい場合は、0を返します。iがncodeunits(str)+1と等しい場合は、lastindex(str)を返します。それ以外の場合は、BoundsErrorをスローします。ケース
n > 1n==1に対して、previndをn回適用した場合と同様に動作します。唯一の違いは、nが大きすぎて、previndを適用すると0に達する場合、残りの各反復で返される値が1ずつ減少することです。この場合、previndは負の値を返すことがあります。ケース
n == 0iがstrの有効なインデックスであるか、ncodeunits(str)+1と等しい場合に限り、iを返します。それ以外の場合は、StringIndexErrorまたはBoundsErrorがスローされます。
Examples
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)
-1Base.Unicode.textwidth — Function
textwidth(s::AbstractString)文字列を表示するのに必要な列数を返します。
Examples
julia> textwidth("March")
5textwidth(c)文字を表示するのに必要な列数を指定します。
Examples
julia> textwidth('α')
1
julia> textwidth('⛵')
2Base.isascii — Function
isascii(cu::AbstractVector{CU}) where {CU <: Integer}::Boolベクトル内のすべての値がASCII文字集合(0x00〜0x7f)に属するかどうかをテストします。この関数は、高速なASCII判定を必要とする他の文字列実装での使用を想定しています。
isascii(c::Union{AbstractChar,AbstractString})::Bool文字がASCII文字セットに属するかどうか、または文字列のすべての要素がASCII文字セットに属するかどうかを判定します。
Examples
julia> isascii('a')
true
julia> isascii('α')
false
julia> isascii("abc")
true
julia> isascii("αβγ")
falseたとえば、isasciiは、非ASCII文字を削除または置換するための述語関数として、filterまたはreplaceに渡せます。
julia> filter(isascii, "abcdeγfgh") # discard non-ASCII chars
"abcdefgh"
julia> replace("abcdeγfgh", !isascii=>' ') # replace non-ASCII chars with spaces
"abcde fgh"Base.Unicode.iscntrl — Function
iscntrl(c::AbstractChar)::Bool文字が制御文字かどうかを判定します。制御文字とは、Unicode の Latin-1 サブセットに含まれる非表示文字です。
Examples
julia> iscntrl('\x01')
true
julia> iscntrl('a')
falseBase.Unicode.isdigit — Function
isdigit(c::AbstractChar)::Bool文字が ASCII の十進数字かどうかを判定します(0-9)。
関連項目:isletter。
Examples
julia> isdigit('❤')
false
julia> isdigit('9')
true
julia> isdigit('α')
falseBase.Unicode.isletter — Function
isletter(c::AbstractChar)::Bool文字が文字(letter)かどうかを判定します。Unicodeの一般カテゴリでLetterに分類される文字、つまりカテゴリコードが「L」で始まる文字は、文字と判定されます。
関連項目: isdigit。
Examples
julia> isletter('❤')
false
julia> isletter('α')
true
julia> isletter('9')
falseBase.Unicode.islowercase — Function
islowercase(c::AbstractChar)::Bool文字が小文字かどうかを判定します(Unicode 標準の Lowercase 派生プロパティに基づきます)。
isuppercase も参照してください。
Examples
julia> islowercase('α')
true
julia> islowercase('Γ')
false
julia> islowercase('❤')
falseBase.Unicode.isnumeric — Function
isnumeric(c::AbstractChar)::Bool文字が数値かどうかを判定します。Unicode の一般カテゴリ「Number」に属する文字、つまりカテゴリコードが「N」で始まる文字は、数値と判定されます。
この広いカテゴリには、¾ や ௰ などの文字も含まれます。文字が 0 から 9 までの十進数字かどうかを調べるには、isdigit を使ってください。
Examples
julia> isnumeric('௰')
true
julia> isnumeric('9')
true
julia> isnumeric('α')
false
julia> isnumeric('❤')
falseBase.Unicode.isprint — Function
isprint(c::AbstractChar)::Bool制御文字ではなく、空白を含む印字可能な文字かどうかを判定します。
Examples
julia> isprint('\x01')
false
julia> isprint('A')
trueBase.Unicode.ispunct — Function
ispunct(c::AbstractChar)::Bool文字が Unicode の一般カテゴリ「句読点」に属するかどうかを判定します。つまり、カテゴリコードが「P」で始まる文字かどうかを調べます。
Examples
julia> ispunct('α')
false
julia> ispunct('=')
false
julia> ispunct('/')
true
julia> ispunct(';')
trueBase.Unicode.isspace — Function
isspace(c::AbstractChar)::Bool文字が空白文字かどうかを判定します。ASCII文字の '\t'、'\n'、'\v'、'\f'、'\r'、' '、Latin-1文字 U+0085、およびUnicodeカテゴリ Zs の文字が対象です。
Examples
julia> isspace('\n')
true
julia> isspace('\r')
true
julia> isspace(' ')
true
julia> isspace('\x20')
trueBase.Unicode.isuppercase — Function
isuppercase(c::AbstractChar)::Bool文字が大文字かどうかを判定します(Unicode 標準の Uppercase 派生プロパティに基づきます)。
islowercase も参照してください。
Examples
julia> isuppercase('γ')
false
julia> isuppercase('Γ')
true
julia> isuppercase('❤')
falseBase.Unicode.isxdigit — Function
isxdigit(c::AbstractChar)::Bool文字が有効な16進数の数字かどうかを判定します。x(標準の0xプレフィックスなど)は含まれないことに注意してください。
Examples
julia> isxdigit('a')
true
julia> isxdigit('x')
falseBase.escape_string — Function
escape_string(str::AbstractString[, esc]; keep=(), ascii=false, fullhex=false)::AbstractString
escape_string(io, str::AbstractString[, esc]; keep=())::Nothing従来のC形式およびUnicode形式のエスケープシーケンスを一般的にエスケープします。1つ目の形式はエスケープ後の文字列を返し、2つ目の形式は結果をioに出力します。
バックスラッシュ(\)は、二重のバックスラッシュ("\\")にエスケープされます。印字できない文字は、標準的なC形式のエスケープコード、NULの場合は"\0"(曖昧さがない場合)、Unicodeコードポイント("\u"プレフィックス)、または16進数("\x"プレフィックス)でエスケープされます。
省略可能なesc引数では、先頭にバックスラッシュを付けてエスケープする追加の文字を指定します(1つ目の形式では、"もデフォルトでエスケープされます)。
keep引数では、そのまま保持する文字の集合を指定します。ただし、ここではescが優先されます。
ascii引数をtrueに設定すると、ASCII以外のすべての文字がエスケープされます。デフォルトのascii=falseでは、印字可能なUnicode文字はそのまま出力されます。(keepはasciiより優先されます。)
fullhex引数をtrueに設定すると、すべての\uエスケープは4桁の16進数で、\Uエスケープは8桁の16進数で出力されます。デフォルト(fullhex=false)では、可能な場合は先頭のゼロを省略し、桁数を少なくして出力します。
逆の操作については、unescape_stringも参照してください。
Examples
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"Base.escape_raw_string — Function
escape_raw_string(s::AbstractString, delim='"')::AbstractString
escape_raw_string(io, s::AbstractString, delim='"')raw文字列リテラルの解析で使われる方法で、文字列をエスケープします。入力文字列 s(指定されている場合は delim)に含まれる各二重引用符(")について、この関数はその直前にあるバックスラッシュ(\)の数 n を数え、その数を n から 2n+1 に増やします(n = 0 の場合も同様です)。また、文字列末尾に連続するバックスラッシュも2倍にします。
このエスケープ規則は、raw文字列やその他の非標準文字列リテラルで使われます。(また、Microsoft C/C++コンパイラのランタイムがコマンドライン文字列を解析して argv[] 配列に格納する際に必要とするエスケープ規則でもあります。)
関連項目: Base.escape_string()。
Base.unescape_string — Function
unescape_string(str::AbstractString, keep = ())::AbstractString
unescape_string(io, s::AbstractString, keep = ())::Nothing従来の C および Unicode のエスケープシーケンスを一般的にアンエスケープします。1つ目の形式はエスケープされた文字列を返し、2つ目の形式は結果を io に出力します。引数 keep には、バックスラッシュとともにそのまま保持する文字の集合を指定します。
次のエスケープシーケンスを認識します。
- エスケープされたバックスラッシュ(
\\) - エスケープされた二重引用符(
\") - 標準的な C のエスケープシーケンス(
\a、\b、\t、\n、\v、\f、\r、\e) - Unicode BMP コードポイント(
\uの後に1~4桁の16進数を指定) - すべての Unicode コードポイント(
\Uの後に1~8桁の16進数を指定。最大値 = 0010ffff) - 16進バイト(
\xの後に1~2桁の16進数を指定) - 8進バイト(
\の後に1~3桁の8進数を指定)
escape_string も参照してください。
Examples
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"AnnotatedStrings
Base.AnnotatedString — Type
AnnotatedString{S <: AbstractString} <: AbstractString注釈付き領域を含む、メタデータ付きの文字列です。
より具体的には、任意のAbstractStringを包むシンプルなラッパーで、ラップされた文字列の領域にラベル付きの値を注釈として付与できます。
C
┌──────┸─────────┐
"this is an example annotated string"
└──┰────────┼─────┘ │
A └─────┰─────────┘
B上の図は、3つの範囲に注釈(ラベルはA、B、C)が付与されたAnnotatedStringを示しています。各注釈は、ラベル(Symbol)と値(Any)を持ちます。この3つの情報は、@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}として保持されます。
ラベルは一意である必要はありません。同じ領域に、同じラベルの注釈を複数付与できます。
一般に、AnnotatedString向けに書かれたコードでは、次の性質を維持する必要があります。
- 注釈が適用される文字
- 各文字に注釈が適用される順序
AnnotatedStringの具体的な用途によっては、さらに意味が加わる場合があります。
この規則から、同じラベルと値を持つ注釈が隣接して連続している場合、それらは結合した範囲に付与された単一の注釈と同等になります。
AnnotatedChar、annotatedstring、annotations、annotate!も参照してください。
Constructors
AnnotatedString(s::S<:AbstractString) -> AnnotatedString{S}
AnnotatedString(s::S<:AbstractString, annotations::Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}})AnnotatedStringはannotatedstringを使って作成することもできます。これはstringとよく似ていますが、引数に含まれる注釈を保持します。
Examples
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"Base.AnnotatedChar — Type
AnnotatedChar{S <: AbstractChar} <: AbstractChar注釈付きの Char です。
より具体的には、任意の AbstractChar を包む単純なラッパーで、包まれた文字とともに、任意のラベル付き注釈のリスト(@NamedTuple{label::Symbol, value})を保持します。
関連項目:AnnotatedString、annotatedstring、annotations、annotate!。
Constructors
AnnotatedChar(s::S) -> AnnotatedChar{S}
AnnotatedChar(s::S, annotations::Vector{@NamedTuple{label::Symbol, value}})Examples
julia> AnnotatedChar('j', [(:label, 1)])
'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)Base.annotatedstring — Function
annotatedstring(values...)AnnotatedString を、任意の数の values から、それらの print 表現を使って作成します。
これは string と同様に動作しますが、存在する注釈(AnnotatedString または AnnotatedChar の値として表されるもの)を保持します。
AnnotatedString および AnnotatedChar も参照してください。
Examples
julia> annotatedstring("now an AnnotatedString")
"now an AnnotatedString"
julia> annotatedstring(AnnotatedString("annotated", [(1:9, :label, 1)]), ", and unannotated")
"annotated, and unannotated"Base.annotations — Function
annotations(chr::AnnotatedChar)::Vector{@NamedTuple{label::Symbol, value}}chr のすべてのアノテーションを、アノテーションのペアを要素とするベクトルとして取得します。
annotations(str::Union{AnnotatedString, SubString{AnnotatedString}},
[position::Union{Integer, UnitRange}]) ->
Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}}strに適用されるすべての注釈を取得します。positionが指定された場合は、positionと重なる注釈のみが返されます。
注釈は、適用対象の領域とともに、領域と注釈のタプルからなるベクトルとして渡されます。
AnnotatedStringに記載されているセマンティクスに従い、返される注釈の順序は、適用された順序と一致します。
関連項目: annotate!。
Base.annotate! — Function
annotate!(char::AnnotatedChar, label::Symbol, value::Any)charに、ラベル付きの値(label, value)を注釈として付けます。
annotate!(str::AnnotatedString, [range::UnitRange{Int}], label::Symbol, value)
annotate!(str::SubString{AnnotatedString}, [range::UnitRange{Int}], label::Symbol, value)str(または文字列全体)に、ラベル付きの値 (label, value) を付けて、range に注釈を付けます。既存の label 注釈を削除するには、nothing の値を指定します。
str に注釈を適用する順序は意味を持ちます。詳しくは AnnotatedString を参照してください。