Reguläre Ausdrücke in Go mit Beispielen: Vollständiger Leitfaden

Reguläre Ausdrücke in Go mit Beispielen

Reguläre Ausdrücke (Regex) sind ein leistungsstarkes Werkzeug zum Suchen, Extrahieren und Ersetzen von Text basierend auf Mustern. In der Go-Sprache (Golang) wird die Arbeit mit regulären Ausdrücken über das Standardpaket regexp implementiert. In diesem Artikel werden wir gründlich untersuchen, wie man reguläre Ausdrücke in Go verwendet: von der einfachen Suche bis zu komplexen Ersetzungen mit Erfassungsgruppen.

1. Grundlagen des regexp-Pakets

Das Paket regexp bietet zwei Hauptansätze: schnelle einmalige Nutzung (Paket-Level-Funktionen) und leistungsstarke Arbeit mit einem vorcompilierten Muster (die Regexp-Struktur). Für wiederholte Nutzung sollten Sie das Muster immer vorab compilieren.

Compilieren eines regulären Ausdrucks

package main

import (    "fmt"    "regexp")

func main() {    // Compilieren eines Musters (empfohlene Methode mit Fehlerbehandlung)    pattern, err := regexp.Compile(`\\d+`)    if err != nil {        fmt.Println("Compilierungsfehler:", err)        return    }        // Für einfache Fälle — ohne Fehlerbehandlung (panics bei ungültigem Muster)    patternMust := regexp.MustCompile(`[a-z]+`)        fmt.Println(pattern, patternMust)}

Compile gibt einen Fehler zurück, wenn das Muster ungültig ist. MustCompile löst eine Panic aus — verwenden Sie es nur für statische Muster.

2. Grundlegende Operationen: Suchen und Abgleichen

Schauen wir uns die Hauptmethoden zum Überprüfen von Übereinstimmungen und zum Suchen von Teilzeichenfolgen an.

Überprüfen auf eine partielle Übereinstimmung

pattern := regexp.MustCompile(`go`)text := "Ich lerne Golang"

// MatchString — enthält die Zeichenfolge eine Teilzeichenfolge, die dem Muster entsprichtmatched := pattern.MatchString(text)fmt.Println(matched) // true (weil "go" in "Golang" enthalten ist)

Überprüfen auf eine vollständige Übereinstimmung

// Um zu überprüfen, ob die gesamte Zeichenfolge dem Muster entspricht, verwenden Sie Anker ^ und $fullPattern := regexp.MustCompile(`^[a-zA-Z]+$`)fmt.Println(fullPattern.MatchString("Hallo"))   // truefmt.Println(fullPattern.MatchString("Hallo1"))  // false

Finden der ersten Übereinstimmung

datePattern := regexp.MustCompile(`\\d{2}\\.\\d{2}\\.\\d{4}`)text := "Heute ist der 15.03.2024, und morgen ist der 16.03.2024"

// FindString — gibt die erste Übereinstimmung zurückfirstDate := datePattern.FindString(text)fmt.Println(firstDate) // "15.03.2024"

Finden aller Übereinstimmungen

// FindAllString — gibt einen Slice aller Übereinstimmungen zurückallDates := datePattern.FindAllString(text, -1) // -1 — alle Übereinstimmungenfmt.Println(allDates) // ["15.03.2024" "16.03.2024"]

// Begrenzung der Anzahl: FindAllString(text, 1) — nur die erste

3. Erfassungsgruppen und Substitutionen

Erfassungsgruppen ermöglichen es Ihnen, Teile einer Übereinstimmung zu extrahieren. In Go werden Gruppen durch Klammern () gekennzeichnet.

Extrahieren von Daten nach Gruppen

// Muster zum Extrahieren von Name und Alter: "Name: [Name], Alter: [Zahl]"personPattern := regexp.MustCompile(`Name: (\\w+), Alter: (\\d+)`)text := "Name: Alexey, Alter: 30"

// FindStringSubmatch — gibt einen Slice zurück: [vollständige_Übereinstimmung, Gruppe1, Gruppe2, ...]matches := personPattern.FindStringSubmatch(text)if len(matches) > 0 {    fmt.Println("Vollständige Übereinstimmung:", matches[0]) // "Name: Alexey, Alter: 30"    fmt.Println("Name:", matches[1])                         // "Alexey"    fmt.Println("Alter:", matches[2])                        // "30"}

Benannte Gruppen (Go 1.21+)

// Seit Go Version 1.21 können Sie benannte Gruppen verwenden: (?P<name>muster)pattern := regexp.MustCompile(`(?P<name>\\w+)@(?P<domain>\\w+\\.\\w+)`)text := "test@example.com"

// SubexpNames — ermittelt die GruppennamengroupNames := pattern.SubexpNames()matches := pattern.FindStringSubmatch(text)

// Erstellt eine Map: Gruppenname