Logdateien parsen

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 auch Perl, Python und andere Sprachen verwenden.

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

Wenn du Backticks (`) verwendest, um Strings zu erzeugen, haben Backslashes (\) 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'

Deshalb ist es sinnvoll, für reguläre Ausdrücke Backticks zu verwenden, denn so müssen wir keine Backslashes escapen:

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

Muster kompilieren - der Typ RegExp

Um einen regulären Ausdruck zu verwenden, müssen wir zuerst das Muster als String kompilieren. Kompilieren bedeutet hier, dass das Muster des regulären Ausdrucks als String genommen und in eine interne Darstellung umgewandelt wird, 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 Muster als String mit der Funktion regexp.Compile zu einem regexp.Regexp kompilieren. Diese Funktion gibt nil und einen Fehler zurück, wenn das Kompilieren 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 abgleichen und den gefundenen Text identifizieren. Ihre Namen folgen diesem regulären Ausdruck:

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

• Wenn All vorhanden ist, findet die Methode 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 angibt.
• Wenn Index vorhanden ist, werden Treffer und Submatches durch Byte-Index-Paare innerhalb des Eingabe-Strings angegeben.

Außerdem gibt es Methoden zum:

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

Insgesamt definiert das Paket regexp mehr als 40 Funktionen und Methoden. Wir zeigen unten die Verwendung einiger Methoden. 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 des 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 mit dem Text des am weitesten links stehenden Treffers des regulären Ausdrucks zurück.

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 ein Slice von Strings zurück, das den Text des am weitesten links stehenden Treffers des regulären Ausdrucks und, falls vorhanden, die Treffer seiner Unterausdrücke enthält. Damit lassen sich die Strings identifizieren, die zu Capturing-Gruppen passen. Ein Rückgabewert von nil zeigt an, 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 dabei Treffer des regulären Ausdrucks re durch den Ersatz-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 ein Slice der Teilstrings zwischen diesen Treffern zurück. Die Anzahl n bestimmt die maximale Anzahl der zurückgegebenen Teilstrings. Wenn n<0, 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"}