...

パッケージ regexp

概要 ▾

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

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

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

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

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

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

正規表現に一致し,一致したテキストを識別する Regexp には 16 の方法があります。 それらの名前は,この正規表現によって照合されます。

(すべて)?(文字列)?(サブマッチ)?(インデックス)?

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

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

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

If 'Index' is present, matches and submatches are identified by byte index pairs within the input string: result[2*n:2*n+1] identifies the indexes of the nth submatch. The pair for n==0 identifies the match of the entire expression. If 'Index' is not present, the match is identified by the text of the match/submatch. If an index is negative or text is nil, it means that subexpression did not match any string in the input. For 'String' versions an empty string means either no match or an empty match.

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"))
// 出力 :truetruefalsefalse

目次 ▾

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)

一致は,バイトスライス 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 の正規表現の解析エラー : 閉じていません):`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 の正規表現の解析エラー : 閉じていません):`a(b`

func QuoteMeta

func QuoteMeta(s string) string

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

コード:

fmt.Println(regexp.QuoteMeta(`Escaping symbols like: .+*?()|[]{}^$`))
// 出力 :\ 。
// \+\*\?\(\)\|\[\]\{\}\^\$ のようにエスケープ記号

type Regexp

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

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

func Compile

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

コンパイルは正規表現を解析し,成功すれば,テキストとの照合に使用できる 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} ではなく ${10} と同じです。 0 。

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

コード:

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=value1option2=value2option3=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=value1option2=value2option3=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`)))

// 出力 :" 食べ物 "

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

// 出力 :[" 食べ物 " " ばか "]

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))
// 出力 :[aranal][aran][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`)
// 指標 :01234567012345678-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))
// 出力 :[[1322]][[1524]][[1322][4756]][[1524][6877]][]

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]]))
}
// 出力 :[183318252733]option1:value1option1value1[355035424450]option2:value2option2value2

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]]))
// 出力 :[1833]option1: 値 1

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"))
// 出力 :" 食べ物 "
// ""

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)
// 出力 :[13]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()

最長では,将来の検索で最も左から最も長いものが優先されます。 つまり,テキストとのマッチング時には,正規表現は入力のできるだけ早い方 (一番左) から始まるマッチングを返し,その中でできるだけ長いものを選択します。 このメソッドは 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"))
// 出力 :falsetruetruetrue

func (*Regexp) NumSubexp

func (re *Regexp) NumSubexp() int

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

func (*Regexp) ReplaceAll

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

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

func (*Regexp) ReplaceAllFunc

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

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

func (*Regexp) ReplaceAllLiteral

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

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

func (*Regexp) ReplaceAllLiteralString

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

ReplaceAllLiteralString は src のコピーを返し, Regexp の一致を置換文字列 repl で置き換えます。 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 は src のコピーを返し, Regexp の一致を置換文字列 repl に置き換えます。 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

スライス 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))
// 出力 :[bnn][][banana][bnana][pia][][pizza][pia]

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 パッケージは,正規表現をパースしてパースツリーを作成し,パースツリーをコンパイルしてプログラムにします。