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

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"

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)

任意の値の文字列表現を作成するには、2引数の show(io, x) 関数を使用します。これは、可能な限り解析可能なJuliaコードの文字列を生成することを目的としています。すなわち、eval(Meta.parse(repr(x))) == x が成り立つべきです。repr にメソッドを追加してはいけません。代わりに show メソッドを定義してください。

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

repr(x) は通常、x の値がJuliaでどのように入力されるかに似ています。人間が消費するために設計された x の「きれいに印刷された」バージョンを返す repr(MIME("text/plain"), x) も参照してください。これは、3引数の show(io, mime, 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 を参照してください。

Extended help

同時プログラムの安全性プロパティ

遅延文字列自体は、複数の 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}を返します。（エイリアスCwchar_tも整数型として使用でき、外部Cライブラリによって使用されるwchar_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, 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 を参照してください。

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.

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

@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にエンコードしようとはしません。重要なことに、このオプションは、マッチャーとターゲットの両方を単純なバイト（ISO/IEC 8859-1 / Latin-1バイトのように）として扱うことにより、無効なUTF-8文字列に対してマッチングを許可します。この場合、このオプションはしばしば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 にアクセスすることで取得できます。結果の RegexMatch オブジェクトは他のコレクションを構築するために使用できます：例えば Tuple(m)、NamedTuple(m) など。

例

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

Tuple(m)、NamedTuple(m)、およびDict(m)を使用して、RegexMatchオブジェクトからより柔軟なコレクション型を構築できます。

例

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"

julia> Dict(m)
Dict{Any, Union{Nothing, SubString{String}}} with 3 entries:
  "hour"   => "11"
  3        => nothing
  "minute" => "30"

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               "

ltruncate(str::AbstractString, maxwidth::Integer, replacement::Union{AbstractString,AbstractChar} = '…')

strを最大でmaxwidth列に切り詰めます（textwidthによって推定される）、必要に応じて最初の文字をreplacementで置き換えます。デフォルトの置き換え文字列は"…"です。

例

julia> s = ltruncate("🍕🍕 I love 🍕", 10)
"…I love 🍕"

julia> textwidth(s)
10

julia> ltruncate("foo", 3)
"foo"

他にrtruncateやctruncateも参照してください。

rtruncate(str::AbstractString, maxwidth::Integer, replacement::Union{AbstractString,AbstractChar} = '…')

strを最大でmaxwidth列に切り詰めます（textwidthによって推定されるように）、必要に応じて最後の文字をreplacementで置き換えます。デフォルトの置き換え文字列は"…"です。

例

julia> s = rtruncate("🍕🍕 I love 🍕", 10)
"🍕🍕 I lo…"

julia> textwidth(s)
10

julia> rtruncate("foo", 3)
"foo"

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

ctruncate(str::AbstractString, maxwidth::Integer, replacement::Union{AbstractString,AbstractChar} = '…'; prefer_left::Bool = true)

strを最大でmaxwidth列に切り詰めます（textwidthによって推定される）、必要に応じて中央の文字をreplacementで置き換えます。デフォルトの置き換え文字列は"…"です。デフォルトでは、切り詰めは左側の文字を保持することを優先しますが、prefer_leftをfalseに設定することで変更できます。

例

julia> s = ctruncate("🍕🍕 I love 🍕", 10)
"🍕🍕 …e 🍕"

julia> textwidth(s)
10

julia> ctruncate("foo", 3)
"foo"

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

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(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

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があります。

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::Regex)

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

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

例

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

startswith(prefix)

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

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

例

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

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

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

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

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

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

endswithやcontainsも参照してください。

例

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

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

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

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

例

julia> endswith("JuliaLang", r"Lang|Roberts")
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::Union{AbstractString,Base.Chars})

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

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

例

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

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)との一貫性のために提供されています。

他にも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

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(s::AbstractString)

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

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

例

julia> uppercase("Julia")
"JULIA"

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)

lowercase(s::AbstractString)

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

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

例

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

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)

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

sの各単語の最初の文字を大文字にします。strictがtrueの場合、他のすべての文字は小文字に変換されます。そうでない場合は、変更されずにそのまま残ります。デフォルトでは、新しいグラフemeを開始するすべての非文字は単語の区切りと見なされます。どの文字を単語の区切りと見なすかを決定するために、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"

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)

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

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

関連項目 chop。

例

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

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

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

例

julia> thisind("α", 0)
0

julia> thisind("α", 1)
1

julia> thisind("α", 2)
1

julia> thisind("α", 3)
3

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

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

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

• ケース n == 1

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

• ケース n > 1

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

• ケース n == 0

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

例

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

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

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

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

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

• ケース n == 1

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

• ケース n > 1

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

• ケース n == 0

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

例

julia> prevind("α", 3)
1

julia> prevind("α", 1)
0

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

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

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

textwidth(s::AbstractString)

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

例

julia> textwidth("March")
5

textwidth(c)

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

例

julia> textwidth('α')
1

julia> textwidth('⛵')
2

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

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

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"

iscntrl(c::AbstractChar) -> Bool

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

例

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

isdigit(c::AbstractChar) -> Bool

文字がASCIIの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('=')
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=(), ascii=false, fullhex=false)::AbstractString
escape_string(io, str::AbstractString[, esc]; keep=())::Nothing

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

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

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

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

引数asciiは、すべての非ASCII文字をエスケープするためにtrueに設定できますが、デフォルトのascii=falseは表示可能なUnicode文字をそのまま出力します（keepがasciiよりも優先されます）。

引数fullhexは、すべての\uエスケープを4桁の16進数で出力し、\Uエスケープを8桁の16進数で出力するためにtrueに設定できますが、デフォルトでは（fullhex=false）可能な限り桁数を少なくして出力します（先頭のゼロを省略します）。

逆の操作については、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++ コンパイラランタイムが期待するエスケープ規則でもあります。）

Base.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

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

より具体的には、ラベル付きの値で注釈を付けることができるラップされた文字列の周りのシンプルなラッパーです。

                           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(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!.

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のrange（または全体の文字列）にラベル付きの値(label, value)で注釈を付けます。既存のlabel注釈を削除するには、nothingの値を使用します。

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