Reguläre Ausdrücke in

Über Reguläre Ausdrücke

Das Paket regexp bietet Unterstützung für reguläre Ausdrücke in Go.

Syntax

Die Syntax der akzeptierten regulären Ausdrücke entspricht der allgemeinen Syntax, die von Perl, Python und anderen Sprachen verwendet wird.

Sowohl die Suchmuster als auch die Eingabetexte werden als UTF-8 interpretiert.

Wenn du Backticks (\`) keine besondere Bedeutung und markieren nicht den Anfang von Sonderzeichen wie Tabs \t oder Zeilenumbrüchen \n:

"\t\n" // regular string literal with 2 characters: a tab and a newline
`\t\n`// raw string literal with 4 characters: two backslashes, a 't', and an 'n'

Aus diesem Grund ist es sinnvoll, Backticks zu verwenden, um reguläre Ausdrücke zu erstellen, denn dann müssen wir Backslashes nicht escapen:

"\\" // string with a single backslash
`\\` // string with 2 backslashes

Muster kompilieren - RegExp-Typ

Um einen regulären Ausdruck zu verwenden, müssen wir zunächst das String-Muster kompilieren. Kompilieren bedeutet hier, das String-Muster des regulären Ausdrucks zu nehmen und in eine interne Darstellung umzuwandeln, mit der sich leichter arbeiten lässt. Wir müssen jedes Muster nur einmal kompilieren. Danach können wir die kompilierte Version des regulären Ausdrucks beliebig oft verwenden. Der Typ regexp.Regexp repräsentiert einen kompilierten regulären Ausdruck. Wir können ein String-Muster mit der Funktion regexp.Compile in einen regexp.Regexp kompilieren. Diese Funktion gibt nil und einen Fehler zurück, wenn die Kompilierung fehlgeschlagen ist:

re, err := regexp.Compile(`(a|b)+`)
fmt.Println(re, err) // => (a|b)+ <nil>
re, err = regexp.Compile(`a|b)+`)
fmt.Println(re, err) // => <nil> error parsing regexp: unexpected ): `a|b)+`

Die Funktion MustCompile ist eine praktische Alternative zu Compile:

re = regexp.MustCompile(`[a-z]+\d*`)

Bei dieser Funktion musst du keinen Fehler behandeln.

Methoden für reguläre Ausdrücke

Es gibt 16 Methoden von Regexp, die einen regulären Ausdruck matchen und den übereinstimmenden Text identifizieren. Ihre Namen entsprechen diesem regulären Ausdruck:

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

• Wenn All vorhanden ist, findet die Routine aufeinanderfolgende, nicht überlappende Treffer des gesamten Ausdrucks.
• Wenn String vorhanden ist, ist das Argument ein String; andernfalls ist es ein Slice von Bytes. Die Rückgabewerte werden entsprechend angepasst.
• Wenn Submatch vorhanden ist, ist der Rückgabewert ein Slice, der die aufeinanderfolgenden Submatches des Ausdrucks identifiziert.
• Wenn Index vorhanden ist, werden Treffer und Submatches durch Byte-Index-Paare innerhalb des Eingabe-Strings identifiziert.

Es gibt auch Methoden zum:

• Ersetzen von Treffern regulärer Ausdrücke durch Ersetzungs-Strings und
• Aufteilen von Strings, die durch reguläre Ausdrücke getrennt sind.

Insgesamt definiert das Paket regexp mehr als 40 Funktionen und Methoden. Wir werden unten die Verwendung einiger Methoden demonstrieren. Weitere Einzelheiten zu diesen und anderen Funktionen findest du in der API-Dokumentation.

Beispiele für MatchString

Die Methode MatchString gibt an, ob ein String einen Treffer eines regulären Ausdrucks enthält.

re = regexp.MustCompile(`[a-z]+\d*`)
b = re.MatchString("[a12]")       // => true
b = re.MatchString("12abc34(ef)") // => true
b = re.MatchString(" abc!")       // => true
b = re.MatchString("123 456")     // => false

Beispiele für FindString

Die Methode FindString gibt einen String zurück, der den Text des am weitesten links stehenden Treffers des regulären Ausdrucks enthält.

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.FindString("[a12]")       // => "a12"
s = re.FindString("12abc34(ef)") // => "abc34"
s = re.FindString(" abc!")       // => "abc"
s = re.FindString("123 456")     // => ""

Beispiele für FindStringSubmatch

Die Methode FindStringSubmatch gibt einen Slice von Strings zurück, der den Text des am weitesten links stehenden Treffers des regulären Ausdrucks und die Treffer seiner Teilausdrücke, falls vorhanden, enthält. Damit lassen sich die Strings identifizieren, die auf Capturing-Gruppen passen. Ein Rückgabewert von nil bedeutet, dass es keinen Treffer gibt.

re = regexp.MustCompile(`[a-z]+(\d*)`)
sl = re.FindStringSubmatch("[a12]")       // => []string{"a12","12"}
sl = re.FindStringSubmatch("12abc34(ef)") // => []string{"abc34","34"}
sl = re.FindStringSubmatch(" abc!")       // => []string{"abc",""}
sl = re.FindStringSubmatch("123 456")     // => <nil>

Beispiele für ReplaceAllString

Die Methode re.ReplaceAllString(src,repl) gibt eine Kopie von src zurück und ersetzt Treffer des regulären Ausdrucks re durch den Ersetzungs-String repl.

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.ReplaceAllString("[a12]", "X")       // => "[X]"
s = re.ReplaceAllString("12abc34(ef)", "X") // => "12X(X)"
s = re.ReplaceAllString(" abc!", "X")       // => " X!"
s = re.ReplaceAllString("123 456", "X")     // => "123 456"

Beispiele für Split

Die Methode re.Split(s,n) zerlegt einen Text s in Teilstrings, die durch den Ausdruck getrennt sind, und gibt einen Slice der Teilstrings zwischen diesen Treffern des Ausdrucks zurück. Die Anzahl n bestimmt die maximale Anzahl der zurückzugebenden Teilstrings. Wenn n<0 ist, gibt die Methode alle Teilstrings zurück.

re = regexp.MustCompile(`[a-z]+\d*`)
sl = re.Split("[a12]", -1)      // => []string{"[","]"}
sl = re.Split("12abc34(ef)", 2) // => []string{"12","(ef)"}
sl = re.Split(" abc!", -1)      // => []string{" ","!"}
sl = re.Split("123 456", -1)    // => []string{"123 456"}

Performance

Die von diesem Paket bereitgestellte regexp-Implementierung läuft garantiert in linearer Zeit bezogen auf die Größe der Eingabe.

Einschränkung

Das Paket regexp implementiert RE2-reguläre Ausdrücke (mit Ausnahme von \C). Die Syntax ist weitgehend kompatibel mit PCRE („Perl Compatible Regular Expression"), aber es gibt einige Unterschiede. Weitere Einzelheiten findest du im „Caveat-Abschnitt" in diesem Artikel.