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。

source
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 をそれぞれ独自に実装する必要があります。

source
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文字を表しているかどうかを調べられます。

source
Base.codepoint — Function
codepoint(c::AbstractChar)::Integer

文字 c に対応する Unicode コードポイント(符号なし整数)を返します(c が有効な文字を表していない場合は、例外をスローします)。Char の場合、これは UInt32 の値ですが、Unicode の一部のみを表す AbstractChar 型では、異なるサイズの整数が返されることがあります(例:UInt8)。

source
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を指定できます。

Note

この操作の時間計算量は、一般に線形です。値をその場で数えるため、文字列内のバイト数または文字数に比例した時間がかかります。これは、定数時間で実行される配列向けのメソッドとは異なります。

関連項目: isvalid、ncodeunits、lastindex、thisind、nextind、prevind。

Examples

julia> length("jμΛIα")
5
source
Base.sizeof — Method
sizeof(str::AbstractString)

文字列 str のバイト単位でのサイズ。str のコード単位数に、str の1コード単位あたりのバイト数を掛けた値です。

Examples

julia> sizeof("")
0

julia> sizeof("∀")
3
source
Base.:* — 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"
source
Base.:^ — Method
^(s::Union{AbstractString,AbstractChar}, n::Integer)::AbstractString

文字列または文字をn回繰り返します。これはrepeat(s, n)とも書けます。

repeatも参照してください。

Examples

julia> "Test "^3
"Test Test Test "
source
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"
source
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"
source
Base.repeat — Method
repeat(s::AbstractString, r::Integer)

文字列をr回繰り返します。これはs^rと記述できます。

^も参照してください。

Examples

julia> repeat("ha", 3)
"hahaha"
source
Base.repeat — Method
repeat(c::AbstractChar, r::Integer)::String

文字をr回繰り返します。これは、c^rを呼び出すことでも同様に実現できます。

Examples

julia> repeat('A', 3)
"AAA"
source
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)を使います。

Julia 1.7

キーワードcontextにタプルを渡すには、Julia 1.7以降が必要です。

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"
source
Core.String — Method
String(s::AbstractString)

既存のAbstractStringから新しいStringを作成します。

source
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"
source
Base.LazyString — Type
LazyString <: AbstractString

文字列補間を遅延評価する表現です。実際の補間や文字列の構築が不要、または望ましくない状況(関数のエラー処理など)で文字列を構築する場合に便利です。

この型は、実行時の構築コストを抑えるよう設計されています。可能な限り多くの処理をマクロまたは後続の出力処理に委ねます。

Examples

julia> n = 5; str = LazyString("n is ", n)
"n is 5"

@lazy_strも参照してください。

Julia 1.8

LazyStringを使用するには、Julia 1.8以降が必要です。

Extended help

Safety properties for concurrent programs

遅延文字列自体は、複数のJuliaタスクで出力しても並行処理上の問題を引き起こしません。ただし、キャプチャされた値に対するprintメソッドが、同期なしで呼び出された場合に並行処理上の問題を起こし得るなら、遅延文字列の出力によって問題が発生することがあります。また、キャプチャされた値に対するprintメソッドは複数回呼び出されることがありますが、返される結果は必ず1つだけです。

Julia 1.9

LazyStringは、Julia 1.9以降では上記の意味で安全です。

source
Base.@lazy_str — Macro
lazy"str"

通常の文字列補間構文を使ってLazyStringを作成します。補間はLazyStringの構築時に評価されますが、文字列の出力は、文字列に初めてアクセスするまで遅延される点に注意してください。

並行プログラムにおける安全性については、LazyStringのドキュメントを参照してください。

Examples

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

julia> typeof(str)
LazyString
Julia 1.8

lazy"str"にはJulia 1.8以降が必要です。

source
Base.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))
"αβγ"
source
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」とされています。

source
unsafe_string(p::Ptr{UInt8}, [length::Integer])
unsafe_string(p::Cstring)

UTF-8でエンコードされたC形式(NUL終端)文字列のアドレスから文字列をコピーします(コピー後、ポインターは安全に解放できます)。length(データのバイト長)を指定した場合、文字列をNUL終端する必要はありません。

pが、指定された長さのデータを格納する有効なメモリアドレスでない場合、この関数はクラッシュするため、「unsafe」とされています。

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

source
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)
UInt8

ncodeunits、checkbounds も参照してください。

source
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も参照してください。

source
Base.codeunits — Function
codeunits(s::AbstractString)

文字列のコード単位を含む、ベクトルに似たオブジェクトを取得します。デフォルトでは CodeUnits ラッパーを返しますが、必要に応じて、新しい文字列型に対して codeunits を定義できます。

Examples

julia> codeunits("Juλia")
6-element Base.CodeUnits{UInt8, String}:
 0x4a
 0x75
 0xce
 0xbb
 0x69
 0x61
source
Base.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"
source
Base.Regex — Type
Regex(pattern[, flags]) <: AbstractPattern

正規表現を表す型です。Regexオブジェクトを使うと、文字列をmatchで照合できます。

Regexオブジェクトは、@r_str文字列マクロを使って作成できます。pattern文字列に補間が必要な場合は、通常Regex(pattern[, flags])コンストラクターを使います。フラグの詳細については、文字列マクロのドキュメントを参照してください。

Note

補間される変数をエスケープするには、\Qと\Eを使います(例:Regex("\\Q$x\\E"))

source
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つのフラグが有効になっています。

source
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}
source
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"
source
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 \"
source
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]
0x32
source
Base.takestring! — Function
takestring!(io::IOBuffer)::String

io の内容を 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
true
Julia 1.13

この関数を使用するには、Julia 1.13 以降が必要です。

source
takestring!(x)::AbstractString

xの内容から文字列を作成し、xを空にします。

Examples

julia> v = [0x61, 0x62, 0x63];

julia> s = takestring!(v)
"abc"

julia> isempty(v)
true
Julia 1.13

この関数を使用するには、Julia 1.13以降が必要です。

source
Base.Docs.@html_str — Macro
@html_str -> Docs.HTML

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

Examples

julia> html"Julia"
HTML{String}("Julia")
source
Base.Docs.@text_str — Macro
@text_str -> Docs.Text

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

Examples

julia> text"Julia"
Julia
source
Base.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))
true
source
Base.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)
true
Julia 1.6

部分配列の値への対応はJulia 1.6で追加されました。

source
Base.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:
[...]
source
Base.match — Function
match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])

正規表現 r の最初の一致を s から検索し、一致した場合はその一致を含む RegexMatch オブジェクトを返します。一致しなかった場合は何も返しません。省略可能な idx 引数には、検索を開始するインデックスを指定します。一致した部分文字列は m.match にアクセスして取得でき、キャプチャされたシーケンスは m.captures にアクセスして取得できます。結果の RegexMatch オブジェクトを使って、ほかのコレクションを構築できます。例: Tuple(m)、NamedTuple(m)。

Julia 1.11

NamedTuple と Dict の構築には Julia 1.11 が必要です

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
true

See also

eachmatch、occursin、findfirst

source
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

match, findall, count

source
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オブジェクトから、より柔軟なコレクション型を構築できます。

Julia 1.11

RegexMatchesからNamedTupleやDictを構築するには、Julia 1.11が必要です。

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"
source
Base.keys — Method
keys(m::RegexMatch)::Vector

基になる正規表現のすべてのキャプチャグループについて、キーのベクトルを返します。キャプチャグループがマッチしなかった場合でも、そのキーは含まれます。つまり、idx は、m[idx] == nothing であっても戻り値に含まれます。

名前のないキャプチャグループのキーは、インデックスに対応する整数です。名前付きキャプチャグループのキーは文字列です。

Julia 1.7

このメソッドは Julia 1.7 で追加されました

Examples

julia> keys(match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30"))
3-element Vector{Any}:
  "hour"
  "minute"
 3
source
Base.isless — Method
isless(a::AbstractString, b::AbstractString)::Bool

文字列 a が、文字列 b よりアルファベット順(厳密には、Unicodeコードポイントによる辞書順)で前に来るかどうかを判定します。

Examples

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

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

julia> isless("a", "a")
false
source
Base.:(==) — Method
==(a::AbstractString, b::AbstractString)::Bool

2つの文字列が、文字ごと(厳密には Unicode コードポイントごと)に等しいかどうかを判定します。いずれかの文字列が AnnotatedString の場合は、文字列のプロパティも一致している必要があります。

Examples

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false
source
Base.cmp — Method
cmp(a::AbstractString, b::AbstractString)::Int

2つの文字列を比較します。両方の文字列の長さが同じで、各インデックスの文字も同じ場合は、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", "β")
-1
source
Base.lpad — Function
lpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ')::String

sを文字列に変換し、左側をpで埋めて、n文字(textwidth)にします。sがすでにn文字の場合は、同じ文字列が返されます。デフォルトでは、空白で埋めます。

Examples

julia> lpad("March", 10)
"     March"
Julia 1.7

Julia 1.7では、この関数は生の文字(コードポイント)の数ではなく、textwidthを使うように変更されました。

source
Base.rpad — Function
rpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ')::String

sを文字列に変換し、右側をpで埋めて、n文字(textwidth)にします。sがすでにn文字の場合は、同じ文字列を返します。デフォルトでは、空白で埋めます。

Examples

julia> rpad("March", 20)
"March               "
Julia 1.7

Julia 1.7では、この関数は生の文字(コードポイント)の数ではなく、textwidthを使うように変更されました。

source
Base.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"
Julia 1.12

この関数は Julia 1.12 で追加されました。

rtruncate および ctruncate も参照してください。

source
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"
Julia 1.12

この関数は Julia 1.12 で追加されました。

ltruncate および ctruncate も参照してください。

source
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"
Julia 1.12

この関数はJulia 1.12で追加されました。

関連項目:ltruncateおよびrtruncate。

source
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:5
source
Base.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:9
source
Base.findnext — Method
findnext(ch::AbstractChar, string::AbstractString, start::Integer)

位置 start から検索を開始し、string 内で文字 ch が次に現れる位置を探します。

Julia 1.3

このメソッドを使用するには、Julia 1.3 以降が必要です。

Examples

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

julia> findnext('o', "Hello to the world", 6)
8
source
Base.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:5
source
Base.findlast — Method
findlast(ch::AbstractChar, string::AbstractString)

ch の中で、string に最後に現れる文字を検索します。

Julia 1.3

このメソッドを使用するには、Julia 1.3 以降が必要です。

Examples

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

julia> findlast('z', "happy") === nothing
true
source
Base.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:5
source
Base.occursin — Function
occursin(haystack)

引数がhaystackに含まれているかを判定する関数を作成します。つまり、needle -> occursin(needle, haystack)と同等の関数です。

返される関数の型はBase.Fix2{typeof(occursin)}です。

Julia 1.6

このメソッドを使用するには、Julia 1.6以降が必要です。

Examples

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

julia> search_f("JuliaLang")
true

julia> search_f("Python")
false
source
occursin(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")
false

contains

source
Base.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"
Note

以下の例は、システムによって表示が異なる場合があります。コメントは、想定される表示方法を示しています。

結合文字によって、予想外の結果になることがあります。

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"
source
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つだけであり、パターンは入力テキストにのみ適用され、置換後のテキストには適用されません。

Julia 1.7

複数のパターンを使用するには、バージョン1.7以降が必要です。

Julia 1.10

io::IO 引数を使用するには、バージョン1.10以降が必要です。

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

Julia 1.8

eachsplit関数を使用するには、Julia 1.8以降が必要です。

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"
source
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 とは異なり、この関数は入力内の部分文字列を、出現順とは逆の右から左の順にイテレーションすることに注意してください。

関連項目: eachsplit、rsplit。

Julia 1.11

この関数を使用するには、Julia 1.11 以降が必要です。

Examples

julia> a = "Ma.r.ch";

julia> collect(eachrsplit(a, ".")) == ["ch", "r", "Ma"]
true

julia> collect(eachrsplit(a, "."; limit=2)) == ["ch", "Ma.r"]
true
source
Base.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です。

関連項目: rsplit、eachsplit。

Examples

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

julia> split(a, ".")
2-element Vector{SubString{String}}:
 "Ma"
 "rch"
source
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"
source
Base.strip — Function
strip([pred=isspace,] str::AbstractString)::SubString
strip(str::AbstractString, chars)::SubString

str の先頭および末尾から、chars で指定した文字、または関数 pred が true を返す文字を削除します。

デフォルトでは、先頭および末尾の空白文字と区切り文字が削除されます。詳しくは、isspace を参照してください。

省略可能な chars 引数で、削除する文字を指定します。単一の文字、文字のベクトル、または文字の集合を指定できます。

lstrip および rstrip も参照してください。

Julia 1.2

述語関数を受け取るメソッドを使用するには、Julia 1.2 以降が必要です。

Examples

julia> strip("{3, 5}\n", ['{', '}', '\n'])
"3, 5"
source
Base.lstrip — Function
lstrip([pred=isspace,] str::AbstractString)::SubString
lstrip(str::AbstractString, chars)::SubString

str の先頭から、chars で指定した文字、または関数 pred が true を返す文字を削除します。

デフォルトでは、先頭の空白文字と区切り文字を削除します。詳しくは isspace を参照してください。

省略可能な chars 引数で、削除する文字を指定します。単一の文字、または文字のベクトルや集合を指定できます。

strip および rstrip も参照してください。

Examples

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

julia> lstrip(a)
"March"
source
Base.rstrip — Function
rstrip([pred=isspace,] str::AbstractString)::SubString
rstrip(str::AbstractString, chars)::SubString

str の末尾から、chars で指定した文字、または関数 pred が true を返す文字を削除します。

デフォルトでは、末尾の空白文字と区切り文字を削除します。詳しくは isspace を参照してください。

省略可能な chars 引数で、削除する文字を指定します。単一の文字、または文字のベクトルや集合を指定できます。

strip および lstrip も参照してください。

Examples

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

julia> rstrip(a)
"March"
source
Base.startswith — Function
startswith(s::AbstractString, prefix::Regex)

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

Note

startswithはアンカーを正規表現にコンパイルするのではなく、match_optionとしてPCREに渡します。コンパイル時間を償却できる場合、occursin(r"^...", s)はstartswith(s, r"...")より高速です。

関連項目: occursin、endswith、match

Julia 1.2

このメソッドを使用するには、Julia 1.2以降が必要です。

Examples

julia> startswith("JuliaLang", r"Julia|Romeo")
true
source
startswith(prefix)

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

返される関数の型は Base.Fix2{typeof(startswith)} で、これを使って特化メソッドを実装できます。

Julia 1.5

引数が1つの startswith(prefix) を使うには、Julia 1.5以降が必要です。

Examples

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

julia> startswith("Julia")("Ends with Julia")
false
source
startswith(io::IO, prefix::Union{AbstractString,Base.Chars})

IO オブジェクトが、文字列、文字、または文字のタプル・ベクター・集合のいずれかである接頭辞で始まるかどうかを確認します。peek も参照してください。

source
startswith(s::AbstractString, prefix::Union{AbstractString,Base.Chars})

s が prefix(文字列、文字、または文字のタプル・ベクター・集合)で始まる場合、true を返します。prefix が文字のタプル・ベクター・集合の場合は、s の最初の文字がその集合に含まれるかどうかを判定します。

関連項目: endswith、contains。

Examples

julia> startswith("JuliaLang", "Julia")
true
source
Base.endswith — Function
endswith(s::AbstractString, suffix::Regex)

s が正規表現パターン suffix で終わる場合、true を返します。

Note

endswith はアンカーを正規表現にコンパイルせず、代わりにアンカーを match_option として PCRE に渡します。コンパイル時間を償却できる場合、occursin(r"...$", s) は endswith(s, r"...") より高速です。

関連項目: occursin、startswith、match

Julia 1.2

このメソッドを使用するには、Julia 1.2 以降が必要です。

Examples

julia> endswith("JuliaLang", r"Lang|Roberts")
true
source
endswith(suffix)

引数が suffix で終わるかどうかを判定する関数を作成します。つまり、y -> endswith(y, suffix) と同等の関数です。

返される関数の型は Base.Fix2{typeof(endswith)} であり、これを使って特化メソッドを実装できます。

Julia 1.5

引数が1つの endswith(suffix) は、Julia 1.5以降で使用できます。

Examples

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

julia> endswith("Julia")("JuliaLang")
false
source
endswith(s::AbstractString, suffix::Union{AbstractString,Base.Chars})

s が suffix で終わる場合、true を返します。ここで、末尾として指定できるのは文字列、文字、または文字のタプル・ベクトル・集合です。suffix が文字のタプル・ベクトル・集合の場合は、s の最後の文字がその集合に含まれるかどうかを判定します。

startswith、contains も参照してください。

Examples

julia> endswith("Sunday", "day")
true
source
Base.contains — Function
contains(needle)

引数にneedleが含まれているかどうかを判定する関数、つまりhaystack -> contains(haystack, needle)と同等の関数を作成します。

返される関数の型はBase.Fix2{typeof(contains)}であり、これを使って特化したメソッドを実装できます。

source
contains(haystack::AbstractString, needle)

haystackにneedleが含まれている場合は、trueを返します。これはoccursin(needle, haystack)と同じですが、startswith(haystack, needle)およびendswith(haystack, needle)との一貫性を保つために用意されています。

関連項目:occursin、in、issubset。

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")
false
Julia 1.5

contains関数を使用するには、Julia 1.5以降が必要です。

source
Base.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)
"∀ϵ≠"
source
Base.last — Method
last(s::AbstractString, n::Integer)

s の末尾 n 文字からなる文字列を取得します。

Examples

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

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

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"
source
Base.Unicode.uppercase — Function
uppercase(s::AbstractString)

すべての文字を大文字に変換したsを返してください。

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

Examples

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

cを大文字に変換します。

lowercase、titlecaseも参照してください。

Examples

julia> uppercase('a')
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)

julia> uppercase('ê')
'Ê': Unicode U+00CA (category Lu: Letter, uppercase)
source
Base.Unicode.lowercase — Function
lowercase(s::AbstractString)

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

こちらも参照してください:uppercase、titlecase、lowercasefirst。

Examples

julia> lowercase("STRINGS AND THINGS")
"strings and things"
source
lowercase(c::AbstractChar)

cを小文字に変換します。

uppercase、titlecaseも参照してください。

Examples

julia> lowercase('A')
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> lowercase('Ö')
'ö': Unicode U+00F6 (category Ll: Letter, lowercase)
source
Base.Unicode.titlecase — Function
titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true)::String

s の各単語の先頭文字を大文字にします。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"
source
titlecase(c::AbstractChar)

c をタイトルケースに変換します。二重音字の場合は大文字とは異なることがあります。以下の例を参照してください。

関連項目: uppercase、lowercase。

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)
source
Base.Unicode.uppercasefirst — Function
uppercasefirst(s::AbstractString)::String

最初の文字を大文字(厳密には Unicode の「タイトルケース」)に変換した s を返します。titlecase も参照してください。これは s の各単語の最初の文字を大文字にします。

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

Examples

julia> uppercasefirst("python")
"Python"
source
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"
source
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)
""
source
Base.chopprefix — Function
chopprefix(s::AbstractString, prefix::Union{AbstractString,Regex,AbstractChar})::SubString

s から prefix を取り除きます。s が prefix で始まらない場合は、s と等しい文字列が返されます。

関連項目: chopsuffix。

Julia 1.8

この関数は Julia 1.8 以降で利用できます。

Julia 1.13

AbstractChar の prefix を受け取るメソッドは Julia 1.13 以降で利用できます。

Examples

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

julia> chopprefix("Hamburger", "hotdog")
"Hamburger"
source
Base.chopsuffix — Function
chopsuffix(s::AbstractString, suffix::Union{AbstractString,Regex,AbstractChar})::SubString

s から suffix を取り除きます。s が suffix で終わっていない場合は、s と等しい文字列が返されます。

関連項目: chopprefix。

Julia 1.8

この関数は Julia 1.8 以降で利用できます。

Julia 1.13

AbstractChar のサフィックスを受け取るメソッドは Julia 1.13 以降で利用できます。

Examples

julia> chopsuffix("Hamburger", "er")
"Hamburg"

julia> chopsuffix("Hamburger", "hotdog")
"Hamburger"
source
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"
source
Base.thisind — Function
thisind(s::AbstractString, i::Integer)::Int

i が 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]
[...]
source
Base.nextind — Method
nextind(str::AbstractString, i::Integer, n::Integer=1)::Int
  • ケース n == 1

    i が str の範囲内にある場合、インデックス i より後からエンコーディングが始まる文字の開始位置のインデックスを返します。つまり、i が文字の開始位置であれば、次の文字の開始位置を返します。i が文字の開始位置でない場合は、次の文字の開始位置まで進み、そのインデックスを返します。i が 0 と等しい場合は、1 を返します。i が範囲内にあり、lastindex(str) 以上の場合は、ncodeunits(str)+1 を返します。それ以外の場合は BoundsError をスローします。

  • ケース n > 1

    n==1 に対して n を nextind 回適用した場合と同様に動作します。唯一の違いは、n が非常に大きく、nextind を適用すると ncodeunits(str)+1 に達する場合、残りの各反復で返される値が 1 ずつ増加することです。したがって、この場合、nextind は ncodeunits(str)+1 より大きい値を返すことがあります。

  • ケース n == 0

    i が 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)
4
source
Base.prevind — Method
prevind(str::AbstractString, i::Integer, n::Integer=1)::Int
  • ケース n == 1

    i が str の範囲内にある場合、インデックス 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 がスローされます。

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)
-1
source
Base.Unicode.textwidth — Function
textwidth(s::AbstractString)

文字列を表示するのに必要な列数を返します。

Examples

julia> textwidth("March")
5
source
textwidth(c)

文字を表示するのに必要な列数を指定します。

Examples

julia> textwidth('α')
1

julia> textwidth('⛵')
2
source
Base.isascii — Function
isascii(cu::AbstractVector{CU}) where {CU <: Integer}::Bool

ベクトル内のすべての値がASCII文字集合(0x00〜0x7f)に属するかどうかをテストします。この関数は、高速なASCII判定を必要とする他の文字列実装での使用を想定しています。

source
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"
source
Base.Unicode.iscntrl — Function
iscntrl(c::AbstractChar)::Bool

文字が制御文字かどうかを判定します。制御文字とは、Unicode の Latin-1 サブセットに含まれる非表示文字です。

Examples

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false
source
Base.Unicode.isdigit — Function
isdigit(c::AbstractChar)::Bool

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

関連項目:isletter。

Examples

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false
source
Base.Unicode.isletter — Function
isletter(c::AbstractChar)::Bool

文字が文字(letter)かどうかを判定します。Unicodeの一般カテゴリでLetterに分類される文字、つまりカテゴリコードが「L」で始まる文字は、文字と判定されます。

関連項目: isdigit。

Examples

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false
source
Base.Unicode.islowercase — Function
islowercase(c::AbstractChar)::Bool

文字が小文字かどうかを判定します(Unicode 標準の Lowercase 派生プロパティに基づきます)。

isuppercase も参照してください。

Examples

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false
source
Base.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('❤')
false
source
Base.Unicode.isprint — Function
isprint(c::AbstractChar)::Bool

制御文字ではなく、空白を含む印字可能な文字かどうかを判定します。

Examples

julia> isprint('\x01')
false

julia> isprint('A')
true
source
Base.Unicode.ispunct — Function
ispunct(c::AbstractChar)::Bool

文字が Unicode の一般カテゴリ「句読点」に属するかどうかを判定します。つまり、カテゴリコードが「P」で始まる文字かどうかを調べます。

Note

この動作は、C の ispunct 関数とは異なります。

Examples

julia> ispunct('α')
false

julia> ispunct('=')
false

julia> ispunct('/')
true

julia> ispunct(';')
true
source
Base.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')
true
source
Base.Unicode.isuppercase — Function
isuppercase(c::AbstractChar)::Bool

文字が大文字かどうかを判定します(Unicode 標準の Uppercase 派生プロパティに基づきます)。

islowercase も参照してください。

Examples

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false
source
Base.Unicode.isxdigit — Function
isxdigit(c::AbstractChar)::Bool

文字が有効な16進数の数字かどうかを判定します。x(標準の0xプレフィックスなど)は含まれないことに注意してください。

Examples

julia> isxdigit('a')
true

julia> isxdigit('x')
false
source
Base.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も参照してください。

Julia 1.7

keep引数はJulia 1.7以降で使用できます。

Julia 1.12

ascii引数とfullhex引数にはJulia 1.12が必要です。

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"
source
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()。

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

AnnotatedStrings

Note

AnnotatedStrings の API は実験的なものとみなされており、Julia のバージョン間で変更される可能性があります。

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"
source
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)
source
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"
source
Base.annotations — Function
annotations(chr::AnnotatedChar)::Vector{@NamedTuple{label::Symbol, value}}

chr のすべてのアノテーションを、アノテーションのペアを要素とするベクトルとして取得します。

source
annotations(str::Union{AnnotatedString, SubString{AnnotatedString}},
            [position::Union{Integer, UnitRange}]) ->
    Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}}

strに適用されるすべての注釈を取得します。positionが指定された場合は、positionと重なる注釈のみが返されます。

注釈は、適用対象の領域とともに、領域と注釈のタプルからなるベクトルとして渡されます。

AnnotatedStringに記載されているセマンティクスに従い、返される注釈の順序は、適用された順序と一致します。

関連項目: annotate!。

source
Base.annotate! — Function
annotate!(char::AnnotatedChar, label::Symbol, value::Any)

charに、ラベル付きの値(label, value)を注釈として付けます。

source
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 を参照してください。

source