Ausführbare Go-Docs: Reguläre Ausdrücke

Q: Wie prüfe ich in Go, ob ein String zu einem Regex passt?

Kompiliere das Muster einmal mit regexp.MustCompile und schreib es als Raw String in Backticks, damit Backslashes nicht escapt werden müssen. Ruf dann re.MatchString(s) auf. Ohne Anker (^ und $) gibt MatchString true zurück, wenn das Muster irgendwo im String passt.

Q: Unterstützt Go regexp Lookahead und Lookbehind?

Nein. Das regexp von Go verwendet die RE2-Syntax, die weder Lookahead noch Lookbehind noch Rückverweise kennt. Im Gegenzug läuft das Matching in linearer Zeit zur Eingabegröße, also kann ein bösartiges Muster oder eine bösartige Eingabe dein Programm nicht lahmlegen. Nimm stattdessen Capture Groups und etwas Go-Code oder teil die Prüfung auf zwei Regexes auf.

Q: Was ist der Unterschied zwischen regexp.Compile und regexp.MustCompile?

Compile gibt das kompilierte Muster und einen Fehler zurück. MustCompile löst bei einem ungültigen Muster stattdessen eine Panic aus. Nimm MustCompile für Muster, die in deinem Quelltext stehen, typischerweise in einer Variablen auf Paketebene, damit ein Tippfehler schon beim Start auffällt. Nimm Compile für Muster, die von Nutzern oder aus Konfigurationsdateien kommen.

Q: Wie bekomme ich in Go die Capture Groups eines Regex?

Mit FindStringSubmatch, das einen Slice zurückgibt, in dem Index 0 der gesamte Treffer ist und Index 1, 2, ... die Gruppen sind, oder nil, wenn es keinen Treffer gibt. Für alle Treffer nimm FindAllStringSubmatch(s, -1). Benannte Gruppen (?P \d{4}) findest du mit re.SubexpIndex("year").

Einmal kompilieren, dann matchen

package main

import (
	"fmt"
	"regexp"
)

// Compiled once, when the program starts.
var phoneRe = regexp.MustCompile(`^\d{3}-\d{3}-\d{4}$`)

func main() {
	for _, s := range []string{"555-123-4567", "5551234567", "call 555-123-4567"} {
		fmt.Printf("%-20q %v\n", s, phoneRe.MatchString(s))
	}

	wordRe := regexp.MustCompile(`go+gle`)
	fmt.Println(wordRe.MatchString("I googled it")) // unanchored: matches anywhere
}

Schreib Muster als Raw-String-Literale in Backticks. In einem normalen String in doppelten Anführungszeichen muss jeder Backslash verdoppelt werden ("\\d+"), was schnell unlesbar wird.

regexp.MustCompile löst bei einem ungültigen Muster eine Panic aus, und genau das willst du bei einem Muster in deinem Quelltext: Ein Tippfehler fällt sofort beim Start auf, nicht erst beim ersten Request. Für Muster von Nutzern oder aus der Konfiguration nimm regexp.Compile und behandle den Fehler:

re, err := regexp.Compile(userPattern)
if err != nil {
	return fmt.Errorf("bad pattern: %w", err)
}

Einmal kompilieren. Kompilieren ist weit teurer als Matchen. Ein regexp.MustCompile in einer Funktion, die pro Request oder pro Zeile läuft, wiederholt diese Arbeit jedes Mal. Leg den kompilierten *regexp.Regexp in ein var auf Paketebene oder in ein Struct-Feld. Ein kompilierter Regexp kann gefahrlos von vielen Goroutinen gleichzeitig benutzt werden.

regexp.MatchString(pattern, s) kompiliert und matcht in einem Aufruf. Für eine einmalige Prüfung ist das in Ordnung, in einer Schleife ist es Verschwendung.

Treffer finden

package main

import (
	"fmt"
	"regexp"
)

var numRe = regexp.MustCompile(`\d+`)

func main() {
	s := "order 66 shipped 3 boxes, 1200 grams"

	fmt.Printf("%q\n", numRe.FindString(s))           // first match
	fmt.Println(numRe.FindStringIndex(s))             // its [start, end) byte offsets
	fmt.Println(numRe.FindAllString(s, -1))           // all matches
	fmt.Println(numRe.FindAllString(s, 2))            // at most 2
	fmt.Printf("%q\n", numRe.FindString("no digits")) // "" when nothing matches

	fmt.Println(numRe.FindAllString("no digits", -1) == nil)
}

Die Methodennamen folgen einem Muster: Find + All? + String? + Submatch? + Index?.

Teil	Bedeutung
`All`	jeder nicht überlappende Treffer; nimmt ein Limit `n` (`-1` für alle)
`String`	arbeitet auf einem `string`; ohne diesen Teil nimmt und liefert die Methode `[]byte`
`Submatch`	liefert zusätzlich die Capture Groups
`Index`	liefert Byte-Offsets statt Text

FindString gibt "" zurück, wenn es keinen Treffer gibt, und das ist nicht von einem Treffer auf einen leeren String zu unterscheiden. Kann das Muster leeren Text treffen, nimm FindStringIndex (gibt ohne Treffer nil zurück) oder vorher MatchString. Die All-Varianten geben nil zurück, wenn nichts passt.

Capture Groups

Klammern fangen ein. FindStringSubmatch liefert den gesamten Treffer an Index 0, dann einen Eintrag pro Gruppe:

package main

import (
	"fmt"
	"regexp"
)

var dateRe = regexp.MustCompile(`(\d{4})-(\d{2})-(\d{2})`)

var logRe = regexp.MustCompile(`(?P<level>INFO|WARN|ERROR) (?P<msg>.+)`)

func main() {
	m := dateRe.FindStringSubmatch("released on 2026-09-23 at noon")
	if m == nil {
		fmt.Println("no date")
		return
	}
	fmt.Println("whole:", m[0], "year:", m[1], "month:", m[2], "day:", m[3])

	for _, g := range dateRe.FindAllStringSubmatch("2025-01-15 and 2026-02-28", -1) {
		fmt.Println(g[1], g[2], g[3])
	}

	// Named groups: look up the index by name.
	line := "ERROR disk full on /dev/sda1"
	if lm := logRe.FindStringSubmatch(line); lm != nil {
		fmt.Println("level:", lm[logRe.SubexpIndex("level")])
		fmt.Println("msg:  ", lm[logRe.SubexpIndex("msg")])
	}
	fmt.Println("group names:", logRe.SubexpNames())
}

Prüf immer auf nil, bevor du das Ergebnis indizierst; ohne Treffer löst m[1] eine Panic aus.

(?:...) gruppiert, ohne einzufangen, für Alternativen oder Wiederholungen: (?:ab)+. Benannte Gruppen schreibst du (?P<name>...), seit Go 1.22 auch (?<name>...).

Ersetzen

package main

import (
	"fmt"
	"regexp"
	"strings"
)

var (
	spaceRe = regexp.MustCompile(`\s+`)
	dateRe  = regexp.MustCompile(`(\d{4})-(\d{2})-(\d{2})`)
	emailRe = regexp.MustCompile(`[\w.+-]+@[\w-]+\.[\w.]+`)
)

func main() {
	fmt.Printf("%q\n", spaceRe.ReplaceAllString("  too   many\tspaces \n", " "))

	// $1, $2 refer to groups. Use ${1} when a letter or digit follows.
	fmt.Println(dateRe.ReplaceAllString("due 2026-09-23", "$3/$2/$1"))

	// Literal replacement: $ has no special meaning.
	fmt.Println(dateRe.ReplaceAllLiteralString("due 2026-09-23", "$DATE"))

	// Compute the replacement in Go.
	masked := emailRe.ReplaceAllStringFunc("mail ada@example.com or bob@test.org", func(e string) string {
		at := strings.IndexByte(e, '@')
		return e[:1] + strings.Repeat("*", at-1) + e[at:]
	})
	fmt.Println(masked)

	// Split on a pattern.
	fmt.Printf("%q\n", regexp.MustCompile(`\s*[,;]\s*`).Split("a, b;c ,d", -1))
}

Eine klassische Falle bei Gruppenverweisen: "$1x" wird als Gruppe mit dem Namen 1x gelesen, die es nicht gibt, und wird zu einem leeren String expandiert. Schreib "${1}x".

Für einen festen String sind strings.ReplaceAll, strings.Contains und strings.Split einfacher und schneller als ein Regexp. Greif zu regexp, wenn der gesuchte Text eine Form hat statt eines festen Werts.

Syntax im Überblick

Go verwendet die RE2-Syntax, die die vertrauten Features im Perl-Stil abdeckt:

Syntax	Trifft
`.`	jedes Zeichen außer Zeilenumbruch (mit `(?s)` auch den)
`\d` `\w` `\s`	Ziffer, Wortzeichen `[0-9A-Za-z_]`, Leerraum (nur ASCII)
`\D` `\W` `\S`	die Negationen
`[abc]` `[^abc]` `[a-z]`	Zeichenklassen
`\pL` `\p{Greek}`	Unicode-Klassen: jeder Buchstabe, jedes griechische Zeichen
`*` `+` `?` `{n,m}`	Wiederholung, gierig
`*?` `+?` `??`	Wiederholung, genügsam
`^` `$`	Anfang und Ende des Texts (mit `(?m)` der Zeile)
`\b`	Wortgrenze (ASCII)
`a\|b`	Alternative
`(?i)`	ignoriert Groß- und Kleinschreibung ab dieser Stelle bis zum Ende der umschließenden Gruppe; meist an den Anfang des Musters geschrieben

\d und \w treffen nur ASCII. Für „jeden Buchstaben in jeder Sprache“ nimm \pL und für jede Unicode-Ziffer \p{Nd}. regexp.QuoteMeta(s) escapt jedes Sonderzeichen in s; das brauchst du, wenn du ein Muster aus Nutzereingaben baust.

Was RE2 nicht kann

Der Regexp von Go garantiert, dass das Matching in linearer Zeit zur Länge der Eingabe läuft. Features, die diese Garantie brechen würden, werden nicht unterstützt:

Kein Lookahead oder Lookbehind: (?=...), (?!...), (?<=...), (?<!...) sind Compilerfehler. Weil Go 1.22 begonnen hat, (?<name>...) für benannte Gruppen zu akzeptieren, scheitert ein Lookbehind jetzt mit der verwirrenden Meldung invalid named capture, wie das Programm unten zeigt.
Keine Rückverweise: (\w)\1, um einen doppelten Buchstaben zu treffen, ist nicht möglich.
Keine possessiven Quantoren oder atomaren Gruppen.

package main

import (
	"fmt"
	"regexp"
	"strings"
)

// Goal: a price in dollars, but only the number, and not when it is negative.
// PCRE would write (?<!-)(?<=\$)\d+(\.\d{2})? using lookbehind.
var priceRe = regexp.MustCompile(`(-?)\$(\d+(?:\.\d{2})?)`)

func main() {
	_, err := regexp.Compile(`(?<=\$)\d+`)
	fmt.Println("lookbehind:", err)

	text := "was $19.99, now $15, refund -$5"
	for _, m := range priceRe.FindAllStringSubmatch(text, -1) {
		if m[1] == "-" {
			continue // the lookbehind's job, done in Go
		}
		fmt.Println("price:", m[2])
	}

	// A doubled letter without a backreference: check in plain Go.
	word := "balloon"
	for i := 1; i < len(word); i++ {
		if word[i] == word[i-1] {
			fmt.Println("doubled:", strings.Repeat(string(word[i]), 2))
		}
	}
}

Der Workaround ist fast immer derselbe: Fang etwas mehr ein, als du brauchst, und filtere oder schneide dann in Go. Der Gewinn: Ein Go-Regexp lässt sich nicht in katastrophales Backtracking treiben. Ein Muster wie (a+)+$, das eine PCRE-Engine schon bei einer kurzen Eingabe einfrieren kann, läuft hier in linearer Zeit. Das zählt, wenn das Muster oder die Eingabe von außen kommt.

Häufige Fehler

In einer Schleife oder einem Handler kompilieren. Kompiliere einmal in eine Variable auf Paketebene.
Muster in doppelten Anführungszeichen. "\d" ist nicht einmal ein gültiger Go-String; nimm Backticks.
Anker bei der Validierung vergessen. \d{5} trifft innerhalb von "abc123456xyz". Nimm ^\d{5}$.
Ein Submatch-Ergebnis ohne Prüfung auf nil indizieren.
Erwarten, dass \w oder \b Text außerhalb von ASCII verstehen. Nimm Unicode-Klassen wie \pL.
regexp für feste Strings nutzen. Das Paket strings ist klarer und schneller.

Häufig gestellte Fragen

Wie prüfe ich in Go, ob ein String zu einem Regex passt?

Kompiliere das Muster einmal mit regexp.MustCompile und schreib es als Raw String in Backticks, damit Backslashes nicht escapt werden müssen. Ruf dann re.MatchString(s) auf. Ohne Anker (^ und $) gibt MatchString true zurück, wenn das Muster irgendwo im String passt.

Unterstützt Go regexp Lookahead und Lookbehind?

Nein. Das regexp von Go verwendet die RE2-Syntax, die weder Lookahead noch Lookbehind noch Rückverweise kennt. Im Gegenzug läuft das Matching in linearer Zeit zur Eingabegröße, also kann ein bösartiges Muster oder eine bösartige Eingabe dein Programm nicht lahmlegen. Nimm stattdessen Capture Groups und etwas Go-Code oder teil die Prüfung auf zwei Regexes auf.

Was ist der Unterschied zwischen regexp.Compile und regexp.MustCompile?

Compile gibt das kompilierte Muster und einen Fehler zurück. MustCompile löst bei einem ungültigen Muster stattdessen eine Panic aus. Nimm MustCompile für Muster, die in deinem Quelltext stehen, typischerweise in einer Variablen auf Paketebene, damit ein Tippfehler schon beim Start auffällt. Nimm Compile für Muster, die von Nutzern oder aus Konfigurationsdateien kommen.

Wie bekomme ich in Go die Capture Groups eines Regex?

Mit FindStringSubmatch, das einen Slice zurückgibt, in dem Index 0 der gesamte Treffer ist und Index 1, 2, ... die Gruppen sind, oder nil, wenn es keinen Treffer gibt. Für alle Treffer nimm FindAllStringSubmatch(s, -1). Benannte Gruppen (?P<year>\d{4}) findest du mit re.SubexpIndex("year").

Verwandte Konzepte