Dokumentacja Go z przykładami: Wyrażenia regularne

Q: Jak sprawdzić, czy string pasuje do wyrażenia regularnego w Go?

Skompiluj wzorzec raz przez regexp.MustCompile, zapisując go jako surowy string w backtickach, żeby ukośniki wsteczne nie wymagały escapowania, a potem wywołaj re.MatchString(s). Bez kotwic (^ i $) MatchString zwraca true, jeśli wzorzec pasuje w dowolnym miejscu stringa.

Q: Czy regexp w Go obsługuje lookahead i lookbehind?

Nie. Pakiet regexp w Go używa składni RE2, która nie ma lookahead, lookbehind ani odwołań wstecznych. W zamian dopasowanie działa w czasie liniowym względem rozmiaru danych, więc złośliwy wzorzec lub wejście nie zawiesi programu. Zamiast tego użyj grup przechwytujących i odrobiny kodu w Go albo podziel sprawdzanie na dwa wyrażenia regularne.

Q: Czym różni się regexp.Compile od regexp.MustCompile?

Compile zwraca skompilowany wzorzec i błąd. MustCompile przy niepoprawnym wzorcu wywołuje panic. Używaj MustCompile dla wzorców zapisanych w kodzie źródłowym, zwykle w zmiennej na poziomie pakietu, żeby literówka ujawniła się przy starcie. Compile stosuj dla wzorców pochodzących od użytkowników lub z plików konfiguracyjnych.

Q: Jak pobrać grupy przechwytujące z wyrażenia regularnego w Go?

Użyj FindStringSubmatch, która zwraca slice, gdzie indeks 0 to całe dopasowanie, a indeksy 1, 2, ... to grupy, albo nil, gdy nic nie pasuje. Dla wszystkich dopasowań użyj FindAllStringSubmatch(s, -1). Grupy nazwane (?P \d{4}) można odnaleźć przez re.SubexpIndex("year").

Kompiluj raz, potem dopasowuj

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
}

Zapisuj wzorce jako surowe literały stringów w backtickach. W zwykłym stringu w cudzysłowach każdy ukośnik wsteczny trzeba podwoić ("\\d+"), co szybko staje się nieczytelne.

regexp.MustCompile wywołuje panic, jeśli wzorzec jest niepoprawny, i właśnie tego chcesz dla wzorca w kodzie źródłowym: literówka ujawnia się od razu przy starcie, a nie przy pierwszym żądaniu. Dla wzorców od użytkowników lub z konfiguracji użyj regexp.Compile i obsłuż błąd:

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

Kompiluj raz. Kompilacja jest dużo droższa niż dopasowanie. regexp.MustCompile wewnątrz funkcji wywoływanej dla każdego żądania lub każdej linii powtarza tę pracę za każdym razem. Umieść skompilowany *regexp.Regexp w var na poziomie pakietu albo w polu struktury. Skompilowany regexp można bezpiecznie używać z wielu goroutine jednocześnie.

regexp.MatchString(pattern, s) kompiluje i dopasowuje w jednym wywołaniu. Nadaje się do jednorazowego sprawdzenia, ale w pętli marnuje czas.

Wyszukiwanie dopasowań

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

Nazwy metod układają się według schematu: Find + All? + String? + Submatch? + Index?.

Część	Znaczenie
`All`	każde nienakładające się dopasowanie; przyjmuje limit `n` (`-1` oznacza wszystkie)
`String`	działa na `string`; bez niej metoda przyjmuje i zwraca `[]byte`
`Submatch`	zwraca też grupy przechwytujące
`Index`	zwraca przesunięcia w bajtach zamiast tekstu

FindString zwraca "", gdy nic nie pasuje, czego nie da się odróżnić od dopasowania pustego stringa. Gdy wzorzec może dopasować pusty tekst, użyj FindStringIndex (zwraca nil, gdy brak dopasowania) albo najpierw MatchString. Warianty All zwracają nil, gdy nic nie pasuje.

Grupy przechwytujące

Nawiasy przechwytują. FindStringSubmatch zwraca całe dopasowanie pod indeksem 0, a potem po jednym elemencie na każdą grupę:

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())
}

Zawsze sprawdź nil przed indeksowaniem wyniku; gdy brak dopasowania, m[1] wywołuje panic.

(?:...) grupuje bez przechwytywania, do alternatywy lub powtórzeń: (?:ab)+. Grupy nazwane zapisuje się jako (?P<name>...), a od Go 1.22 także (?<name>...).

Zamiana

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

Klasyczna pułapka z odwołaniami do grup: "$1x" jest czytane jako grupa o nazwie 1x, która nie istnieje, i rozwija się do pustego stringa. Napisz "${1}x".

Dla stałego tekstu strings.ReplaceAll, strings.Contains i strings.Split są prostsze i szybsze niż regexp. Sięgaj po regexp, gdy szukany tekst ma określony kształt, a nie stałą wartość.

Ściągawka ze składni

Go używa składni RE2, która obejmuje znane funkcje w stylu Perla:

Składnia	Dopasowuje
`.`	dowolny znak poza znakiem nowej linii (z `(?s)` także nową linię)
`\d` `\w` `\s`	cyfrę, znak słowa `[0-9A-Za-z_]`, biały znak (tylko ASCII)
`\D` `\W` `\S`	zaprzeczenia powyższych
`[abc]` `[^abc]` `[a-z]`	klasy znaków
`\pL` `\p{Greek}`	klasy Unicode: dowolna litera, dowolny znak grecki
`*` `+` `?` `{n,m}`	powtórzenie, zachłanne
`*?` `+?` `??`	powtórzenie, leniwe
`^` `$`	początek i koniec tekstu (linii, z `(?m)`)
`\b`	granica słowa (ASCII)
`a\|b`	alternatywa
`(?i)`	bez rozróżniania wielkości liter od tego miejsca do końca otaczającej grupy; zwykle zapisywane na początku wzorca

\d i \w dopasowują tylko ASCII. Dla „dowolnej litery w dowolnym języku” użyj \pL, a dla dowolnej cyfry Unicode \p{Nd}. regexp.QuoteMeta(s) escapuje każdy znak specjalny w s, co jest potrzebne, gdy budujesz wzorzec z danych od użytkownika.

Czego RE2 nie potrafi

Regexp w Go gwarantuje, że dopasowanie zajmuje czas liniowy względem długości wejścia. Funkcje, które złamałyby tę gwarancję, nie są obsługiwane:

Brak lookahead i lookbehind: (?=...), (?!...), (?<=...), (?<!...) dają błąd kompilacji. Ponieważ Go 1.22 zaczęło akceptować (?<name>...) dla grup nazwanych, lookbehind kończy się teraz mylącym komunikatem invalid named capture, co pokazuje program poniżej.
Brak odwołań wstecznych: (\w)\1 do dopasowania podwojonej litery nie jest możliwe.
Brak kwantyfikatorów zaborczych i grup atomowych.

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

Obejście jest prawie zawsze takie samo: przechwyć trochę więcej, niż potrzebujesz, a potem przefiltruj lub przytnij wynik w Go. W zamian regexp w Go nie da się wpędzić w katastrofalny backtracking. Wzorzec taki jak (a+)+$, który potrafi zamrozić silnik PCRE na krótkim wejściu, działa tu w czasie liniowym, co ma znaczenie, gdy wzorzec lub dane pochodzą z zewnątrz.

Typowe błędy

Kompilowanie w pętli lub w handlerze. Skompiluj raz do zmiennej na poziomie pakietu.
Wzorce w cudzysłowach. "\d" nie jest nawet poprawnym stringiem w Go; użyj backticków.
Brak kotwic przy walidacji. \d{5} pasuje wewnątrz "abc123456xyz". Użyj ^\d{5}$.
Indeksowanie wyniku submatcha bez sprawdzenia nil.
Oczekiwanie, że \w lub \b zrozumieją tekst spoza ASCII. Użyj klas Unicode, takich jak \pL.
Używanie regexp dla stałych stringów. Pakiet strings jest czytelniejszy i szybszy.

Najczęściej zadawane pytania

Jak sprawdzić, czy string pasuje do wyrażenia regularnego w Go?

Skompiluj wzorzec raz przez regexp.MustCompile, zapisując go jako surowy string w backtickach, żeby ukośniki wsteczne nie wymagały escapowania, a potem wywołaj re.MatchString(s). Bez kotwic (^ i $) MatchString zwraca true, jeśli wzorzec pasuje w dowolnym miejscu stringa.

Czy regexp w Go obsługuje lookahead i lookbehind?

Nie. Pakiet regexp w Go używa składni RE2, która nie ma lookahead, lookbehind ani odwołań wstecznych. W zamian dopasowanie działa w czasie liniowym względem rozmiaru danych, więc złośliwy wzorzec lub wejście nie zawiesi programu. Zamiast tego użyj grup przechwytujących i odrobiny kodu w Go albo podziel sprawdzanie na dwa wyrażenia regularne.

Czym różni się regexp.Compile od regexp.MustCompile?

Compile zwraca skompilowany wzorzec i błąd. MustCompile przy niepoprawnym wzorcu wywołuje panic. Używaj MustCompile dla wzorców zapisanych w kodzie źródłowym, zwykle w zmiennej na poziomie pakietu, żeby literówka ujawniła się przy starcie. Compile stosuj dla wzorców pochodzących od użytkowników lub z plików konfiguracyjnych.

Jak pobrać grupy przechwytujące z wyrażenia regularnego w Go?

Użyj FindStringSubmatch, która zwraca slice, gdzie indeks 0 to całe dopasowanie, a indeksy 1, 2, ... to grupy, albo nil, gdy nic nie pasuje. Dla wszystkich dopasowań użyj FindAllStringSubmatch(s, -1). Grupy nazwane (?P<year>\d{4}) można odnaleźć przez re.SubexpIndex("year").

Powiązane zagadnienia