...

パッケージ regexp

概要 ▾

regexp パッケージは,正規表現検索を実装します。

受け入れられる正規表現の構文は, Perl, Python ,およびその他の言語で使用されているのと同じ一般的な構文です。 より正確には, \C を除いて, RE2 の https://golang.org/s/re2syntax で記述されている構文です。 構文の概要については, go doc regexp/syntax を実行してください。

このパッケージによって渡される正規表現の実装は,入力のサイズにおいて時間的に線形に実行されることが保証されています。 (これは,正規表現のほとんどのオープンソース実装で保証されていない特徴です。) この特徴の詳細については,以下を参照してください。

https://swtch.com/~rsc/regexp/regexp1.html

またはオートマトン理論についての本。

すべての文字は UTF-8 エンコードのコードポイントです。

正規表現にマッチし,マッチしたテキストを識別する Regexp には 16 のメソッドがあります。 それらの名前は,この正規表現にマッチします。

Find(All)?(String)?(Submatch)?(Index)?

'All' が存在する場合,ルーチンは式全体の連続した重複しないマッチとマッチします。 直前のマッチに隣接する空のマッチは無視されます。 戻り値は,対応する 'All' 以外のルーチンの連続する戻り値を含むスライスです。 これらのルーチンは,追加の整数引数 n を取ります。 n >= 0 の場合,関数は最大 n 個のマッチ / 部分マッチを返します。 そうでなければ,すべてを返します。

'String' が存在する場合,引数は文字列です。 そうでなければ,それはバイトスライスです。 戻り値は適切に調整されます。

'Submatch' が存在する場合,戻り値は式の連続した部分マッチを識別するスライスです。 部分マッチは,正規表現内の括弧で囲まれた部分式 (キャプチャグループとも呼ばれます) の左括弧の順にマッチする部分です。 部分マッチ 0 は式全体のマッチ,部分マッチ 1 は最初の括弧で囲まれた部分式のマッチ,というように続きます。

'Index' が存在する場合,一致および部分一致は,入力文字列内のバイトインデックスペアによって識別されます。 result[2*n:2*n+1] は, n 番目の部分一致のインデックスを識別します。 n==0 のペアは,式全体の一致を識別します。 'Index' が存在しない場合,一致 / 部分マッチのテキストによって一致が識別されます。 インデックスが負の場合,またはテキストが nil の場合,サブ表現が入力内のどの文字列とも一致しなかったことを意味します。 'String' バージョンの場合,空の文字列は,一致しないか空の一致を意味します。

RuneReader から読み込まれたテキストに適用できるメソッドのサブセットもあります。

MatchReader, FindReaderIndex, FindReaderSubmatchIndex

このセットは増えるかもしれません。 正規表現のマッチはマッチによって返されたテキストを超えてテキストを調べる必要があるかもしれないことに注意してください,それで RuneReader からのテキストにマッチするメソッドはリターンする前に入力の遠くまで任意に読むかもしれません。

(このパターンとマッチしない方法は他にもいくつかあります。)

コード:

// 通常は初期化時に,式を 1 回コンパイルします。
// バックスラッシュを引用符で囲むことを避けるためにロー文字列を使用ます。
var validID = regexp.MustCompile(`^[a-z]+\[[0-9]+\]$`)

fmt.Println(validID.MatchString("adam[23]"))
fmt.Println(validID.MatchString("eve[7]"))
fmt.Println(validID.MatchString("Job[48]"))
fmt.Println(validID.MatchString("snakey"))

出力:

true
true
false
false

目次 ▾

func Match(pattern string, b []byte) (matched bool, err error)
func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)
func MatchString(pattern string, s string) (matched bool, err error)
func QuoteMeta(s string) string
type Regexp
    func Compile(expr string) (*Regexp, error)
    func CompilePOSIX(expr string) (*Regexp, error)
    func MustCompile(str string) *Regexp
    func MustCompilePOSIX(str string) *Regexp
    func (re *Regexp) Copy() *Regexp
    func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte
    func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte
    func (re *Regexp) Find(b []byte) []byte
    func (re *Regexp) FindAll(b []byte, n int) [][]byte
    func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
    func (re *Regexp) FindAllString(s string, n int) []string
    func (re *Regexp) FindAllStringIndex(s string, n int) [][]int
    func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string
    func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
    func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte
    func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int
    func (re *Regexp) FindIndex(b []byte) (loc []int)
    func (re *Regexp) FindReaderIndex(r io.RuneReader) (loc []int)
    func (re *Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int
    func (re *Regexp) FindString(s string) string
    func (re *Regexp) FindStringIndex(s string) (loc []int)
    func (re *Regexp) FindStringSubmatch(s string) []string
    func (re *Regexp) FindStringSubmatchIndex(s string) []int
    func (re *Regexp) FindSubmatch(b []byte) [][]byte
    func (re *Regexp) FindSubmatchIndex(b []byte) []int
    func (re *Regexp) LiteralPrefix() (prefix string, complete bool)
    func (re *Regexp) Longest()
    func (re *Regexp) Match(b []byte) bool
    func (re *Regexp) MatchReader(r io.RuneReader) bool
    func (re *Regexp) MatchString(s string) bool
    func (re *Regexp) NumSubexp() int
    func (re *Regexp) ReplaceAll(src, repl []byte) []byte
    func (re *Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
    func (re *Regexp) ReplaceAllLiteral(src, repl []byte) []byte
    func (re *Regexp) ReplaceAllLiteralString(src, repl string) string
    func (re *Regexp) ReplaceAllString(src, repl string) string
    func (re *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string
    func (re *Regexp) Split(s string, n int) []string
    func (re *Regexp) String() string
    func (re *Regexp) SubexpNames() []string

パッケージファイル

backtrack.go exec.go onepass.go regexp.go

func Match

func Match(pattern string, b []byte) (matched bool, err error)

Match は,バイトスライス b に正規表現パターンのマッチが含まれているかどうかを報告します。 もっと複雑なクエリは Compile と完全な Regexp インターフェースを使う必要があります。

コード:

matched, err := regexp.Match(`foo.*`, []byte(`seafood`))
fmt.Println(matched, err)
matched, err = regexp.Match(`bar.*`, []byte(`seafood`))
fmt.Println(matched, err)
matched, err = regexp.Match(`a(b`, []byte(`seafood`))
fmt.Println(matched, err)

出力:

true <nil>
false <nil>
false error parsing regexp: missing closing ): `a(b`

func MatchReader

func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)

MatchReader は, RuneReader によって返されたテキストに正規表現パターンのマッチが含まれているかどうかを報告します。 もっと複雑なクエリは Compile と完全な Regexp インターフェースを使う必要があります。

func MatchString

func MatchString(pattern string, s string) (matched bool, err error)

MatchString は,文字列 s に正規表現パターンのマッチが含まれているかどうかを報告します。 もっと複雑なクエリは Compile と完全な Regexp インターフェースを使う必要があります。

コード:

matched, err := regexp.MatchString(`foo.*`, "seafood")
fmt.Println(matched, err)
matched, err = regexp.MatchString(`bar.*`, "seafood")
fmt.Println(matched, err)
matched, err = regexp.MatchString(`a(b`, "seafood")
fmt.Println(matched, err)

出力:

true <nil>
false <nil>
false error parsing regexp: missing closing ): `a(b`

func QuoteMeta

func QuoteMeta(s string) string

QuoteMeta は,引数 text 内のすべての正規表現メタ文字をエスケープする文字列を返します。 返される文字列は,リテラルテキストとマッチする正規表現です。

コード:

fmt.Println(regexp.QuoteMeta(`Escaping symbols like: .+*?()|[]{}^$`))

出力:

Escaping symbols like: \.\+\*\?\(\)\|\[\]\{\}\^\$

type Regexp

Regexp は,コンパイルされた正規表現の表現です。 正規表現は, Longest などの設定方法を除いて,複数のゴルーチンによる平行使用に対して安全です。

type Regexp struct {
    // エクスポートされていないフィールドがあります
}

func Compile

func Compile(expr string) (*Regexp, error)

Compile は正規表現を解析し,成功すれば,テキストとの照合に使用できる Regexp オブジェクトを返します。

テキストと照合するとき,正規表現は入力のできるだけ早い (最も左の) マッチを返し,その中からバックトラック検索が最初に見つけたものを選びます。 このいわゆる一番左のマッチングは, Perl, Python ,および他の実装が使用しているのと同じセマンティクスですが,このパッケージではバックトラックをかけずに実装します。 POSIX の左端最長マッチについては, CompilePOSIX を参照してください。

func CompilePOSIX

func CompilePOSIX(expr string) (*Regexp, error)

CompilePOSIX は Compile に似ていますが,正規表現を POSIX ERE (egrep) 構文に制限し,マッチの意味を最左端に変更します。

つまり,テキストとのマッチング時には,正規表現は入力のできるだけ早い方 (一番左) から始まるマッチングを返し,その中でできるだけ長いものを選択します。 このいわゆる最左端のマッチングは,初期の正規表現の実装で使用されていたものと POSIX で規定されているものと同じセマンティクスです。

しかし,部分マッチの選択肢が異なる,最も左から最も長い複数のマッチがある可能性があり,ここではこのパッケージは POSIX とは異なります。 可能性のある最も左から最も長いマッチの中で,このパッケージはバックトラッキング検索が最初に見つけたであろうものを選択しますが, POSIX は最初の部分式の長さを最大にするためにマッチを選択します。 。 POSIX 規則は計算上高価で,明確に定義されていません。 詳しくは https://swtch.com/~rsc/regexp/regexp2.html#posix をご覧ください。

func MustCompile

func MustCompile(str string) *Regexp

MustCompile は Compile に似ていますが,式を解析できない場合はパニックします。 コンパイルされた正規表現を保持するグローバル変数の安全な初期化を単純化します。

func MustCompilePOSIX

func MustCompilePOSIX(str string) *Regexp

MustCompilePOSIX は CompilePOSIX に似ていますが,式を解析できない場合はパニックします。 コンパイルされた正規表現を保持するグローバル変数の安全な初期化を単純化します。

func (*Regexp) Copy 1.6

func (re *Regexp) Copy() *Regexp

Copy は re からコピーされた新しい Regexp オブジェクトを返します。 あるコピーで Longest を呼び出しても,別のコピーには影響しません。

非推奨: 以前のリリースでは,複数の goroutine で Regexp を使用しているときに,各 goroutine に独自のコピーを指定すると,ロック競合を回避するのに役立ちました。 Go 1.12 以降,ロック競合を回避するために Copy を使用する必要がなくなりました。 コピーを使用する理由が,異なる最長設定で 2 つのコピーを作成することである場合は,コピーが依然として適切な場合があります。

func (*Regexp) Expand

func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte

Expand は dst にテンプレートを追加して結果を返します。 追加時に, Expand はテンプレート内の変数を, src から抽出された対応するマッチで置き換えます。 マッチスライスは FindSubmatchIndex によって返されたはずです。

テンプレートでは,変数は $name または ${name} の形式の部分文字列で表されます。 ここで, name は空ではない一連の文字,数字,およびアンダースコアです。 $1 のような純粋に数値の名前は,対応するインデックスを持つ部分マッチを参照します。 他の名前は, (?P< 名前 >...) という構文で命名された括弧を取り込むことを指します。 範囲外またはマッチしないインデックスへの参照,または正規表現に存在しない名前は,空のスライスに置き換えられます。

$name 形式では, name は可能な限り長くなるように解釈されます。 $1x は ${1}x ではなく ${1x} と同じです。 $10 は ${1}0 ではなく ${10} と同じです。

出力にリテラル $ を挿入するには,テンプレートで $$ を使用します。

コード:

content := []byte(`
    # comment line
    option1: value1
    option2: value2

    # another comment line
    option3: value3
`)

// 正規表現パターンは,コンテンツから "キー: 値" のペアをキャプチャします。
pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)

// 正規表現パターンによって取り込まれた値を参照して, "key: value" を "key=value" に変換するためのテンプレート。
template := []byte("$key=$value\n")

result := []byte{}

// コンテンツ内の正規表現のマッチごとに。
for _, submatches := range pattern.FindAllSubmatchIndex(content, -1) {
    // キャプチャした部分マッチをテンプレートに適用し,結果に結果を追加します。
    result = pattern.Expand(result, template, content, submatches)
}
fmt.Println(string(result))

出力:

option1=value1
option2=value2
option3=value3

func (*Regexp) ExpandString

func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte

ExpandString は Expand に似ていますが,テンプレートとソースは文字列です。 呼び出しコードに割り当てを制御させるために,バイトスライスを追加して返します。

コード:

content := `
    # comment line
    option1: value1
    option2: value2

    # another comment line
    option3: value3
`

// 正規表現パターンは,コンテンツから "キー: 値" のペアをキャプチャします。
pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)

// 正規表現パターンによって取り込まれた値を参照して, "key: value" を "key=value" に変換するためのテンプレート。
template := "$key=$value\n"

result := []byte{}

// コンテンツ内の正規表現のマッチごとに。
for _, submatches := range pattern.FindAllStringSubmatchIndex(content, -1) {
    // キャプチャした部分マッチをテンプレートに適用し,結果に結果を追加します。
    result = pattern.ExpandString(result, template, content, submatches)
}
fmt.Println(string(result))

出力:

option1=value1
option2=value2
option3=value3

func (*Regexp) Find

func (re *Regexp) Find(b []byte) []byte

Find は正規表現の b の左端のマッチのテキストを保持するスライスを返します。 戻り値 nil は,マッチしないことを示します。

コード:

re := regexp.MustCompile(`foo.?`)
fmt.Printf("%q\n", re.Find([]byte(`seafood fool`)))

出力:

"food"

func (*Regexp) FindAll

func (re *Regexp) FindAll(b []byte, n int) [][]byte

FindAll は Find の 'All' バージョンです。 パッケージコメントの 'All' の説明で定義されているように,正規表現の連続するすべてのマッチのスライスを返します。 戻り値 nil は,マッチしないことを示します。

コード:

re := regexp.MustCompile(`foo.?`)
fmt.Printf("%q\n", re.FindAll([]byte(`seafood fool`), -1))

出力:

["food" "fool"]

func (*Regexp) FindAllIndex

func (re *Regexp) FindAllIndex(b []byte, n int) [][]int

FindAllIndex は FindIndex の 'All' バージョンです。 パッケージコメントの 'All' の説明で定義されているように,正規表現の連続するすべてのマッチのスライスを返します。 戻り値 nil は,マッチしないことを示します。

func (*Regexp) FindAllString

func (re *Regexp) FindAllString(s string, n int) []string

FindAllString は FindString の 'All' バージョンです。 パッケージコメントの 'All' の説明で定義されているように,正規表現の連続するすべてのマッチのスライスを返します。 戻り値 nil は,マッチしないことを示します。

コード:

re := regexp.MustCompile(`a.`)
fmt.Println(re.FindAllString("paranormal", -1))
fmt.Println(re.FindAllString("paranormal", 2))
fmt.Println(re.FindAllString("graal", -1))
fmt.Println(re.FindAllString("none", -1))

出力:

[ar an al]
[ar an]
[aa]
[]

func (*Regexp) FindAllStringIndex

func (re *Regexp) FindAllStringIndex(s string, n int) [][]int

FindAllStringIndex は, FindStringIndex の 'All' バージョンです。 パッケージコメントの 'All' の説明で定義されているように,正規表現の連続するすべてのマッチのスライスを返します。 戻り値 nil は,マッチしないことを示します。

func (*Regexp) FindAllStringSubmatch

func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string

FindAllStringSubmatch は, FindStringSubmatch の 'All' バージョンです。 パッケージコメントの 'All' の説明で定義されているように,正規表現の連続するすべてのマッチのスライスを返します。 戻り値 nil は,マッチしないことを示します。

コード:

re := regexp.MustCompile(`a(x*)b`)
fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-", -1))
fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-", -1))
fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-axb-", -1))
fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-ab-", -1))

出力:

[["ab" ""]]
[["axxb" "xx"]]
[["ab" ""] ["axb" "x"]]
[["axxb" "xx"] ["ab" ""]]

func (*Regexp) FindAllStringSubmatchIndex

func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int

FindAllStringSubmatchIndex は, FindStringSubmatchIndex の 'All' バージョンです。 パッケージコメントの 'All' の説明で定義されているように,正規表現の連続するすべてのマッチのスライスを返します。 戻り値 nil は,マッチしないことを示します。

コード:

re := regexp.MustCompile(`a(x*)b`)
// インデックス:
//    01234567   012345678
//    -ab-axb-   -axxb-ab-
fmt.Println(re.FindAllStringSubmatchIndex("-ab-", -1))
fmt.Println(re.FindAllStringSubmatchIndex("-axxb-", -1))
fmt.Println(re.FindAllStringSubmatchIndex("-ab-axb-", -1))
fmt.Println(re.FindAllStringSubmatchIndex("-axxb-ab-", -1))
fmt.Println(re.FindAllStringSubmatchIndex("-foo-", -1))

出力:

[[1 3 2 2]]
[[1 5 2 4]]
[[1 3 2 2] [4 7 5 6]]
[[1 5 2 4] [6 8 7 7]]
[]

func (*Regexp) FindAllSubmatch

func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte

FindAllSubmatch は FindSubmatch の 'All' バージョンです。 パッケージコメントの 'All' の説明で定義されているように,正規表現の連続するすべてのマッチのスライスを返します。 戻り値 nil は,マッチしないことを示します。

コード:

re := regexp.MustCompile(`foo(.?)`)
fmt.Printf("%q\n", re.FindAllSubmatch([]byte(`seafood fool`), -1))

出力:

[["food" "d"] ["fool" "l"]]

func (*Regexp) FindAllSubmatchIndex

func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int

FindAllSubmatchIndex は, FindSubmatchIndex の 'All' バージョンです。 パッケージコメントの 'All' の説明で定義されているように,正規表現の連続するすべてのマッチのスライスを返します。 戻り値 nil は,マッチしないことを示します。

コード:

content := []byte(`
    # comment line
    option1: value1
    option2: value2
`)
// 正規表現パターンは,コンテンツから "キー: 値" のペアをキャプチャします。
pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)
allIndexes := pattern.FindAllSubmatchIndex(content, -1)
for _, loc := range allIndexes {
    fmt.Println(loc)
    fmt.Println(string(content[loc[0]:loc[1]]))
    fmt.Println(string(content[loc[2]:loc[3]]))
    fmt.Println(string(content[loc[4]:loc[5]]))
}

出力:

[18 33 18 25 27 33]
option1: value1
option1
value1
[35 50 35 42 44 50]
option2: value2
option2
value2

func (*Regexp) FindIndex

func (re *Regexp) FindIndex(b []byte) (loc []int)

FindIndex は,正規表現の b の最も左にあるマッチの位置を定義する 2 要素整数のスライスを返します。 マッチ自体は b[loc[0]:loc[1]] です。 戻り値 nil は,マッチしないことを示します。

コード:

content := []byte(`
    # comment line
    option1: value1
    option2: value2
`)
// 正規表現パターンは,コンテンツから "キー: 値" のペアをキャプチャします。
pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)

loc := pattern.FindIndex(content)
fmt.Println(loc)
fmt.Println(string(content[loc[0]:loc[1]]))

出力:

[18 33]
option1: value1

func (*Regexp) FindReaderIndex

func (re *Regexp) FindReaderIndex(r io.RuneReader) (loc []int)

FindReaderIndex は, RuneReader から読み込まれたテキスト内の正規表現の左端にマッチする位置を定義する整数の 2 要素スライスを返します。 見つかったマッチテキストは,入力テキストのバイトオフセット loc[0] から loc[1]-1 までです。 戻り値 nil は,マッチしないことを示します。

func (*Regexp) FindReaderSubmatchIndex

func (re *Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int

FindReaderSubmatchIndex は,パッケージのコメントの 'Submatch' と 'Index' の記述で定義されているように, RuneReader によって読み込まれたテキストの正規表現の左端のマッチと,その部分式のマッチを識別するインデックスペアを保持するスライスを返します。 戻り値 nil は,マッチしないことを示します。

func (*Regexp) FindString

func (re *Regexp) FindString(s string) string

FindString は正規表現の s の中で最も左にマッチするテキストを保持する文字列を返します。 マッチしない場合,戻り値は空の​​文字列ですが,正規表現が空の文字列と正常にマッチした場合も戻り値は空になります。 これらのケースを区別する必要がある場合は, FindStringIndex または FindStringSubmatch を使用してください。

コード:

re := regexp.MustCompile(`foo.?`)
fmt.Printf("%q\n", re.FindString("seafood fool"))
fmt.Printf("%q\n", re.FindString("meat"))

出力:

"food"
""

func (*Regexp) FindStringIndex

func (re *Regexp) FindStringIndex(s string) (loc []int)

FindStringIndex は,正規表現の s の左端にマッチする位置を定義する整数の 2 要素スライスを返します。 マッチ自体は s[loc[0]:loc[1]] です。 戻り値 nil は,マッチしないことを示します。

コード:

re := regexp.MustCompile(`ab?`)
fmt.Println(re.FindStringIndex("tablett"))
fmt.Println(re.FindStringIndex("foo") == nil)

出力:

[1 3]
true

func (*Regexp) FindStringSubmatch

func (re *Regexp) FindStringSubmatch(s string) []string

FindStringSubmatch は,パッケージコメント内の 'Submatch' の説明で定義されているように, s 内の正規表現の左端にマッチするテキストと,その部分式のマッチがある場合はそのテキストを保持する文字列のスライスを返します。 戻り値 nil は,マッチしないことを示します。

コード:

re := regexp.MustCompile(`a(x*)b(y|z)c`)
fmt.Printf("%q\n", re.FindStringSubmatch("-axxxbyc-"))
fmt.Printf("%q\n", re.FindStringSubmatch("-abzc-"))

出力:

["axxxbyc" "xxx" "y"]
["abzc" "" "z"]

func (*Regexp) FindStringSubmatchIndex

func (re *Regexp) FindStringSubmatchIndex(s string) []int

FindStringSubmatchIndex は,パッケージのコメント内の 'Submatch' と 'Index' の説明で定義されているように, s 内の正規表現の左端のマッチを識別するためのインデックスペアとその部分式のマッチを保持するスライスを返します。 戻り値 nil は,マッチしないことを示します。

func (*Regexp) FindSubmatch

func (re *Regexp) FindSubmatch(b []byte) [][]byte

FindSubmatch は,パッケージコメントの 'Submatch' の説明で定義されているように, b の正規表現の左端にマッチするテキストと,その部分式がマッチした場合はそのテキストを保持するスライスのスライスを返します。 戻り値 nil は,マッチしないことを示します。

コード:

re := regexp.MustCompile(`foo(.?)`)
fmt.Printf("%q\n", re.FindSubmatch([]byte(`seafood fool`)))

出力:

["food" "d"]

func (*Regexp) FindSubmatchIndex

func (re *Regexp) FindSubmatchIndex(b []byte) []int

FindSubmatchIndex は,パッケージコメントの 'Submatch' と 'Index' の記述で定義されているように, b の正規表現の左端のマッチと,もしあればその部分式のマッチを識別するインデックスペアを保持するスライスを返します。 戻り値 nil は,マッチしないことを示します。

func (*Regexp) LiteralPrefix

func (re *Regexp) LiteralPrefix() (prefix string, complete bool)

LiteralPrefix は,正規表現 re の任意のマッチを開始する必要があるリテラル文字列を返します。 リテラル文字列が正規表現全体を構成する場合は,ブール値の true を返します。

func (*Regexp) Longest 1.1

func (re *Regexp) Longest()

Longest は,将来の検索で最も左から最も長いものが優先されます。 つまり,テキストとのマッチング時には,正規表現は入力のできるだけ早い方 (一番左) から始まるマッチングを返し,その中でできるだけ長いものを選択します。 このメソッドは Regexp を変更し,他のメソッドと平行に呼び出すことはできません。

func (*Regexp) Match

func (re *Regexp) Match(b []byte) bool

Match は,バイトスライス b に正規表現 re のマッチが含まれているかどうかを報告します。

コード:

re := regexp.MustCompile(`foo.?`)
fmt.Println(re.Match([]byte(`seafood fool`)))

出力:

true

func (*Regexp) MatchReader

func (re *Regexp) MatchReader(r io.RuneReader) bool

MatchReader は, RuneReader によって返されたテキストに正規表現 re のマッチが含まれているかどうかを報告します。

func (*Regexp) MatchString

func (re *Regexp) MatchString(s string) bool

MatchString は,文字列 s に正規表現 re のマッチが含まれているかどうかを報告します。

コード:

re := regexp.MustCompile(`(gopher){2}`)
fmt.Println(re.MatchString("gopher"))
fmt.Println(re.MatchString("gophergopher"))
fmt.Println(re.MatchString("gophergophergopher"))

出力:

false
true
true

func (*Regexp) NumSubexp

func (re *Regexp) NumSubexp() int

NumSubexp は,この正規表現内の括弧で囲まれた部分式の数を返します。

func (*Regexp) ReplaceAll

func (re *Regexp) ReplaceAll(src, repl []byte) []byte

ReplaceAll は, Regexp のマッチを置換テキスト repl に置き換えた src のコピーを返します。 repl の中では, $ 記号は Expand のように解釈されるので,たとえば $1 は最初の部分マッチのテキストを表します。

func (*Regexp) ReplaceAllFunc

func (re *Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte

ReplaceAllFunc は, Regexp のすべてのマッチが,関数 repl をマッチしたバイトスライスに適用した戻り値で置き換えられた src のコピーを返します。 repl によって返された置換は, Expand を使用せずに直接置き換えられます。

func (*Regexp) ReplaceAllLiteral

func (re *Regexp) ReplaceAllLiteral(src, repl []byte) []byte

ReplaceAllLiteral は, Regexp のマッチを置換バイト repl に置き換えた src のコピーを返します。 Expand を使用せずに,置換 repl が直接置き換えられます。

func (*Regexp) ReplaceAllLiteralString

func (re *Regexp) ReplaceAllLiteralString(src, repl string) string

ReplaceAllLiteralString は Regexp のマッチを置換文字列 repl で置き換えた src のコピーを返します。 Expand を使用せずに,置換 repl が直接置き換えられます。

コード:

re := regexp.MustCompile(`a(x*)b`)
fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "T"))
fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "$1"))
fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "${1}"))

出力:

-T-T-
-$1-$1-
-${1}-${1}-

func (*Regexp) ReplaceAllString

func (re *Regexp) ReplaceAllString(src, repl string) string

ReplaceAllString は Regexp のマッチを置換文字列 repl に置き換えた src のコピーを返します。 repl の中では, $ 記号は Expand のように解釈されるので,たとえば $1 は最初の部分マッチのテキストを表します。

コード:

re := regexp.MustCompile(`a(x*)b`)
fmt.Println(re.ReplaceAllString("-ab-axxb-", "T"))
fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1"))
fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1W"))
fmt.Println(re.ReplaceAllString("-ab-axxb-", "${1}W"))

出力:

-T-T-
--xx-
---
-W-xxW-

func (*Regexp) ReplaceAllStringFunc

func (re *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string

ReplaceAllStringFunc は,正規表現のすべてのマッチが,マッチした部分文字列に適用された関数 repl の戻り値に置き換えられた src のコピーを返します。 repl によって返された置換は, Expand を使用せずに直接置き換えられます。

コード:

re := regexp.MustCompile(`[^aeiou]`)
fmt.Println(re.ReplaceAllStringFunc("seafood fool", strings.ToUpper))

出力:

SeaFooD FooL

func (*Regexp) Split 1.1

func (re *Regexp) Split(s string, n int) []string

Split は, s を正規表現で部分文字列に分割し,マッチの間にある部分文字列のスライスを返します。

このメソッドによって返されるスライスは, FindAllString によって返されるスライスに含まれていない s のすべての部分文字列で構成されています。 メタ文字を含まない式で呼び出されると, strings.SplitN と同等になります。

例:

s := regexp.MustCompile("a*").Split("abaabaccadaaae", 5)
// s: ["", "b", "b", "c", "cadaaae"]

count は,返される部分文字列の数を決定します。

n > 0: 最大で n 個の部分文字列。
最後の部分文字列は分割されていない残りの部分になります。
n == 0: 結果は nil (ゼロ部分文字列)
n<0: すべての部分文字列

コード:

a := regexp.MustCompile(`a`)
fmt.Println(a.Split("banana", -1))
fmt.Println(a.Split("banana", 0))
fmt.Println(a.Split("banana", 1))
fmt.Println(a.Split("banana", 2))
zp := regexp.MustCompile(`z+`)
fmt.Println(zp.Split("pizza", -1))
fmt.Println(zp.Split("pizza", 0))
fmt.Println(zp.Split("pizza", 1))
fmt.Println(zp.Split("pizza", 2))

出力:

[b n n ]
[]
[banana]
[b nana]
[pi a]
[]
[pizza]
[pi a]

func (*Regexp) String

func (re *Regexp) String() string

String は,正規表現のコンパイルに使用されたソーステキストを返します。

func (*Regexp) SubexpNames

func (re *Regexp) SubexpNames() []string

SubexpNames は,この正規表現内の括弧で囲まれた部分式の名前を返します。 最初の部分式の名前は names[1] です。 したがって, m がマッチスライスの場合, m[i] の名前は SubexpNames()[i] になります。 Regexp 全体として名前を付けることはできないので, names[0] は常に空の文字列です。 スライスは変更しないでください。

コード:

re := regexp.MustCompile(`(?P<first>[a-zA-Z]+) (?P<last>[a-zA-Z]+)`)
fmt.Println(re.MatchString("Alan Turing"))
fmt.Printf("%q\n", re.SubexpNames())
reversed := fmt.Sprintf("${%s} ${%s}", re.SubexpNames()[2], re.SubexpNames()[1])
fmt.Println(reversed)
fmt.Println(re.ReplaceAllString("Alan Turing", reversed))

出力:

true
["" "first" "last"]
${last} ${first}
Turing Alan

サブディレクトリ

名前 概要
..
syntax syntax パッケージは,正規表現をパースしてパースツリーを作成し,パースツリーをコンパイルしてプログラムにします。