Go Regex（正規表現）

Go Regexパッケージは文字列を検索するために使用されます。検索するために、文字列パターンを提供する必要があります。

私たちはパターンをregexオブジェクトにコンパイルする必要があります。そうすることで、そのオブジェクトを通じてメソッドを呼び出すことができます。

compile()とmustcompile()関数を使用して正規表現オブジェクトを取得することができます。今や、関数を使用して文字列を検索することができます。例えば、FindString()、FindStringSubmatch()、FindStringIndex()などです。

正規表現の例1

例

package　main
import　(
	"fmt"
	"regexp"
)
func　main()　{
	re　:=　regexp.MustCompile(".com")
	fmt.Println(re.FindString("oldtoolbag.com"))
	fmt.Println(re.FindString("abc.org"))
	fmt.Println(re.FindString("fb.com"))
}

出力：

.com
.com

FindString()メソッドは、最も左側の一致するテキストを持つ文字列を返します。一致項が見つからない場合、空文字列が返されます。

正規表現の例2

例

package　main
import　(
	"fmt"
	"regexp"
)
func　main()　{
	re　:=　regexp.MustCompile(".com")
	fmt.Println(re.FindStringIndex("google.com"))
	fmt.Println(re.FindStringIndex("abc.org"))
	fmt.Println(re.FindStringIndex("fb.com"))
}

出力：

[6　10]
[]
[2　6]

正規表現の例3

私たちは、FindStringSubmatch()メソッドを使用することができます。このメソッドは、最も左側の一致項と一致項のテキストを持つ文字列スライスを返します。一致項が見つからない場合、空文字列が返されます。

例

package　main
import　(
	"fmt"
	"regexp"
)
func　main()　{
	re　:=　regexp.MustCompile("f([a-z]+)ing")
	fmt.Println(re.FindStringSubmatch("flying"))
	fmt.Println(re.FindStringSubmatch("abcfloatingxyz"))
}

出力：

[flying　ly]
[floating　loat]
Process finished with exit code 0

Go 言語正則表現 regexp パッケージの常用メソッド

Go言語の正則表現のマッチングは、Go言語のregexpパッケージを使用することができます。 　

Go言語の正則表現は他の言語の正則表現のルールと同じですが、呼び出す関数が異なります。 　　

正則表現を構築する際には、`pattern`形式を使用することをお勧めします。

regexp.Match

//　bに正則表現patternが一致するサブストリングが見つかるかどうかを判定します。
//　pattern：要查找的正規表現
//　b：その中で検索を行う　[]byte
//　matched：返回是否找到匹配項
//　err：返回查找過程中遇到的任何錯誤
//　此函數通過調用 Regexp 的方法實現
func Match(pattern string, b []byte) (matched bool, err error)

在线示例

package　main
　
import　(
　　　　"fmt"
　　　　"regexp"
)
　
func　main()　{
　　　　matched,　err　:=　regexp.Match("^abc.*z$",　[]byte("abcdefgz"))
　　　　fmt.Println(matched,　err)　//true　nil
　
　　　　matched,　err　=　regexp.Match("^abc.*z$",　[]byte("bcdefgz"))
　　　　fmt.Println(matched,　err)　//false　nil
}

regexp.MatchString

//　sに正則表現patternが一致するサブストリングが見つかるかどうかを判定します。
　//　pattern：要查找的正規表現
　//　r：要在其中進行查找的字符串
　//　matched：返回是否找到匹配項
　//　err：返回查找過程中遇到的任何錯誤
　//　此函數通過調用 Regexp 的方法實現
　
　func MatchString(pattern string, s string) (matched bool, err error)

在线示例

package　main
　
import　(
　　　　"fmt"
　　　　"regexp"
)
　
func　main()　{
　　　　matched,　err　:=　regexp.MatchString("^abc.*z$",　"abcdefgz")
　　　　fmt.Println(matched,　err)　//true　<nil>
　
　　　　matched,　err　=　regexp.MatchString("^abc.*z$",　"bcdefgz")
　　　　fmt.Println(matched,　err)　//false　<nil>
}

regexp.Compile

//　Compileは正則表現exprが有効かどうかを解析し、有効な場合はRegexpオブジェクトを返します。
//　Regexp 对象可以在任意文本上执行需要的操作
func Compile(expr string) (*Regexp, error)

返しいた正則表現のオブジェクトポインタが得られます。返り値を使用して、Match、MatchString、findなどの定義されたメソッドを呼び出すことができます。

在线示例

//func Compile(expr string) (*Regexp, error)
r,　_　:=　regexp.Compile(`f([a-z]+)`)
　
//func　(re　*Regexp)　Match(b　[]byte)　bool
fmt.Println(r.Match([]byte("foo")))　//true
　
//func　(re　*Regexp)　MatchString(s　string)　bool
fmt.Println(r.MatchString("foo"))　//true
　
//func　(re　*Regexp) FindString(s string) string
//只匹配一次
fmt.Println(r.FindString("foo　func"))　//foo
　
//func　(re　*Regexp)　FindStringIndex(s　string)　(loc　[]int)
fmt.Println(r.FindStringIndex("demo　foo　func"))　//[5　8]
　
//func　(re　*Regexp)　FindStringSubmatch(s　string)　[]string
//一度だけマッチし、結果のインデックス0の値は全体のマッチ文字列の値、次の値は子式の値
fmt.Println(r.FindStringSubmatch("this　foo　func　fan"))　//[foo　oo]
　
//FindStringSubmatchに対して、式に子式がなければ子式を検出しません
demo,　_　:=　regexp.Compile(`foo`)
fmt.Println(demo.FindStringSubmatch("foo"))　//[foo]
　
//func　(re　*Regexp) FindStringSubmatchIndex(s string) []int
fmt.Println(r.FindStringSubmatchIndex("foo　func"))　//[0　3　1　3]
　
//func　(re　*Regexp)　FindAllString(s　string,　n　int)　[]string
//nが-1の時、すべての合致する文字列をマッチし、nは-1の時、n回だけマッチします
fmt.Println(r.FindAllString("foo　func　fan",　-1))　//[foo　func　fan]
fmt.Println(r.FindAllString("foo　func　fan",　2))　　//[foo　func]
　
//func　(re　*Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
//nもまたマッチ回数を表す、-1すべてのマッチを表す
fmt.Println(r.FindAllStringSubmatchIndex("foo　func　demo　fan",　-1))
//[[0　3　1　3]] [4　8　5　8]] [14　17　15　17]]
　
//置き換え
　
//func　(re　*Regexp)　ReplaceAll(src　[]byte,　repl　[]byte)　[]byte
fmt.Println(string(r.ReplaceAll([]byte("this　is　foo,　that　is　func,　they　are　fan"),　[]byte("x"))))
//this　is　x,　that　is　x,　they　are　x
　
//func　(re　*Regexp)　ReplaceAllString(src　string,　repl　string)　string
fmt.Println(r.ReplaceAllString("this　is　foo,　that　is　func,　they　are　fan",　"xx"))

regexp.MustCompileと上のregexp.Compileの使い方は似ている。

Go言語の正規表現regexpパッケージ詳細

//　regexp.go　詳細
------------------------------------------------------------
1.　[]byte　の中で正規表現　pattern　が一致するサブストリングを見つけるかどうかを判断
//　pattern：要查找的正規表現
//　b：その中で検索を行う　[]byte
//　matched：返回是否找到匹配項
//　err：返回查找過程中遇到的任何錯誤
//　此函數通過調用 Regexp 的方法實現
func Match(pattern string, b []byte) (matched bool, err error)
func　main()　{
fmt.Println(regexp.Match("H.*　", []byte("Hello World!")))
//　true
}
------------------------------------------------------------
2. 判斷在 r 中能否找到正規表現 pattern 所匹配的子串
//　pattern：要查找的正規表現
//　r：要在其中進行查找的 RuneReader 接口
//　matched：返回是否找到匹配項
//　err：返回查找過程中遇到的任何錯誤
//　此函數通過調用 Regexp 的方法實現
func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)
func　main()　{
r　:=　bytes.NewReader([]byte("Hello　World!"))
fmt.Println(regexp.MatchReader("H.*　", r))
//　true
}
------------------------------------------------------------
3. 判斷在 s 中能否找到正規表現 pattern 所匹配的子串
//　pattern：要查找的正規表現
//　r：要在其中進行查找的字符串
//　matched：返回是否找到匹配項
//　err：返回查找過程中遇到的任何錯誤
//　此函數通過調用 Regexp 的方法實現
func MatchString(pattern string, s string) (matched bool, err error)
func　main()　{
fmt.Println(regexp.Match("H.*　", "Hello World!"))
//　true
}
------------------------------------------------------------
4. QuoteMeta 將字符串 s 中的「特殊字符」轉換為其「轉義格式」
//　例如，QuoteMeta（`[foo]`）返回`
foo
`。
//　特殊字符有：\.+*?()|[]{}^$
//　這些字符用於實現正規語法，所以當作普通字符使用時需要轉換
func QuoteMeta(s string) string
func　main()　{
fmt.Println(regexp.QuoteMeta("(?P:Hello)　[a-z]"))
//　\?P:Hello
a−z
}
------------------------------------------------------------
5.Regexp 組織表示一個編譯後的正規表現
//　Regexp 的公開接口都是通過方法實現的
//　多個 goroutine 并發使用一個 RegExp 是安全的
type Regexp struct {
//　私有字段
}
//　通過 Compile、CompilePOSIX、MustCompile、MustCompilePOSIX
//　四個函數可以創建一個 Regexp 对象
------------------------------------------------------------
6.Compile 用以解析正規表現 expr 是否合法，如果合法，則返回一個 Regexp 对象
//　Regexp 对象可以在任意文本上执行需要的操作
func Compile(expr string) (*Regexp, error)
func　main()　{
reg, err := regexp.Compile(`\w+`)
fmt.Printf("%q,%v\n", reg.FindString("Hello World!"), err)
//　"Hello"
}
------------------------------------------------------------
7.CompilePOSIX 的作用和 Compile 一样
//　不同的是，CompilePOSIX 使用 POSIX 语法，
//　同时，它采用最左最长方式搜索，
//　而 Compile 采用最左最短方式搜索
//　POSIX 语法不支持 Perl 的语法格式：\d、\D、\s、\S、\w、\W
func CompilePOSIX(expr string) (*Regexp, error)
func　main()　{
reg, err := regexp.CompilePOSIX(`[[:word:]]+`)
fmt.Printf("%q,%v\n", reg.FindString("Hello World!"), err)
//　"Hello"
}
------------------------------------------------------------
8.MustCompile 的作用和 Compile 一样
//　不同的是，当正则表达式 str 不合法时，MustCompile 会抛出异常
//　而 Compile 仅返回一个 error 值
func MustCompile(str string)　*Regexp
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
//　Hello
}
------------------------------------------------------------
9.MustCompilePOSIX 的作用和 CompilePOSIX 一样
//　不同的是，当正则表达式 str 不合法时，MustCompilePOSIX 会抛出异常
//　而 CompilePOSIX 仅返回一个 error 值
func MustCompilePOSIX(str string)　*Regexp
func　main()　{
reg := regexp.MustCompilePOSIX(`[[:word:]].+　`)
fmt.Printf("%q\n", reg.FindString("Hello World!"))
//　"Hello "
}
------------------------------------------------------------
10. 在 []byte 中查找 re 中编译好的正则表达式，并返回第一个匹配的内容
func　(re　*Regexp) Find(b []byte) []byte
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q", reg.Find([]byte("Hello World!")))
//　"Hello"
}
------------------------------------------------------------
11. 在 string 中查找 re 中编译好的正则表达式，并返回第一个匹配的内容
func　(re　*Regexp) FindString(s string) string
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
//　"Hello"
}
------------------------------------------------------------
12.在　[]byte　中查找　re　中編集した正則表現式，並びにすべての一致内容を返します
//　{{一致項},　{一致項},　...}
//　nが0以下の場合、先頭n個のマッチのみを検索します。
func　(re　*Regexp)　FindAll(b　[]byte,　n　int)　[][]byte
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q",　reg.FindAll([]byte("Hello　World!"),　-1))
//　["Hello"　"World"]
}
------------------------------------------------------------
13string内で、reでコンパイルされた正則表現を検索し、すべての一致内容を返します
//　{一致項,　一致項,　...}
//　nが0以下の場合、先頭n個のマッチのみを検索します。
func　(re　*Regexp)　FindAllString(s　string,　n　int)　[]string
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q",　reg.FindAllString("Hello　World!",　-1))
//　["Hello"　"World"]
}
------------------------------------------------------------
14.　在　[]byte　中查找　re　中編集した正則表現式，並びに最初の一致位置を返します
//　{開始位置,　終了位置}
func　(re　*Regexp)　FindIndex(b　[]byte)　(loc　[]int)
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindIndex([]byte("Hello　World!")))
//　[0　5]
}
------------------------------------------------------------
15.　在　string　中查找　re　中編集した正則表現式，並びに最初の一致位置を返します
//　{開始位置,　終了位置}
func　(re　*Regexp)　FindStringIndex(s　string)　(loc　[]int)
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindStringIndex("Hello　World!"))
//　[0　5]
}
------------------------------------------------------------
16.rにreにコンパイルされた正規表現を検索し、最初のマッチ位置を返します。
//　{開始位置,　終了位置}
func　(re　*Regexp)　FindReaderIndex(r　io.RuneReader)　(loc　[]int)
func　main()　{
r　:=　bytes.NewReader([]byte("Hello　World!"))
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindReaderIndex(r))
//　[0　5]
}
------------------------------------------------------------
17.[]byteにreにコンパイルされた正規表現を検索し、すべてのマッチ位置を返します。
//　{{開始位置,　終了位置},　{開始位置,　終了位置},　...}
//　nが0以下の場合、先頭n個のマッチのみを検索します。
func　(re　*Regexp)　FindAllIndex(b　[]byte,　n　int)　[][]int
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindAllIndex([]byte("Hello　World!"),　-1))
//　[[0　5]] [6　11]]
}
------------------------------------------------------------
18.stringにreにコンパイルされた正規表現を検索し、すべてのマッチ位置を返します。
//　{{開始位置,　終了位置},　{開始位置,　終了位置},　...}
//　nが0以下の場合、先頭n個のマッチのみを検索します。
func　(re　*Regexp)　FindAllStringIndex(s　string,　n　int)　[][]int
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindAllStringIndex("Hello　World!",　-1))
//　[[0　5]] [6　11]]
}
------------------------------------------------------------
19[]byte内で、reでコンパイルされた正則表現を検索し、最初の一致内容を返します
//　同時に部分表現の一致内容を返します
//　{{完全一致項},　{部分一致項},　{部分一致項},　...}
func　(re　*Regexp)　FindSubmatch(b　[]byte)　[][]byte
func　main()　{
reg　:=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q",　reg.FindSubmatch([]byte("Hello　World!")))
//　["Hello"　"H"　"o"]
}
------------------------------------------------------------
2string内で、reでコンパイルされた正則表現を検索し、最初の一致内容を返します
//　同時に部分表現の一致内容を返します
//　{完全一致項,　部分一致項,　部分一致項,　...}
func　(re　*Regexp)　FindStringSubmatch(s　string)　[]string
func　main()　{
reg　:=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q",　reg.FindStringSubmatch("Hello　World!"))
//　["Hello"　"H"　"o"]
}
------------------------------------------------------------
21[]byte内で、reでコンパイルされた正則表現を検索し、すべての一致内容を返します
//　同時に部分表現の一致内容を返します
//　{
//　{{完全一致項},　{部分一致項},　{部分一致項},　...},
//　{{完全一致項},　{部分一致項},　{部分一致項},　...},
//　...
//　}
func　(re　*Regexp)　FindAllSubmatch(b　[]byte,　n　int)　[][][]byte
func　main()　{
reg　:=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q",　reg.FindAllSubmatch([]byte("Hello　World!"),　-1))
//　[["Hello"　"H"　"o"]　["World"　"W"　"d"]]
}
------------------------------------------------------------
22string内で、reでコンパイルされた正則表現を検索し、すべての一致内容を返します
//　同時に部分表現の一致内容を返します
//　{
//　{完全一致項,　部分一致項,　部分一致項,　...},
//　{完全一致項,　部分一致項,　部分一致項,　...},
//　...
//　}
//　nが0以下の場合、先頭n個のマッチのみを検索します。
func　(re　*Regexp)　FindAllStringSubmatch(s　string,　n　int)　[][]string
func　main()　{
reg　:=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q",　reg.FindAllStringSubmatch("Hello　World!",　-1))
//　[["Hello"　"H"　"o"]　["World"　"W"　"d"]]
}
------------------------------------------------------------
23[]byte内で、reでコンパイルされた正則表現を検索し、最初の一致位置を返します
//　同時に子表現式のマッチ位置も返します。
//　{完全項開始, 完全項終了, 子項開始, 子項終了, 子項開始, 子項終了, ...}
func　(re　*Regexp)　FindSubmatchIndex(b　[]byte)　[]int
func　main()　{
reg　:=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindSubmatchIndex([]byte("Hello　World!")))
//　[0　5　0　1　4　5]
}
------------------------------------------------------------
24string内で、reでコンパイルされた正則表現を検索し、最初の一致位置を返します
//　同時に子表現式のマッチ位置も返します。
//　{完全項開始, 完全項終了, 子項開始, 子項終了, 子項開始, 子項終了, ...}
func　(re　*Regexp) FindStringSubmatchIndex(s string) []int
func　main()　{
reg　:=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindStringSubmatchIndex("Hello　World!"))
//　[0　5　0　1　4　5]
}
------------------------------------------------------------
25.rにreにコンパイルされた正規表現を検索し、最初のマッチ位置を返します。
//　同時に子表現式のマッチ位置も返します。
//　{完全項開始, 完全項終了, 子項開始, 子項終了, 子項開始, 子項終了, ...}
func　(re　*Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int
func　main()　{
r　:=　bytes.NewReader([]byte("Hello　World!"))
reg　:=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindReaderSubmatchIndex(r))
//　[0　5　0　1　4　5]
}
------------------------------------------------------------
26.[]byteにreにコンパイルされた正規表現を検索し、すべてのマッチ位置を返します。
//　同時に子表現式のマッチ位置も返します。
//　{
//　{完全項開始, 完全項終了, 子項開始, 子項終了, 子項開始, 子項終了, ...},
//　{完全項開始, 完全項終了, 子項開始, 子項終了, 子項開始, 子項終了, ...},
//　...
//　}
//　nが0以下の場合、先頭n個のマッチのみを検索します。
func　(re　*Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int
func　main()　{
reg　:=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindAllSubmatchIndex([]byte("Hello　World!"),　-1))
//　[[0　5　0　1　4　5]] [6　11　6　7　10　11]]
}
------------------------------------------------------------
27.stringにreにコンパイルされた正規表現を検索し、すべてのマッチ位置を返します。
//　同時に子表現式のマッチ位置も返します。
//　{
//　{完全項開始, 完全項終了, 子項開始, 子項終了, 子項開始, 子項終了, ...},
//　{完全項開始, 完全項終了, 子項開始, 子項終了, 子項開始, 子項終了, ...},
//　...
//　}
//　nが0以下の場合、先頭n個のマッチのみを検索します。
func　(re　*Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
func　main()　{
reg　:=　regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindAllStringSubmatchIndex("Hello　World!",　-1))
//　[[0　5　0　1　4　5]] [6　11　6　7　10　11]]
}
-----------------------------------------------------------
30. template の内容を処理した後、dst の末尾に追加します。
//　template には $ が含まれていなければなりません。1、$2${name}1}2このような「グループ参照記号」}
//　match は FindSubmatchIndex メソッドが返す結果で、各グループの位置情報が保存されています。
//　もし template に「グループ参照記号」がある場合、match を基準にします。
//　src　中の対応する部分文字列を取り出し、template　の　$で置き換えます1、$2　等引用符号。
func　(re　*Regexp)　Expand(dst　[]byte,　template　[]byte,　src　[]byte,　match　[]int)　[]byte
func　main()　{
reg　:=　regexp.MustCompile(`(\w+),(\w+)`)
src　:=　[]byte("Golang,World!")　//　源文本
dst　:=　[]byte("Say:　")　//　目标文本
template　:=　[]byte("Hello　$1,　Hello　$2)　//　模板
match　:=　reg.FindSubmatchIndex(src)　//　解析源文本
//　填写模板，并将模板追加到目标文本中
fmt.Printf("%q",　reg.Expand(dst,　template,　src,　match))
//　"Say:　Hello　Golang,　Hello　World"
}
------------------------------------------------------------
31.機能同　Expand　一样，ただしパラメータが　string　タイプに変更されています
func　(re　*Regexp)　ExpandString(dst　[]byte,　template　string,　src　string,　match　[]int)　[]byte
func　main()　{
reg　:=　regexp.MustCompile(`(\w+),(\w+)`)
src　:=　"Golang,World!"　//　源文本
dst　:=　[]byte("Say:　")　//　目标文本（可写）
template　:=　"Hello　$1,　Hello　$2"　//　模板
match　:=　reg.FindStringSubmatchIndex(src)　//　解析源文本
//　填写模板，并将模板追加到目标文本中
fmt.Printf("%q",　reg.ExpandString(dst,　template,　src,　match))
//　"Say:　Hello　Golang,　Hello　World"
}
------------------------------------------------------------
32.　LiteralPrefix　返回所有匹配项都共同拥有的前缀（去除可变元素）
//　prefix：共同拥有的前缀
//　complete：如果　prefix　就是正则表达式本身，则返回　true，否则返回　false
func　(re　*Regexp)　LiteralPrefix()　(prefix　string,　complete　bool)
func　main()　{
reg　:=　regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.LiteralPrefix())
//　Hello　false
reg　=　regexp.MustCompile(`Hello`)
fmt.Println(reg.LiteralPrefix())
//　Hello　true
}
------------------------------------------------------------
33．切り替え「貪欲モード」
func　(re　*Regexp)　Longest()
func　main()　{
text　:=　`Hello　World,　123　Go!`
pattern　:=　`(?U)H[\w\s]+o`　//　正則マーク「非貪欲モード」(?U)
reg　:=　regexp.MustCompile(pattern)
fmt.Printf("%q\n",　reg.FindString(text))
//　Hello
reg.Longest()　//　切り替え「貪欲モード」
fmt.Printf("%q\n",　reg.FindString(text))
//　Hello　Wo
}
------------------------------------------------------------
34．判斷在　b　中能否找到匹配項
func　(re　*Regexp)　Match(b　[]byte)　bool
func　main()　{
b　:=　[]byte(`Hello　World`)
reg　:=　regexp.MustCompile(`Hello\w+`)
fmt.Println(reg.Match(b))
//　false
reg　=　regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.Match(b))
//　true
}
------------------------------------------------------------
35．判斷在　r　中能否找到匹配項
func　(re　*Regexp)　MatchReader(r　io.RuneReader)　bool
func　main()　{
r　:=　bytes.NewReader([]byte(`Hello　World`))
reg　:=　regexp.MustCompile(`Hello\w+`)
fmt.Println(reg.MatchReader(r))
//　false
r.Seek(0,　0)
reg　=　regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.MatchReader(r))
//　true
}
------------------------------------------------------------
36．判斷在　s　中能否找到匹配項
func　(re　*Regexp)　MatchString(s　string)　bool
func　main()　{
s　:=　`Hello　World`
reg　:=　regexp.MustCompile(`Hello\w+`)
fmt.Println(reg.MatchString(s))
//　false
reg　=　regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.MatchString(s))
//　true
}
------------------------------------------------------------
37．統計正則表達式中的分組個數（不包括「非捕獲的分組」）
func　(re　*Regexp)　NumSubexp()　int
func　main()　{
reg　:=　regexp.MustCompile(`(?U)(?:Hello)(\s+)(\w+)`)
fmt.Println(reg.NumSubexp())
//　2
}
------------------------------------------------------------
38. src 中でマッチングする項目を検索し、repl 指定の内容に置き換える
//　全ての置換を行い、置換された結果を返します
func　(re　*Regexp)　ReplaceAll(src,　repl　[]byte)　[]byte
func　main()　{
b := []byte("Hello World,　123　Go!")
reg := regexp.MustCompile(`(Hell|G)o`)
rep := []byte("${1}"
fmt.Printf("%q\n",　reg.ReplaceAll(b,　rep))
//　"Hellooo World,　123　Gooo!"
}
------------------------------------------------------------
39. src 中でマッチングする項目を検索し、repl 指定の内容に置き換える
//　全ての置換を行い、置換された結果を返します
func　(re　*Regexp)　ReplaceAllString(src,　repl　string)　string
func　main()　{
s := "Hello World,　123　Go!"
reg := regexp.MustCompile(`(Hell|G)o`)
rep := "${1}"
fmt.Printf("%q\n", reg.ReplaceAllString(s, rep))
//　"Hellooo World,　123　Gooo!"
}
-----------------------------------------------------------
40. src 中でマッチングする項目を検索し、repl 指定の内容に置き換える
//　もし repl に「グループ参照記号」（$）が含まれている場合1、$name）の場合、「グループ参照記号」を普通の文字として処理します
//　全ての置換を行い、置換された結果を返します
func　(re　*Regexp) ReplaceAllLiteral(src, repl []byte) []byte
func　main()　{
b := []byte("Hello World,　123　Go!")
reg := regexp.MustCompile(`(Hell|G)o`)
rep := []byte("${1}"
fmt.Printf("%q\n", reg.ReplaceAllLiteral(b, rep))
//　"${1}ooo World,　123　${1}ooo!"
}
-----------------------------------------------------------
41. src 中でマッチングする項目を検索し、repl 指定の内容に置き換える
//　もし repl に「グループ参照記号」（$）が含まれている場合1、$name）の場合、「グループ参照記号」を普通の文字として処理します
//　全ての置換を行い、置換された結果を返します
func　(re　*Regexp) ReplaceAllLiteralString(src, repl string) string
func　main()　{
s := "Hello World,　123　Go!"
reg := regexp.MustCompile(`(Hell|G)o`)
rep := "${1}"
fmt.Printf("%q\n", reg.ReplaceAllLiteralString(s, rep))
//　"${1}ooo World,　123　${1}ooo!"
}
------------------------------------------------------------
42. src 中でマッチングする項目を検索し、その内容を repl で処理して、src 中のマッチングする項目を置き換える
//　もし repl の返り値に「グループ参照記号」（$）が含まれている場合1、$name）の場合、「グループ参照記号」を普通の文字として処理します
//　全ての置換を行い、置換された結果を返します
func　(re　*Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
func　main()　{
s := []byte("Hello World!")
reg　:=　regexp.MustCompile("(H)ello")
rep := []byte("$0$1)
fmt.Printf("%s\n", reg.ReplaceAll(s, rep))
//　
fmt.Printf("%s\n", reg.ReplaceAllFunc(s,)
func(b []byte) []byte {
rst := []byte{}
rst = append(rst, b...)
rst = append(rst, "$1"...)
rst を返す
))
//　Hello$1　World!
}
k
------------------------------------------------------------
43. src 中でマッチングする項目を検索し、その内容を repl で処理して、src 中のマッチングする項目を置き換える
//　もし repl の返り値に「グループ参照記号」（$）が含まれている場合1、$name）の場合、「グループ参照記号」を普通の文字として処理します
//　全ての置換を行い、置換された結果を返します
func　(re　*Regexp)　ReplaceAllStringFunc(src　string,　repl　func(string)　string)　string
func　main()　{
s　:=　"Hello　World!"
reg　:=　regexp.MustCompile("(H)ello")
rep　:=　"$0$"1"
fmt.Printf("%s\n",　reg.ReplaceAllString(s,　rep))
//　
fmt.Printf("%s\n",　reg.ReplaceAllStringFunc(s,
func(b　string)　string　{
return　b　+　"$1"
))
//　Hello$1　World!
}
------------------------------------------------------------
43.s内でマッチング項目を検索し、マッチング項目を分割符としてsを複数のサブストリングに分割します
//　nまでのサブストリングを分割し、第nのサブストリングは分割されません
//　nが負の値の場合、すべてのサブストリングを分割します
//　返り値は分割されたサブストリングリストです
func　(re　*Regexp)　Split(s　string,　n　int)　[]string
func　main()　{
s　:=　"Hello　World\tHello\nGolang"

fmt.Printf("%q\n",　reg.Split(s,　-1))
//　["Hello"　"World"　"Hello"　"Golang"]
}
------------------------------------------------------------
44.返り値はreの「正規表現」文字列を返します
func　(re　*Regexp)　String()　string
func　main()　{
re　:=　regexp.MustCompile("Hello.*$")
fmt.Printf("%s\n",　re.String())
//　Hello.*$
}
------------------------------------------------------------
45.返り値はreのグループ名リストを返します。未命名のグループは空文字列を返します
//　返り値[0]　は全体の正規表現の名前
//　返り値[1]　はグループ　1　の名称
//　返り値[2]　はグループ　2　の名称
//　……
func　(re　*Regexp)　SubexpNames()　[]string
func　main()　{
re　:=　regexp.MustCompile("(?PHello)　(World)")
fmt.Printf("%q\n",　re.SubexpNames())
//　""　"Name1"　"
}