Go-Regex(Regulärer Ausdruck)

Das Go Regex-Paket wird zur Suche in Strings verwendet. Um Strings zu suchen, müssen wir ein Stringmuster bereitstellen.

Wir müssen das Muster in das regex-Objekt kompilieren, damit wir über es Methoden aufrufen können.

Man kann die Funktionen compile() und mustcompile() verwenden, um das reguläre Ausdrucksobjekt abzurufen. Jetzt können wir mit diesen Funktionen Strings suchen, z.B. FindString(), FindStringSubmatch(), FindStringIndex() und so weiter.

Beispiel regulärer Ausdrücke1

Beispiel

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"))
{}

Ausgabe:

.com
.com

Die Methode FindString() gibt einen String zurück, der den linkensten Treffer enthält. Wenn kein Treffer gefunden wird, wird ein leerer String zurückgegeben.

Beispiel regulärer Ausdrücke2

Beispiel

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"))
{}

Ausgabe:

[6　10]
[]
[2　6]

Beispiel regulärer Ausdrücke3

Wir können auch die Methode FindStringSubmatch() verwenden, die ein Slice von Strings zurückgibt, die den linkensten Treffer und den Text des Treffers enthalten. Wenn kein Treffer gefunden wird, wird ein leerer String zurückgegeben.

Beispiel

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

Ausgabe:

[fliegend ly]
[flott flott]
Prozess beendet mit Ausgabecode 0

Gängige Methoden des regulären AusdrucksPakets "regexp" in der Programmiersprache Go

Die Übereinstimmung regulärer Ausdrücke in der Programmiersprache Go kann mit dem regulären AusdrucksPaket von Go erfolgen. 　

Die RegulärAusdrücke in der Programmiersprache Go folgen den gleichen Regeln wie in anderen Programmiersprachen, nur die aufgerufenen Funktionen sind unterschiedlich. 　　

Es wird empfohlen, bei der Erstellung regulärer Ausdrücke das Format `pattern` zu verwenden.

regexp.Match

//　Prüft, ob eine Subzeichenkette, die durch den regulären Ausdruck "pattern" übereinstimmt, in "b" gefunden werden kann
//　pattern: Der zu suchende reguläre Ausdruck
//　b: Das zu durchsuchende []byte
//　matched: Gibt zurück, ob ein Treffer gefunden wurde
//　err: Gibt alle Fehler zurück, die während des Suchvorgangs auftreten
//　Diese Funktion wird durch den Aufruf der Methoden von Regexp implementiert
func Match(pattern string, b []byte) (matched bool, err error)

Online-Beispiel

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

//　Prüft, ob eine Subzeichenkette, die durch den regulären Ausdruck "pattern" übereinstimmt, in "s" gefunden werden kann
　//　pattern: Der zu suchende reguläre Ausdruck
　//　r: Der String, in dem gesucht werden soll
　//　matched: Gibt zurück, ob ein Treffer gefunden wurde
　//　err: Gibt alle Fehler zurück, die während des Suchvorgangs auftreten
　//　Diese Funktion wird durch den Aufruf der Methoden von Regexp implementiert
　
　func MatchString(pattern string, s string) (matched bool, err error)

Online-Beispiel

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 wird verwendet, um zu überprüfen, ob der reguläre Ausdruck "expr" gültig ist. Wenn er gültig ist, wird ein "Regexp"-Objekt zurückgegeben
//　The Regexp object can perform the required operations on any text
func Compile(expr string) (*Regexp, error)

Gibt einen Zeiger auf ein Objekt von "regexp" zurück, das die in der Rückgabe definierten Methoden aufrufen kann, wie z.B. Match, MatchString, find usw.

Online-Beispiel

//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
//nur einmal übereinstimmen
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
//Matching nur einmal, der Wert im Rückgabewert mit Index 0 ist der Wert der gesamten Übereinstimmung, der Wert im zweiten Index ist der Wert der Unterexpression
fmt.Println(r.FindStringSubmatch("this　foo　func　fan"))　//[foo　oo]
　
//Für FindStringSubmatch wird nicht nach Unterexpressions gesucht, wenn im Ausdruck keine Unterexpressions vorhanden sind
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
//wenn n-1bedeutet, alle passenden Zeichenfolgen zu matchen, wenn n nicht-1bedeutet, nur n-mal zu matchen
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 ist ebenfalls ein Indikator für die Anzahl der Übereinstimmungen,-1bedeutet, alle zu matchen
fmt.Println(r.FindAllStringSubmatchIndex("foo　func　demo　fan",　-1))
//[[0　3　1　3]] [4　8　5　8]] [14　17　15　17]]
　
//Ersetzen
　
//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 und regexp.Compile haben ähnliche Verwendungsmöglichkeiten.

Detaillierte Erklärung des regulären Ausdrucks-Pakets regexp in der Programmiersprache Go

//　regexp.go im Detail
------------------------------------------------------------
1. Überprüfen, ob der reguläre Ausdruck pattern im []byte eine Übereinstimmung hat
//　pattern: Der zu suchende reguläre Ausdruck
//　b: Das zu durchsuchende []byte
//　matched: Gibt zurück, ob ein Treffer gefunden wurde
//　err: Gibt alle Fehler zurück, die während des Suchvorgangs auftreten
//　Diese Funktion wird durch den Aufruf der Methoden von Regexp implementiert
func Match(pattern string, b []byte) (matched bool, err error)
func　main()　{
fmt.Println(regexp.Match("H.*　", []byte("Hello World!")))
//　true
{}
------------------------------------------------------------
2. Entspricht dem Suchen eines Substrings, der durch den regulären Ausdruck pattern in r übereinstimmt
//　pattern: Der zu suchende reguläre Ausdruck
//　r: Das RuneReader-Interface, in dem gesucht werden soll
//　matched: Gibt zurück, ob ein Treffer gefunden wurde
//　err: Gibt alle Fehler zurück, die während des Suchvorgangs auftreten
//　Diese Funktion wird durch den Aufruf der Methoden von Regexp implementiert
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. Entspricht dem Suchen eines Substrings, der durch den regulären Ausdruck pattern in s übereinstimmt
//　pattern: Der zu suchende reguläre Ausdruck
//　r: Der String, in dem gesucht werden soll
//　matched: Gibt zurück, ob ein Treffer gefunden wurde
//　err: Gibt alle Fehler zurück, die während des Suchvorgangs auftreten
//　Diese Funktion wird durch den Aufruf der Methoden von Regexp implementiert
func MatchString(pattern string, s string) (matched bool, err error)
func　main()　{
fmt.Println(regexp.Match("H.*　", "Hello World!"))
//　true
{}
------------------------------------------------------------
4. QuoteMeta wandelt den String s der 'speziellen Zeichen' in den 'flüchtigen Format' um
//　Zum Beispiel, QuoteMeta(`[foo]`) gibt `
foo
`。
//　Besondere Zeichen sind: \.+*?()|[]{}^$
//　Diese Zeichen werden zur Implementierung der regulären Syntax verwendet und müssen daher in den Fluss umgewandelt werden.
func QuoteMeta(s string) string
func　main()　{
fmt.Println(regexp.QuoteMeta("(?P:Hello)　[a-z]"))
//　\?P:Hello
a−z
{}
------------------------------------------------------------
5.Regexp Struktur stellt einen kompilierten regulären Ausdruck dar.
//　Die öffentlichen Schnittstellen von Regexp werden durch Methoden implementiert.
//　Das gleichzeitige Verwenden mehrerer goroutine mit einem RegExp ist sicher.
type Regexp struct {
//　Private Felder
{}
//　durch Complite, CompilePOSIX, MustCompile, MustCompilePOSIX
//　Mit vier Funktionen kann ein Regexp-Objekt erstellt werden.
------------------------------------------------------------
6Die Funktion .Compile wird verwendet, um zu überprüfen, ob der reguläre Ausdruck expr gültig ist. Wenn er gültig ist, wird ein Regexp-Objekt zurückgegeben.
//　The Regexp object can perform the required operations on any text
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 has the same function as Compile
//　The difference is that CompilePOSIX uses POSIX syntax
//　At the same time, it uses the most leftmost longest search method
//　While Compile uses the most leftmost shortest search method
//　POSIX syntax does not support Perl syntax format: \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 has the same function as Compile
//　The difference is that when the regular expression str is not valid, MustCompile will throw an exception
//　While Compile only returns an error value
func MustCompile(str string)　*Regexp
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
//　Hello
{}
------------------------------------------------------------
9.MustCompilePOSIX has the same function as CompilePOSIX
//　The difference is that when the regular expression str is not valid, MustCompilePOSIX will throw an exception
//　While CompilePOSIX only returns an error value
func MustCompilePOSIX(str string)　*Regexp
func　main()　{
reg := regexp.MustCompilePOSIX(`[[:word:]]+　`)
fmt.Printf("%q\n", reg.FindString("Hello World!"))
//　"Hello"
{}
------------------------------------------------------------
10In []byte, the compiled regular expression re is searched and the first matching content is returned
func　(re　*Regexp) Find(b []byte) []byte
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q", reg.Find([]byte("Hello World!")))
//　"Hello"
{}
------------------------------------------------------------
11In string, the compiled regular expression re is searched and the first matching content is returned
func　(re　*Regexp) FindString(s string) string
func　main()　{
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
//　"Hello"
{}
------------------------------------------------------------
12.在　[]byte　中查找　re　中编译好的正则表达式，并返回所有匹配的内容
//　{{匹配项},　{匹配项},　...}
//　Sucht nur die ersten n Übereinstimmungen, wenn n < 0, werden alle Übereinstimmungen gesucht
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"]
{}
------------------------------------------------------------
13In der Variable 'string' suchen, die kompilierten regulären Ausdrücke von 're' enthält, und alle Übereinstimmungen zurückgeben.
//　{匹配项,　匹配项,　...}
//　Sucht nur die ersten n Übereinstimmungen, wenn n < 0, werden alle Übereinstimmungen gesucht
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.Sucht im r nach dem kompilierten regulären Ausdruck re und gibt die erste Übereinstimmung zurück
//　{起始位置,　结束位置}
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.Sucht im []byte nach dem kompilierten regulären Ausdruck re und gibt alle Übereinstimmungen zurück
//　{{起始位置,　结束位置},　{起始位置,　结束位置},　...}
//　Sucht nur die ersten n Übereinstimmungen, wenn n < 0, werden alle Übereinstimmungen gesucht
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.Sucht im string nach dem kompilierten regulären Ausdruck re und gibt alle Übereinstimmungen zurück
//　{{起始位置,　结束位置},　{起始位置,　结束位置},　...}
//　Sucht nur die ersten n Übereinstimmungen, wenn n < 0, werden alle Übereinstimmungen gesucht
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]]
{}
------------------------------------------------------------
19In der Variable '[]byte' suchen, die kompilierten regulären Ausdrücke von 're' enthält, und den ersten Übereinstimmungsinhalt zurückgeben.
//　und die Inhalte der Teilausdrücke zurückgeben.
//　{{vollständige Übereinstimmung},　{Teilübereinstimmung},　{Teilübereinstimmung},　...}
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"]
{}
------------------------------------------------------------
20. In der Variable 'string' suchen, die kompilierten regulären Ausdrücke von 're' enthält, und das erste Übereinstimmungsinhalt zurückgeben.
//　und die Inhalte der Teilausdrücke zurückgeben.
//　{vollständige Übereinstimmung,　Teilübereinstimmung,　Teilübereinstimmung,　...}
func　(re　*Regexp) FindStringSubmatch(s string) []string
func　main()　{
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q", reg.FindStringSubmatch("Hello　World!"))
//　["Hello"　"H"　"o"]
{}
------------------------------------------------------------
21In der Variable '[]byte' suchen, die kompilierten regulären Ausdrücke von 're' enthält, und alle Übereinstimmungen zurückgeben.
//　und die Inhalte der Teilausdrücke zurückgeben.
//　{
//　{{vollständige Übereinstimmung},　{Teilübereinstimmung},　{Teilübereinstimmung},　...},
//　{{vollständige Übereinstimmung},　{Teilübereinstimmung},　{Teilübereinstimmung},　...},
//　...
//　{}
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"]]
{}
------------------------------------------------------------
22In der Variable 'string' suchen, die kompilierten regulären Ausdrücke von 're' enthält, und alle Übereinstimmungen zurückgeben.
//　und die Inhalte der Teilausdrücke zurückgeben.
//　{
//　{vollständige Übereinstimmung,　Teilübereinstimmung,　Teilübereinstimmung,　...},
//　{vollständige Übereinstimmung,　Teilübereinstimmung,　Teilübereinstimmung,　...},
//　...
//　{}
//　Sucht nur die ersten n Übereinstimmungen, wenn n < 0, werden alle Übereinstimmungen gesucht
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"]]
{}
------------------------------------------------------------
23In der Variable '[]byte' suchen, die kompilierten regulären Ausdrücke von 're' enthält, und die Position der ersten Übereinstimmung zurückgeben.
//　und gibt die Positionen der Unterausdrücke zurück
//　{Start der vollständigen Übereinstimmung, Ende der vollständigen Übereinstimmung, Start der Untereinheit, Ende der Untereinheit, Start der Untereinheit, Ende der Untereinheit, ...}
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]
{}
------------------------------------------------------------
24In der Variable 'string' suchen, die kompilierte reguläre Ausdrücke von 're' enthält, und die Position der ersten Übereinstimmung zurückgeben.
//　und gibt die Positionen der Unterausdrücke zurück
//　{Start der vollständigen Übereinstimmung, Ende der vollständigen Übereinstimmung, Start der Untereinheit, Ende der Untereinheit, Start der Untereinheit, Ende der Untereinheit, ...}
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.Sucht im r nach dem kompilierten regulären Ausdruck re und gibt die erste Übereinstimmung zurück
//　und gibt die Positionen der Unterausdrücke zurück
//　{Start der vollständigen Übereinstimmung, Ende der vollständigen Übereinstimmung, Start der Untereinheit, Ende der Untereinheit, Start der Untereinheit, Ende der Untereinheit, ...}
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.Sucht im []byte nach dem kompilierten regulären Ausdruck re und gibt alle Übereinstimmungen zurück
//　und gibt die Positionen der Unterausdrücke zurück
//　{
//　{Start der vollständigen Übereinstimmung, Ende der vollständigen Übereinstimmung, Start der Untereinheit, Ende der Untereinheit, Start der Untereinheit, Ende der Untereinheit, ...},
//　{Start der vollständigen Übereinstimmung, Ende der vollständigen Übereinstimmung, Start der Untereinheit, Ende der Untereinheit, Start der Untereinheit, Ende der Untereinheit, ...},
//　...
//　{}
//　Sucht nur die ersten n Übereinstimmungen, wenn n < 0, werden alle Übereinstimmungen gesucht
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.Sucht im string nach dem kompilierten regulären Ausdruck re und gibt alle Übereinstimmungen zurück
//　und gibt die Positionen der Unterausdrücke zurück
//　{
//　{Start der vollständigen Übereinstimmung, Ende der vollständigen Übereinstimmung, Start der Untereinheit, Ende der Untereinheit, Start der Untereinheit, Ende der Untereinheit, ...},
//　{Start der vollständigen Übereinstimmung, Ende der vollständigen Übereinstimmung, Start der Untereinheit, Ende der Untereinheit, Start der Untereinheit, Ende der Untereinheit, ...},
//　...
//　{}
//　Sucht nur die ersten n Übereinstimmungen, wenn n < 0, werden alle Übereinstimmungen gesucht
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. Fügen Sie den Inhalt des Templates nach der Verarbeitung an das Ende von dst an
//　das Template muss das $ enthalten1、$2, ${name1}, ${name2solche "Gruppierungsbezeichner" }
//　Match ist das Ergebnis der Methode FindSubmatchIndex, das die Positionsinformationen der verschiedenen Gruppen speichert.
//　Wenn im Template der "Gruppierungsbezeichner" vorhanden ist, dann wird mit "match" als Standard gearbeitet.
//　Ziehen Sie den entsprechenden Unterstring aus src heraus und ersetzen Sie ihn durch den in template befindlichen $1、$2　Quotation marks.
func　(re　*Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte
func　main()　{
reg := regexp.MustCompile(`(\w+),(\w+)`)
src := []byte("Golang,World!")　//　Quelltext
dst := []byte("Say: ")　//　Zieltext
template := []byte("Hello $1, Hello $2"　//　Muster
match := reg.FindSubmatchIndex(src)　//　Verarbeiten Sie den Quelltext
//　Füllen Sie das Muster aus und fügen Sie es dem Zieltext hinzu
fmt.Printf("%q", reg.Expand(dst, template, src, match))
//　"Say: Hello Golang, Hello World"
{}
------------------------------------------------------------
31. Die Funktion ist gleich wie Expand, nur die Parameter wurden in den Typ string geändert
func　(re　*Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte
func　main()　{
reg := regexp.MustCompile(`(\w+),(\w+)`)
src := "Golang,World!"　//　Quelltext
dst := []byte("Say: ")　//　Zieltext (schreibbar)
template := "Hello $1, Hello $2"　//　Muster
match := reg.FindStringSubmatchIndex(src)　//　Verarbeiten Sie den Quelltext
//　Füllen Sie das Muster aus und fügen Sie es dem Zieltext hinzu
fmt.Printf("%q", reg.ExpandString(dst, template, src, match))
//　"Say: Hello Golang, Hello World"
{}
------------------------------------------------------------
32. LiteralPrefix gibt den gemeinsamen Präfix aller Übereinstimmungen zurück (ohne variable Elemente)
//　prefix: Gemeinsamer Präfix
//　complete: Wenn prefix der gleiche reguläre Ausdruck ist, der die Vorlage darstellt, wird true zurückgegeben, sonst 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.Sucht in src nach Übereinstimmungen und ersetzt sie durch das vom repl angegebene Inhalt
//　全部替换，并返回替换后的结果
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.Sucht in src nach Übereinstimmungen und ersetzt sie durch das vom repl angegebene Inhalt
//　全部替换，并返回替换后的结果
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. Sucht in src nach Übereinstimmungen und ersetzt sie durch das vom repl angegebene Inhalt
//　Wenn repl den "Gruppierungsbezeichner" ($) enthält1、$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.Sucht in src nach Übereinstimmungen und ersetzt sie durch das vom repl angegebene Inhalt
//　Wenn repl den "Gruppierungsbezeichner" ($) enthält1、$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.Sucht in src nach Übereinstimmungen und ersetzt den gefundenen Inhalt durch die Verarbeitung von repl
//　Wenn der Rückgabewert von repl den "Gruppierungsbezeichner" ($) enthält1、$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"...)
return rst
))
//　Hello$1　World!
{}
k
------------------------------------------------------------
43.Sucht in src nach Übereinstimmungen und ersetzt den gefundenen Inhalt durch die Verarbeitung von repl
//　Wenn der Rückgabewert von repl den "Gruppierungsbezeichner" ($) enthält1、$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　<　0，则分割所有子串
//　返回分割后的子串列表
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" "
{}