Strings

AbstractString型は、Juliaにおけるすべての文字列実装のスーパークラスです。文字列は、AbstractChar型によって表されるUnicodeコードポイントのシーケンスのエンコーディングです。Juliaは文字列に関していくつかの仮定をしています：

• 文字列は固定サイズの「コードユニット」に基づいてエンコードされています。

  • コードユニットはcodeunit(s, i)で抽出できます。
  • 最初のコードユニットのインデックスは1です。
  • 最後のコードユニットのインデックスはncodeunits(s)です。
  • 1 ≤ i ≤ ncodeunits(s)を満たす任意のインデックスiは有効です。

• 文字列のインデックスはこれらのコードユニットに基づいて行われます：

  • 文字は有効な文字列インデックスiを使ってs[i]で抽出されます。
  • 文字列内の各AbstractCharは1つ以上のコードユニットでエンコードされています。
  • AbstractCharの最初のコードユニットのインデックスのみが有効なインデックスです。
  • AbstractCharのエンコーディングは、その前後に何があるかに依存しません。
  • 文字列のエンコーディングは自己同期しており、すなわちisvalid(s, i)はO(1)です。

コードユニット、文字、または部分文字列を文字列から抽出するいくつかの文字列関数は、範囲外または無効な文字列インデックスを渡すとエラーになります。これにはcodeunit(s, i)やs[i]が含まれます。文字列インデックスの算術を行う関数は、インデックスに対してより緩やかなアプローチを取り、範囲内の場合は最も近い有効な文字列インデックスを返し、範囲外の場合は文字列の両側に無限の数の文字がパディングされているかのように振る舞います。通常、これらの想像上のパディング文字はコードユニットの長さが1ですが、文字列型はその実装に応じて異なる「想像上の」文字サイズを選択することがあります（例：部分文字列は、提供するビューの基になる文字列にインデックス算術を通過させることがあります）。緩やかなインデックス関数には、インデックス算術を目的としたものが含まれます：thisind、nextind、およびprevind。このモデルにより、インデックス算術は、文字を取得するためにそれらを使用しない限り、中間値として範囲外のインデックスで機能することができます。これにより、エッジケースを回避するためのコードを書く必要がなくなることがよくあります。

また、codeunit、ncodeunits、thisind、nextind、previndも参照してください。

AbstractChar型は、Juliaにおけるすべての文字実装のスーパークラスです。文字はUnicodeコードポイントを表し、codepoint関数を介して整数に変換することで、コードポイントの数値を取得したり、同じ整数から構築したりできます。これらの数値は、例えば<や==で文字を比較する際に使用されます。新しいT <: AbstractChar型は、少なくともcodepoint(::T)メソッドとT(::UInt32)コンストラクタを定義する必要があります。

特定のAbstractCharサブタイプは、Unicodeのサブセットのみを表すことができる場合があり、その場合、サポートされていないUInt32値からの変換はエラーをスローする可能性があります。逆に、組み込みのChar型は、無効なバイトストリームを損失なくエンコードするためにUnicodeのスーパーセットを表し、その場合、非Unicode値をUInt32に変換するとエラーがスローされます。isvalid関数を使用して、特定のAbstractChar型で表現可能なコードポイントを確認できます。

内部的に、AbstractChar型はさまざまなエンコーディングを使用する場合があります。codepoint(char)を介した変換は、このエンコーディングを明らかにしません。なぜなら、常に文字のUnicode値を返すからです。任意のc::AbstractCharのprint(io, c)は、必要に応じてCharに変換することにより、ioによって決定されるエンコーディング（すべての組み込みIO型に対してUTF-8）を生成します。

対照的に、write(io, c)はtypeof(c)に応じたエンコーディングを出力する可能性があり、read(io, typeof(c))はwriteと同じエンコーディングを読み取る必要があります。新しいAbstractChar型は、writeとreadの独自の実装を提供しなければなりません。

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

Charは、Juliaにおける文字のデフォルト表現である32ビットのAbstractChar型です。Charは、文字リテラル（例：'x'）に使用される型であり、Stringの要素型でもあります。

Stringに格納された任意のバイトストリームを損失なく表現するために、Char値はUnicodeコードポイントに変換できない情報を格納することがあります。そのようなCharをUInt32に変換しようとするとエラーが発生します。[isvalid(c::Char)](@ref)関数を使用して、cが有効なUnicode文字を表しているかどうかを確認できます。

codepoint(c::AbstractChar) -> Integer

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

length(s::AbstractString) -> Int
length(s::AbstractString, i::Integer, j::Integer) -> Int

文字列 s のインデックス i から j までの文字数を返します。

これは、i から j までの有効な文字インデックスのコードユニットインデックスの数として計算されます。単一の文字列引数のみの場合、これは文字列全体の文字数を計算します。i と j の引数がある場合、文字列 s の有効なインデックスである i から j までのインデックスの数を計算します。範囲内の値に加えて、i は範囲外の値 ncodeunits(s) + 1 を取り、j は範囲外の値 0 を取ることができます。

関連情報として isvalid, ncodeunits, lastindex, thisind, nextind, prevind を参照してください。

例

julia> length("jμΛIα")
5

sizeof(str::AbstractString)

文字列 str のサイズ（バイト単位）。str のコードユニットの数に str の1つのコードユニットのサイズ（バイト単位）を掛けたものに等しい。

例

julia> sizeof("")
0

julia> sizeof("∀")
3

*(s::Union{AbstractString, AbstractChar}, t::Union{AbstractString, AbstractChar}...) -> AbstractString

文字列や文字を連結し、String または AnnotatedString（適切に）を生成します。これは、引数に対して string または annotatedstring 関数を呼び出すことと同等です。組み込みの文字列型の連結は常に String 型の値を生成しますが、他の文字列型は適切に異なる型の文字列を返すことを選択する場合があります。

例

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

julia> 'j' * "ulia"
"julia"

^(s::Union{AbstractString,AbstractChar}, n::Integer) -> AbstractString

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

参照: repeat。

例

julia> "Test "^3
"Test Test Test "

string(n::Integer; base::Integer = 10, pad::Integer = 1)

整数 n を指定された base の文字列に変換し、オプションでパディングする桁数を指定します。

関連情報として digits, bitstring, count_zeros を参照してください。

例

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

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

string(xs...)

任意の値から文字列を作成するには、print 関数を使用します。

string は通常、直接定義されるべきではありません。代わりに、print(io::IO, x::MyType) メソッドを定義してください。特定の型に対して string(x) が非常に効率的である必要がある場合、string にメソッドを追加し、print(io::IO, x::MyType) = print(io, string(x)) を定義して、関数が一貫性を持つようにすることが意味を持つかもしれません。

参照: String, repr, sprint, show。

例

julia> string("a", 1, true)
"a1true"

repeat(s::AbstractString, r::Integer)

文字列を r 回繰り返します。これは s^r として書くことができます。

関連項目 ^。

例

julia> repeat("ha", 3)
"hahaha"

repeat(c::AbstractChar, r::Integer) -> String

文字を r 回繰り返します。これは、c^r を呼び出すことによって同等に達成できます。

例

julia> repeat('A', 3)
"AAA"

repr(x; context=nothing)

任意の値から文字列を作成するには、show 関数を使用します。repr にメソッドを追加するのではなく、代わりに show メソッドを定義する必要があります。

オプションのキーワード引数 context は、:key=>value ペア、:key=>value ペアのタプル、または show に渡される I/O ストリームに使用される属性を持つ IO または IOContext オブジェクトに設定できます。

repr(x) は通常、x の値が Julia でどのように入力されるかに似ています。人間が消費することをより意図した x の「きれいに印刷された」バージョンを返すには、repr(MIME("text/plain"), x) も参照してください。これは x の REPL 表示に相当します。

例

julia> repr(1)
"1"

julia> repr(zeros(3))
"[0.0, 0.0, 0.0]"

julia> repr(big(1/3))
"0.333333333333333314829616256247390992939472198486328125"

julia> repr(big(1/3), context=:compact => true)
"0.333333"

String(s::AbstractString)

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

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

getindexと同様ですが、コピーを作成するのではなく、範囲i:jまたはr内の親文字列sへのビューを返します。

@viewsマクロは、コードブロック内の任意の文字列スライスs[i:j]を部分文字列SubString(s, i, j)に変換します。

例

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

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

julia> SubString("abc", 2)
"bc"

LazyString <: AbstractString

文字列補間の遅延表現です。これは、実際の補間と文字列構築を行う必要がない、または望ましくないコンテキスト（例えば、関数のエラーパス）で文字列を構築する必要がある場合に便利です。

この型は、実行時に構築するのが安価であるように設計されており、可能な限り多くの作業をマクロまたは後の印刷操作にオフロードしようとします。

例

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

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

拡張ヘルプ

並行プログラムの安全性プロパティ

遅延文字列自体は、複数の Julia タスクで印刷されても、いかなる並行性の問題も引き起こしません。ただし、キャプチャされた値に対する print メソッドは、同期なしで呼び出された場合に並行性の問題を引き起こす可能性があり、遅延文字列を印刷することで問題が発生する可能性があります。さらに、キャプチャされた値に対する print メソッドは複数回呼び出される可能性がありますが、正確に1つの結果のみが返されます。

lazy"str"

通常の文字列補間構文を使用してLazyStringを作成します。補間はLazyStringの構築時に評価されますが、文字列への最初のアクセスまで印刷は遅延されます。

並行プログラムの安全性に関する詳細はLazyStringのドキュメントを参照してください。

例

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

julia> typeof(str)
LazyString

transcode(T, src)

文字列データをUnicodeエンコーディング間で変換します。srcはStringまたはUTF-XXコードユニットのVector{UIntXX}であり、ここでXXは8、16、または32です。Tは戻り値のエンコーディングを示します：Stringは(UTF-8エンコードされた)Stringを返し、UIntXXはUTF-XXデータのVector{UIntXX}を返します。（外部Cライブラリによって使用されるwchar_t*文字列を変換するために、整数型としてCwchar_tも使用できます。）

transcode関数は、入力データがターゲットエンコーディングで合理的に表現できる限り成功します。無効なUnicodeデータに対しても、UTF-XXエンコーディング間の変換は常に成功します。

現在、UTF-8への/からの変換のみがサポートされています。

例

julia> str = "αβγ"
"αβγ"

julia> transcode(UInt16, str)
3-element Vector{UInt16}:
 0x03b1
 0x03b2
 0x03b3

julia> transcode(String, transcode(UInt16, str))
"αβγ"

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

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

この関数は「unsafe」とラベル付けされています。なぜなら、pが要求された長さのデータに対する有効なメモリアドレスでない場合、クラッシュするからです。

ncodeunits(s::AbstractString) -> Int

文字列内のコードユニットの数を返します。この文字列にアクセスするためのインデックスは 1 ≤ i ≤ ncodeunits(s) を満たす必要があります。すべてのインデックスが有効であるわけではありません – それらは文字の開始位置でない場合がありますが、codeunit(s,i) を呼び出すとコードユニット値を返します。

例

julia> ncodeunits("The Julia Language")
18

julia> ncodeunits("∫eˣ")
6

julia> ncodeunits('∫'), ncodeunits('e'), ncodeunits('ˣ')
(3, 1, 2)

関連情報として codeunit, checkbounds, sizeof, length, lastindex を参照してください。

codeunit(s::AbstractString) -> Type{<:Union{UInt8, UInt16, UInt32}}

与えられた文字列オブジェクトのコードユニットタイプを返します。ASCII、Latin-1、またはUTF-8エンコードされた文字列の場合、これはUInt8になります。UCS-2およびUTF-16の場合はUInt16、UTF-32の場合はUInt32になります。コードユニットタイプはこれらの3つのタイプに限定される必要はありませんが、これらのユニットのいずれかを使用しない広く使用されている文字列エンコーディングを考えるのは難しいです。codeunit(s)は、sが空でない文字列の場合、typeof(codeunit(s,1))と同じです。

詳細はncodeunitsを参照してください。

codeunit(s::AbstractString, i::Integer) -> Union{UInt8, UInt16, UInt32}

文字列 s のインデックス i にあるコードユニットの値を返します。注意点として

codeunit(s, i) :: codeunit(s)

すなわち、codeunit(s, i) によって返される値は codeunit(s) によって返される型です。

例

julia> a = codeunit("Hello", 2)
0x65

julia> typeof(a)
UInt8

他にも ncodeunits, checkbounds を参照してください。

codeunits(s::AbstractString)

文字列のコードユニットを含むベクトルのようなオブジェクトを取得します。デフォルトでは CodeUnits ラッパーを返しますが、必要に応じて新しい文字列型のために codeunits をオプションで定義することができます。

例

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

ascii(s::AbstractString)

文字列を String 型に変換し、ASCII データのみを含むことを確認します。そうでない場合は、最初の非 ASCII バイトの位置を示す ArgumentError をスローします。

非 ASCII 文字をフィルタリングまたは置き換えるための isascii プレディケートも参照してください。

例

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

julia> ascii("abcdefgh")
"abcdefgh"

Regex(pattern[, flags]) <: AbstractPattern

正規表現を表す型です。Regexオブジェクトは、matchを使用して文字列と一致させるために使用できます。

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

@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 も含まれ、指定された文字値を直接1バイトとして出力し、UTF-8にエンコードしようとはしません。重要なことに、このオプションは無効なUTF-8文字列に対してマッチングを許可し、マッチャーとターゲットの両方を単純なバイトとして扱います（ISO/IEC 8859-1 / Latin-1バイトのように）文字エンコーディングとしてではなく。この場合、このオプションはしばしば s と組み合わせて使用されます。このオプションは、パターンを (UCP) または (UTF) で始めることによってさらに洗練されることがあります。

補間が必要な場合は Regex を参照してください。

例

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

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

SubstitutionString(substr) <: AbstractString

与えられた文字列 substr を SubstitutionString として保存し、正規表現の置換に使用します。最も一般的には @s_str マクロを使用して構築されます。

例

julia> SubstitutionString("Hello \\g<name>, it's \\1")
s"Hello \g<name>, it's \1"

julia> subst = s"Hello \g<name>, it's \1"
s"Hello \g<name>, it's \1"

julia> typeof(subst)
SubstitutionString{String}

@s_str -> SubstitutionString

置換文字列を構築します。これは正規表現の置換に使用されます。文字列内では、形式 \N のシーケンスは正規表現の N 番目のキャプチャグループを参照し、\g<groupname> は名前付きキャプチャグループ groupname を参照します。

例

julia> msg = "#Hello# from Julia";

julia> replace(msg, r"#(.+)# from (?<from>\w+)" => s"FROM: \g<from>; MESSAGE: \1")
"FROM: Julia; MESSAGE: Hello"

@raw_str -> String

補間やアンエスケープなしで生文字列を作成します。例外として、引用符は依然としてエスケープする必要があります。バックスラッシュは、引用文字の前にバックスラッシュのシーケンスがある場合にのみ、引用符と他のバックスラッシュの両方をエスケープします。したがって、2nのバックスラッシュの後に引用符が続くと、nのバックスラッシュとリテラルの終わりをエンコードし、2n+1のバックスラッシュの後に引用符が続くと、nのバックスラッシュと引用文字をエンコードします。

例

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

julia> println(raw"\"")
"

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

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

@b_str

文字列構文を使用して不変のバイト（UInt8）ベクターを作成します。

例

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

julia> v[2]
0x32

@html_str -> Docs.HTML

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

例

julia> html"Julia"
HTML{String}("Julia")

@text_str -> Docs.Text

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

例

julia> text"Julia"
Julia

isvalid(value) -> Bool

与えられた値がその型に対して有効であれば true を返します。現在、有効な型は AbstractChar または String または SubString{String} のいずれかです。

例

julia> isvalid(Char(0xd800))
false

julia> isvalid(SubString(String(UInt8[0xfe,0x80,0x80,0x80,0x80,0x80]),1,2))
false

julia> isvalid(Char(0xd799))
true

isvalid(T, value) -> Bool

与えられた値がその型に対して有効であれば true を返します。現在、型は AbstractChar または String のいずれかです。AbstractChar の値は AbstractChar 型または UInt32 であることができます。String の値はその型、SubString{String}、Vector{UInt8}、またはその連続した部分配列であることができます。

例

julia> isvalid(Char, 0xd800)
false

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

julia> isvalid(Char, 0xd799)
true

isvalid(s::AbstractString, i::Integer) -> Bool

与えられたインデックスがs内の文字のエンコーディングの開始位置であるかどうかを示す述語です。isvalid(s, i)がtrueの場合、s[i]はそのインデックスで始まるエンコーディングの文字を返します。falseの場合、s[i]は無効なインデックスエラーまたは範囲エラーを発生させます。iが範囲内であるかどうかに依存します。isvalid(s, i)がO(1)の関数であるためには、sのエンコーディングが自己同期でなければなりません。これはJuliaの一般的な文字列サポートの基本的な前提です。

関連項目としては、getindex、iterate、thisind、nextind、prevind、lengthがあります。

例

julia> str = "αβγdef";

julia> isvalid(str, 1)
true

julia> str[1]
'α': Unicode U+03B1 (category Ll: Letter, lowercase)

julia> isvalid(str, 2)
false

julia> str[2]
ERROR: StringIndexError: invalid index [2], valid nearby indices [1]=>'α', [3]=>'β'
Stacktrace:
[...]

match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])

正規表現 r の最初の一致を s で検索し、一致が失敗した場合は何も返さず、一致を含む RegexMatch オブジェクトを返します。一致した部分文字列は m.match にアクセスすることで取得でき、キャプチャされたシーケンスは m.captures にアクセスすることで取得できます。オプションの idx 引数は、検索を開始するインデックスを指定します。

例

julia> rx = r"a(.)a"
r"a(.)a"

julia> m = match(rx, "cabac")
RegexMatch("aba", 1="b")

julia> m.captures
1-element Vector{Union{Nothing, SubString{String}}}:
 "b"

julia> m.match
"aba"

julia> match(rx, "cabac", 3) === nothing
true

eachmatch(r::Regex, s::AbstractString; overlap::Bool=false)

正規表現 r のすべての一致を文字列 s で検索し、一致のイテレータを返します。overlap が true の場合、一致するシーケンスは元の文字列のインデックスで重複することが許可されます。そうでない場合は、異なる文字範囲からでなければなりません。

例

julia> rx = r"a.a"
r"a.a"

julia> m = eachmatch(rx, "a1a2a3a")
Base.RegexMatchIterator{String}(r"a.a", "a1a2a3a", false)

julia> collect(m)
2-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a3a")

julia> collect(eachmatch(rx, "a1a2a3a", overlap = true))
3-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a2a")
 RegexMatch("a3a")

RegexMatch <: AbstractMatch

文字列内で見つかったRegexへの単一の一致を表す型。通常はmatch関数から作成されます。

matchフィールドは、全体の一致した文字列の部分文字列を格納します。capturesフィールドは、番号でインデックスされた各キャプチャグループの部分文字列を格納します。キャプチャグループ名でインデックスを付けるには、全体の一致オブジェクトをインデックスする必要があります。マッチの開始位置はoffsetフィールドに格納されます。offsetsフィールドは、各キャプチャグループの開始位置を格納し、0はキャプチャされなかったグループを示します。

この型は、Regexのキャプチャグループを反復処理するためのイテレータとして使用でき、各グループでキャプチャされた部分文字列を生成します。このため、マッチのキャプチャは分解できます。グループがキャプチャされなかった場合、部分文字列の代わりにnothingが生成されます。

RegexMatchオブジェクトを受け入れるメソッドは、iterate、length、eltype、keys、haskey、およびgetindexに対して定義されており、キーはキャプチャグループの名前または番号です。詳細については、keysを参照してください。

例

julia> m = match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30 in the morning")
RegexMatch("11:30", hour="11", minute="30", 3=nothing)

julia> m.match
"11:30"

julia> m.captures
3-element Vector{Union{Nothing, SubString{String}}}:
 "11"
 "30"
 nothing


julia> m["minute"]
"30"

julia> hr, min, ampm = m; # キャプチャグループを反復処理して分解

julia> hr
"11"

keys(m::RegexMatch) -> Vector

正規表現の基盤となるキャプチャグループのすべてのキーのベクターを返します。キーは、キャプチャグループが一致しなくても含まれます。つまり、idxは、m[idx] == nothingであっても返り値に含まれます。

名前のないキャプチャグループは、そのインデックスに対応する整数キーを持ちます。名前のあるキャプチャグループは、文字列キーを持ちます。

例

julia> keys(match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30"))
3-element Vector{Any}:
  "hour"
  "minute"
 3

isless(a::AbstractString, b::AbstractString) -> Bool

文字列 a が文字列 b よりもアルファベット順で前に来るかどうかをテストします（技術的には、Unicode コードポイントによる辞書式順序で）。

例

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

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

julia> isless("a", "a")
false

==(a::AbstractString, b::AbstractString) -> Bool

2つの文字列が文字ごとに等しいかどうかをテストします（技術的には、Unicode コードポイントごとに）。いずれかの文字列がAnnotatedStringである場合、文字列のプロパティも一致する必要があります。

例

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false

cmp(a::AbstractString, b::AbstractString) -> Int

2つの文字列を比較します。両方の文字列が同じ長さで、各インデックスの文字が両方の文字列で同じであれば 0 を返します。a が b の接頭辞である場合、または a がアルファベット順で b の前に来る場合は -1 を返します。b が a の接頭辞である場合、または b がアルファベット順で a の前に来る場合は 1 を返します（技術的には、Unicode コードポイントによる辞書順です）。

例

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

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

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

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

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

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

julia> cmp("b", "β")
-1

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

sを文字列に変換し、結果の文字列をpで左側にパディングしてn文字（textwidth）の長さにします。もしsがすでにn文字の長さであれば、同じ文字列が返されます。デフォルトではスペースでパディングします。

例

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

```

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

sを文字列に変換し、結果の文字列を右側にpでパディングしてn文字（textwidth）の長さにします。もしsがすでにn文字の長さであれば、同じ文字列が返されます。デフォルトではスペースでパディングします。

例

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

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

string内のpatternの最初の出現を見つけます。findnext(pattern, string, firstindex(s))と同等です。

例

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

julia> findfirst("Julia", "JuliaLang")
1:5

findnext(pattern::AbstractString, string::AbstractString, start::Integer)
findnext(pattern::AbstractPattern, string::String, start::Integer)

patternの次の出現をstring内でstartの位置から探します。patternは文字列または正規表現のいずれかであり、その場合stringはString型でなければなりません。

返り値は、一致するシーケンスが見つかったインデックスの範囲であり、s[findnext(x, s, i)] == xが成り立ちます：

findnext("substring", string, i) == start:stop であり、string[start:stop] == "substring"かつi <= start、または一致しない場合はnothingです。

例

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

julia> findnext("o", "Hello to the world", 6)
8:8

julia> findnext("Lang", "JuliaLang", 2)
6:9

findnext(ch::AbstractChar, string::AbstractString, start::Integer)

文字 ch の次の出現を、位置 start から始めて string 内で見つけます。

例

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

julia> findnext('o', "Hello to the world", 6)
8

findlast(pattern::AbstractString, string::AbstractString)

string内のpatternの最後の出現を見つけます。findprev(pattern, string, lastindex(string))と同等です。

例

julia> findlast("o", "Hello to the world")
15:15

julia> findfirst("Julia", "JuliaLang")
1:5

findlast(ch::AbstractChar, string::AbstractString)

文字 ch の string 内での最後の出現を見つけます。

例

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

julia> findlast('z', "happy") === nothing
true

findprev(pattern::AbstractString, string::AbstractString, start::Integer)

string内のstart位置から始めてpatternの前の出現を見つけます。

返り値は、マッチするシーケンスが見つかったインデックスの範囲であり、s[findprev(x, s, i)] == xとなります：

findprev("substring", string, i) == start:stop であり、string[start:stop] == "substring" かつ stop <= i、または一致しない場合はnothingです。

例

julia> findprev("z", "Hello to the world", 18) === nothing
true

julia> findprev("o", "Hello to the world", 18)
15:15

julia> findprev("Julia", "JuliaLang", 6)
1:5

occursin(needle::Union{AbstractString,AbstractPattern,AbstractChar}, haystack::AbstractString)

最初の引数が2番目の引数の部分文字列であるかどうかを判断します。needleが正規表現の場合、haystackに一致が含まれているかどうかをチェックします。

例

julia> occursin("Julia", "JuliaLang is pretty cool!")
true

julia> occursin('a', "JuliaLang is pretty cool!")
true

julia> occursin(r"a.a", "aba")
true

julia> occursin(r"a.a", "abba")
false

詳細はcontainsを参照してください。

occursin(haystack)

引数が haystack に存在するかどうかをチェックする関数を作成します。すなわち、needle -> occursin(needle, haystack) と同等の関数です。

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

例

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

julia> search_f("JuliaLang")
true

julia> search_f("Python")
false

reverse(s::AbstractString) -> AbstractString

文字列を逆にします。技術的には、この関数は文字列内のコードポイントを逆にし、その主な用途は逆順の文字列処理、特に逆の正規表現検索にあります。sのインデックスをreverse(s)のインデックスに変換するためのreverseindや、コードポイントではなくユーザーが目にする「文字」（グラフェム）に対して操作するためのUnicodeモジュールのgraphemesも参照してください。また、コピーを作成せずに逆順の反復を行うためのIterators.reverseも参照してください。カスタム文字列型は自分自身でreverse関数を実装する必要があり、通常は同じ型とエンコーディングの文字列を返すべきです。異なるエンコーディングの文字列を返す場合、その文字列型に対してreverseindもオーバーライドし、s[reverseind(s,i)] == reverse(s)[i]を満たす必要があります。

例

julia> reverse("JuliaLang")
"gnaLailuJ"

結合文字は驚くべき結果をもたらすことがあります：

julia> reverse("ax̂e") # 帽子は入力ではxの上、出力ではeの上にあります
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # グラフェムを逆にします; 帽子は両方の入力と出力でxの上にあります
"ex̂a"

replace([io::IO], s::AbstractString, pat=>r, [pat2=>r2, ...]; [count::Integer])

与えられたパターン pat を s の中で検索し、各出現を r で置き換えます。count が提供されている場合、最大で count 回の出現を置き換えます。pat は単一の文字、ベクターまたは文字の集合、文字列、または正規表現である可能性があります。r が関数である場合、各出現は r(s) で置き換えられ、ここで s は一致した部分文字列（pat が AbstractPattern または AbstractString の場合）または文字（pat が AbstractChar または AbstractChar のコレクションの場合）です。pat が正規表現であり、r が SubstitutionString の場合、r 内のキャプチャグループ参照は対応する一致したテキストで置き換えられます。pat のインスタンスを文字列から削除するには、r を空の String ("") に設定します。

返り値は、置き換え後の新しい文字列です。io::IO 引数が提供されている場合、変換された文字列は io に書き込まれます（io を返します）。 （例えば、これは IOBuffer と組み合わせて、事前に割り当てられたバッファ配列をその場で再利用するために使用できます。）

複数のパターンを指定することができ、これらは左から右に同時に適用されるため、任意の文字には1つのパターンのみが適用され、パターンは置き換えではなく入力テキストにのみ適用されます。

例

julia> replace("Python is a programming language.", "Python" => "Julia")
"Julia is a programming language."

julia> replace("The quick foxes run quickly.", "quick" => "slow", count=1)
"The slow foxes run quickly."

julia> replace("The quick foxes run quickly.", "quick" => "", count=1)
"The  foxes run quickly."

julia> replace("The quick foxes run quickly.", r"fox(es)?" => s"bus\1")
"The quick buses run quickly."

julia> replace("abcabc", "a" => "b", "b" => "c", r".+" => "a")
"bca"

eachsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

strを区切り文字dlmの出現に基づいて分割し、部分文字列のイテレータを返します。dlmはfindnextの最初の引数で許可されている形式（文字列、正規表現、または関数）や、単一の文字または文字のコレクションとして指定できます。

dlmが省略された場合、デフォルトはisspaceになります。

オプションのキーワード引数は次のとおりです：

• limit: 結果の最大サイズ。limit=0は最大なしを意味します（デフォルト）。
• keepempty: 空のフィールドを結果に保持するかどうか。dlm引数がない場合のデフォルトはfalse、dlm引数がある場合のデフォルトはtrueです。

他にもsplitを参照してください。

例

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

julia> b = eachsplit(a, ".")
Base.SplitIterator{String, String}("Ma.rch", ".", 0, true)

julia> collect(b)
2-element Vector{SubString{String}}:
 "Ma"
 "rch"

eachrsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachrsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

strを区切り文字dlmで分割したときに生成されるSubStringのイテレータを返し、逆順（右から左）で出力します。dlmはfindprevの最初の引数で許可される形式（すなわち、文字列、単一の文字、または関数）、または文字のコレクションのいずれかであることができます。

dlmが省略された場合、デフォルトはisspaceで、keepemptyのデフォルトはfalseです。

オプションのキーワード引数は次のとおりです：

• limit > 0の場合、イテレータは最大でlimit - 1回分割し、その後は残りの文字列を分割せずに返します。limit < 1は分割に制限がないことを意味します（デフォルト）。
• keepempty: イテレート時に空のフィールドを返すべきかどうか。dlm引数がない場合のデフォルトはfalse、dlm引数がある場合のデフォルトはtrueです。

splitやrsplit、eachsplitとは異なり、この関数は入力に現れる順序で部分文字列を右から左にイテレートします。

他にもeachsplit、rsplitを参照してください。

例

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

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

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

split(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
split(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

strを区切り文字dlmの出現に基づいて部分文字列の配列に分割します。dlmはfindnextの最初の引数で許可される形式（すなわち、文字列、正規表現、または関数）や、単一の文字または文字のコレクションとして指定できます。

dlmが省略された場合、デフォルトはisspaceになります。

オプションのキーワード引数は次のとおりです：

• limit: 結果の最大サイズ。limit=0は最大なしを意味します（デフォルト）
• keepempty: 空のフィールドを結果に保持するかどうか。dlm引数がない場合のデフォルトはfalse、dlm引数がある場合はtrueです。

他にrsplit、eachsplitも参照してください。

例

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

julia> split(a, ".")
2-element Vector{SubString{String}}:
 "Ma"
 "rch"

rsplit(s::AbstractString; limit::Integer=0, keepempty::Bool=false)
rsplit(s::AbstractString, chars; limit::Integer=0, keepempty::Bool=true)

文字列の末尾から始める点を除いて、splitと似ています。

例

julia> a = "M.a.r.c.h"
"M.a.r.c.h"

julia> rsplit(a, ".")
5-element Vector{SubString{String}}:
 "M"
 "a"
 "r"
 "c"
 "h"

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

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

strip([pred=isspace,] str::AbstractString) -> SubString
strip(str::AbstractString, chars) -> SubString

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

デフォルトの動作は、先頭と末尾の空白および区切り文字を削除することです。正確な詳細についてはisspaceを参照してください。

オプションのchars引数は、削除する文字を指定します。これは単一の文字、ベクター、または文字の集合であることができます。

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

例

julia> strip("{3, 5}\n", ['{', '}', '\n'])
"3, 5"

lstrip([pred=isspace,] str::AbstractString) -> SubString
lstrip(str::AbstractString, chars) -> SubString

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

デフォルトの動作は、先頭の空白と区切り文字を削除することです。正確な詳細については、isspaceを参照してください。

オプションのchars引数は、削除する文字を指定します。これは単一の文字、または文字のベクターまたはセットであることができます。

他にもstripやrstripを参照してください。

例

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

julia> lstrip(a)
"March"

rstrip([pred=isspace,] str::AbstractString) -> SubString
rstrip(str::AbstractString, chars) -> SubString

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

デフォルトの動作は、末尾の空白と区切り文字を削除することです。正確な詳細についてはisspaceを参照してください。

オプションのchars引数は、削除する文字を指定します。これは単一の文字、または文字のベクターまたはセットであることができます。

他にもstripやlstripがあります。

例

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

julia> rstrip(a)
"March"

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

sがprefixで始まる場合はtrueを返します。prefixは文字列、文字、または文字のタプル/ベクター/セットである可能性があります。prefixが文字のタプル/ベクター/セットである場合、sの最初の文字がそのセットに属するかどうかをテストします。

関連情報としてはendswith、containsがあります。

例

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

startswith(io::IO, prefix::Union{AbstractString,Base.Chars})

IOオブジェクトが、文字列、文字、または文字のタプル/ベクター/セットのいずれかであるプレフィックスで始まるかどうかを確認します。詳細はpeekを参照してください。

startswith(prefix)

prefixで始まるかどうかをチェックする関数を作成します。つまり、y -> startswith(y, prefix)と同等の関数です。

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

例

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

julia> startswith("Julia")("Ends with Julia")
false

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

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

他にoccursinやendswithも参照してください。

例

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

endswith(s::AbstractString, suffix::Union{AbstractString,Base.Chars})

sがsuffixで終わる場合はtrueを返します。suffixは文字列、文字、または文字のタプル/ベクター/セットである可能性があります。suffixが文字のタプル/ベクター/セットである場合、sの最後の文字がそのセットに属するかどうかをテストします。

関連情報としてstartswith、containsを参照してください。

例

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

endswith(suffix)

suffixで引数が終わるかどうかをチェックする関数を作成します。すなわち、y -> endswith(y, suffix)に相当する関数です。

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

例

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

julia> endswith("Julia")("JuliaLang")
false

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

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

他にoccursinやstartswithも参照してください。

例

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

contains(haystack::AbstractString, needle)

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

他にもoccursin、in、issubsetを参照してください。

例

julia> contains("JuliaLang is pretty cool!", "Julia")
true

julia> contains("JuliaLang is pretty cool!", 'a')
true

julia> contains("aba", r"a.a")
true

julia> contains("abba", r"a.a")
false

contains(needle)

引数が needle を含むかどうかをチェックする関数を作成します。すなわち、haystack -> contains(haystack, needle) と同等の関数です。

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

first(s::AbstractString, n::Integer)

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

例

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

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

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

last(s::AbstractString, n::Integer)

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

例

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

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

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

uppercase(c::AbstractChar)

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

関連情報としてlowercase、titlecaseを参照してください。

例

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

julia> uppercase('ê')
'Ê': Unicode U+00CA (category Lu: Letter, uppercase)

uppercase(s::AbstractString)

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

関連情報としては、lowercase、titlecase、uppercasefirstがあります。

例

julia> uppercase("Julia")
"JULIA"

lowercase(c::AbstractChar)

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

関連項目としては uppercase、titlecase があります。

例

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

julia> lowercase('Ö')
'ö': Unicode U+00F6 (category Ll: Letter, lowercase)

lowercase(s::AbstractString)

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

他にもuppercase、titlecase、lowercasefirstを参照してください。

例

julia> lowercase("STRINGS AND THINGS")
"strings and things"

titlecase(c::AbstractChar)

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

関連情報としては、uppercase、lowercaseがあります。

例

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

julia> titlecase('dž')
'Dž': Unicode U+01C5 (category Lt: Letter, titlecase)

julia> uppercase('dž')
'DŽ': Unicode U+01C4 (category Lu: Letter, uppercase)

titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true) -> String

sの各単語の最初の文字を大文字にします。strictがtrueの場合、他のすべての文字は小文字に変換されます。そうでない場合は、変更されずにそのまま残ります。デフォルトでは、新しいグラフェムを開始するすべての非文字は単語の区切りと見なされます。どの文字を単語の区切りと見なすかを決定するために、wordsepキーワードとして述語を渡すことができます。sの最初の文字だけを大文字にするには、uppercasefirstも参照してください。

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

例

julia> titlecase("the JULIA programming language")
"The Julia Programming Language"

julia> titlecase("ISS - international space station", strict=false)
"ISS - International Space Station"

julia> titlecase("a-a b-b", wordsep = c->c==' ')
"A-a B-b"

uppercasefirst(s::AbstractString) -> String

sの最初の文字を大文字に変換した文字列を返します（技術的にはUnicodeの「タイトルケース」）。sのすべての単語の最初の文字を大文字にするには、titlecaseを参照してください。

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

例

julia> uppercasefirst("python")
"Python"

lowercasefirst(s::AbstractString)

sの最初の文字を小文字に変換して返します。

関連項目としては uppercasefirst、uppercase、lowercase、titlecase があります。

例

julia> lowercasefirst("Julia")
"julia"

join([io::IO,] iterator [, delim [, last]])

任意の iterator を単一の文字列に結合し、隣接するアイテムの間に指定された区切り文字（ある場合）を挿入します。 last が指定されている場合、最後の2つのアイテムの間には delim の代わりにそれが使用されます。 iterator の各アイテムは print(io::IOBuffer, x) を介して文字列に変換されます。 io が指定されている場合、結果は String として返されるのではなく、io に書き込まれます。

例

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

julia> join([1,2,3,4,5])
"12345"

chop(s::AbstractString; head::Integer = 0, tail::Integer = 1)

sの最初のhead文字と最後のtail文字を削除します。呼び出しchop(s)はsの最後の文字を削除します。length(s)よりも多くの文字を削除するように要求された場合、空の文字列が返されます。

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

例

julia> a = "March"
"March"

julia> chop(a)
"Marc"

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

julia> chop(a, head = 5, tail = 5)
""

chopprefix(s::AbstractString, prefix::Union{AbstractString,Regex}) -> SubString

sから接頭辞prefixを削除します。sがprefixで始まっていない場合、sと等しい文字列が返されます。

chopsuffixも参照してください。

例

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

julia> chopprefix("Hamburger", "hotdog")
"Hamburger"

chopsuffix(s::AbstractString, suffix::Union{AbstractString,Regex}) -> SubString

sから接尾辞suffixを削除します。sがsuffixで終わっていない場合、sと等しい文字列が返されます。

chopprefixも参照してください。

例

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

julia> chopsuffix("Hamburger", "hotdog")
"Hamburger"

chomp(s::AbstractString) -> SubString

文字列から単一の末尾改行を削除します。

関連項目としてchopがあります。

例

julia> chomp("Hello\n")
"Hello"

thisind(s::AbstractString, i::Integer) -> Int

sの中でiが範囲内であれば、iが含まれる文字のエンコーディングコードユニットの開始位置のインデックスを返します。言い換えれば、iが文字の開始位置であればiを返し、iが文字の開始位置でない場合は、文字の開始位置まで巻き戻してそのインデックスを返します。iが0またはncodeunits(s)+1に等しい場合はiを返します。それ以外の場合はBoundsErrorをスローします。

例

julia> thisind("α", 0)
0

julia> thisind("α", 1)
1

julia> thisind("α", 2)
1

julia> thisind("α", 3)
3

julia> thisind("α", 4)
ERROR: BoundsError: attempt to access 2-codeunit String at index [4]
[...]

julia> thisind("α", -1)
ERROR: BoundsError: attempt to access 2-codeunit String at index [-1]
[...]

nextind(str::AbstractString, i::Integer, n::Integer=1) -> Int

• ケース n == 1

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

• ケース n > 1

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

• ケース n == 0

  i が s の有効なインデックスであるか 0 と等しい場合のみ i を返します。それ以外の場合は StringIndexError または BoundsError がスローされます。

例

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

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

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

julia> nextind("α", 1, 2)
4

prevind(str::AbstractString, i::Integer, n::Integer=1) -> Int

• ケース n == 1

  i が s の範囲内であれば、インデックス i の前にエンコーディングが始まる文字の開始位置のインデックスを返します。言い換えれば、i が文字の開始位置であれば、前の文字の開始位置を返します。i が文字の開始位置でない場合は、文字の開始位置まで巻き戻し、そのインデックスを返します。i が 1 に等しい場合は 0 を返します。i が ncodeunits(str)+1 に等しい場合は lastindex(str) を返します。それ以外の場合は BoundsError をスローします。

• ケース n > 1

  n==1 の場合に prevind を n 回適用するように動作します。唯一の違いは、n が大きすぎて prevind を適用すると 0 に達する場合、残りの各反復で返される値が 1 減少することです。この場合、prevind は負の値を返すことがあります。

• ケース n == 0

  i が str の有効なインデックスであるか、ncodeunits(str)+1 に等しい場合のみ i を返します。それ以外の場合は StringIndexError または BoundsError がスローされます。

例

julia> prevind("α", 3)
1

julia> prevind("α", 1)
0

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

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

julia> prevind("α", 2, 3)
-1

textwidth(c)

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

例

julia> textwidth('α')
1

julia> textwidth('⛵')
2

textwidth(s::AbstractString)

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

例

julia> textwidth("March")
5

isascii(c::Union{AbstractChar,AbstractString}) -> Bool

文字がASCII文字セットに属するか、または文字列のすべての要素がそうであるかをテストします。

例

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

例えば、isasciiはfilterやreplaceのための述語関数として使用でき、非ASCII文字をそれぞれ削除または置き換えることができます：

julia> filter(isascii, "abcdeγfgh") # 非ASCII文字を除外
"abcdefgh"

julia> replace("abcdeγfgh", !isascii=>' ') # 非ASCII文字をスペースに置き換え
"abcde fgh"

isascii(cu::AbstractVector{CU}) where {CU <: Integer} -> Bool

ベクター内のすべての値がASCII文字セット（0x00から0x7f）に属するかどうかをテストします。この関数は、高速なASCIIチェックが必要な他の文字列実装によって使用されることを意図しています。

iscntrl(c::AbstractChar) -> Bool

文字が制御文字であるかどうかをテストします。制御文字は、UnicodeのLatin-1サブセットの非印刷文字です。

例

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

isdigit(c::AbstractChar) -> Bool

文字が10進数の数字（0-9）であるかどうかをテストします。

参照: isletter。

例

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

isletter(c::AbstractChar) -> Bool

文字がアルファベットかどうかをテストします。文字は、Unicodeの一般カテゴリ「Letter」に属する場合、すなわちカテゴリコードが'L'で始まる文字として分類されます。

参照: isdigit.

例

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

文字が小文字であるかどうかをテストします（Unicode標準のLowercase派生プロパティに従います）。

関連情報としてisuppercaseも参照してください。

例

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

文字が数値であるかどうかをテストします。文字は、Unicodeの一般カテゴリ「Number」に属する場合、すなわちカテゴリコードが'N'で始まる文字として分類されます。

この広いカテゴリには、¾や௰のような文字が含まれます。文字が0から9の間の10進数の数字であるかどうかを確認するには、isdigitを使用してください。

例

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

isprint(c::AbstractChar) -> Bool

文字が印刷可能かどうかをテストします。スペースを含みますが、制御文字は含みません。

例

julia> isprint('\x01')
false

julia> isprint('A')
true

ispunct(c::AbstractChar) -> Bool

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

例

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

isspace(c::AbstractChar) -> Bool

文字が任意の空白文字であるかどうかをテストします。ASCII文字 '\t', '\n', '\v', '\f', '\r', および ' '、Latin-1文字 U+0085、Unicodeカテゴリ Zs の文字を含みます。

例

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

isuppercase(c::AbstractChar) -> Bool

文字が大文字のアルファベットであるかどうかをテストします（Unicode標準のUppercase派生プロパティに従います）。

関連情報としてislowercaseも参照してください。

例

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

isxdigit(c::AbstractChar) -> Bool

文字が有効な16進数の桁であるかどうかをテストします。これは、標準の0xプレフィックスにおけるxは含まれないことに注意してください。

例

julia> isxdigit('a')
true

julia> isxdigit('x')
false

escape_string(str::AbstractString[, esc]; keep = ())::AbstractString
escape_string(io, str::AbstractString[, esc]; keep = ())::Nothing

従来のCおよびUnicodeエスケープシーケンスの一般的なエスケープ。最初の形式はエスケープされた文字列を返し、2番目は結果をioに出力します。

バックスラッシュ（\）はダブルバックスラッシュ（"\\"）でエスケープされます。非表示文字は、標準Cエスケープコード（NULの場合は"\0"、あいまいでない場合）、ユニコードコードポイント（"\u"プレフィックス）または16進数（"\x"プレフィックス）でエスケープされます。

オプションのesc引数は、バックスラッシュを前に付けてエスケープされるべき追加の文字を指定します（最初の形式では"もデフォルトでエスケープされます）。

引数keepは、そのまま保持されるべき文字のコレクションを指定します。ここでescが優先されることに注意してください。

逆操作については、unescape_stringも参照してください。

例

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

julia> escape_string("aaa\nbbb"; keep = '\n')
"aaa\nbbb"

julia> escape_string("\xfe\xff") # 無効なutf-8
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # あいまいでない
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0はあいまいになる
"ℵ\\x000"

escape_raw_string(s::AbstractString, delim='"') -> AbstractString
escape_raw_string(io, s::AbstractString, delim='"')

生の文字列リテラルを解析するために使用される方法で文字列をエスケープします。入力文字列 s（または指定された場合は delim）内の各ダブルクォート（") 文字について、この関数は前にあるバックスラッシュ（\）文字の数 n をカウントし、その後、n から 2n+1 までバックスラッシュの数を増やします（n = 0 の場合も含む）。また、文字列の末尾にあるバックスラッシュのシーケンスも倍増させます。

このエスケープ規則は、生の文字列やその他の非標準文字列リテラルで使用されます。（これは、コマンドライン文字列を argv[] 配列に解析する際に Microsoft C/C++ コンパイラランタイムが期待するエスケープ規則でもあります。）

escape_string も参照してください。

unescape_string(str::AbstractString, keep = ())::AbstractString
unescape_string(io, s::AbstractString, keep = ())::Nothing

従来のCおよびUnicodeエスケープシーケンスの一般的なアンエスケープ。最初の形式はエスケープされた文字列を返し、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を参照してください。

例

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

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

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

julia> unescape_string("aaa \\g \\n", ['g']) # `keep`引数を使用
"aaa \\g \n"

AnnotatedString{S <: AbstractString} <: AbstractString

メタデータを持つ文字列で、注釈付きの領域の形をしています。

より具体的には、ラベル付きの値で注釈を付けることができる、他のAbstractStringをラップするシンプルなラッパーです。

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

上の図は、3つの範囲に注釈が付けられたAnnotatedStringを表しています（ラベルはA、B、C）。各注釈はラベル（Symbol）と値（Any）を保持します。これら3つの情報は@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}として保持されます。

ラベルは一意である必要はなく、同じ領域に同じラベルの複数の注釈を持つことができます。

一般的にAnnotatedString用に書かれたコードは、以下の特性を保持する必要があります：

• 注釈が適用される文字
• 各文字に対して注釈が適用される順序

特定のAnnotatedStringの使用によって追加の意味が導入されることがあります。

これらのルールの帰結は、隣接して連続して配置された、同一のラベルと値を持つ注釈は、結合された範囲を跨ぐ単一の注釈に相当するということです。

他にAnnotatedChar、annotatedstring、annotations、およびannotate!も参照してください。

コンストラクタ

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

AnnotatedStringは、引数に存在する注釈を保持しつつ、stringのように動作するannotatedstringを使って作成することもできます。

例

julia> AnnotatedString("this is an example annotated string",
                    [(1:18, :A => 1), (12:28, :B => 2), (18:35, :C => 3)])
"this is an example annotated string"

AnnotatedChar{S <: AbstractChar} <: AbstractChar

注釈付きの文字です。

より具体的には、これは任意のAbstractCharの周りにあるシンプルなラッパーで、ラップされた文字と共に任意のラベル付き注釈のリスト（@NamedTuple{label::Symbol, value}）を保持します。

関連情報: AnnotatedString, annotatedstring, annotations, および annotate!。

コンストラクタ

AnnotatedChar(s::S) -> AnnotatedChar{S}
AnnotatedChar(s::S, annotations::Vector{@NamedTuple{label::Symbol, value}})

例

julia> AnnotatedChar('j', :label => 1)
'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)

annotatedstring(values...)

任意の数の values から print された表現を使用して AnnotatedString を作成します。

これは string のように動作しますが、存在する注釈（AnnotatedString または AnnotatedChar 値の形で）を保持することに注意を払います。

AnnotatedString および AnnotatedChar も参照してください。

例

julia> annotatedstring("now a AnnotatedString")
"now a AnnotatedString"

julia> annotatedstring(AnnotatedString("annotated", [(1:9, :label => 1)]), ", and unannotated")
"annotated, and unannotated"

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

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

注釈は、それが適用される領域と共に、領域–注釈タプルのベクターの形で提供されます。

AnnotatedStringに文書化された意味論に従い、返される注釈の順序は、それらが適用された順序と一致します。

関連情報: annotate!.

annotations(chr::AnnotatedChar) -> Vector{@NamedTuple{label::Symbol, value}}

chrのすべての注釈を、注釈ペアのベクトルの形式で取得します。

annotate!(str::AnnotatedString, [range::UnitRange{Int}], label::Symbol, value)
annotate!(str::SubString{AnnotatedString}, [range::UnitRange{Int}], label::Symbol, value)

strのrange（または全体の文字列）にラベル付きの値（label => value）で注釈を付けます。既存のlabel注釈を削除するには、nothingの値を使用します。

strに注釈が適用される順序は意味的に重要であり、AnnotatedStringで説明されています。

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

charに対してペアlabel => valueで注釈を付けます。