Регулярные выражения в Golang: regexp, поиск, группы, замена

Компилируйте один раз, потом сопоставляйте

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
}

Записывайте шаблоны сырыми строковыми литералами в обратных кавычках. В обычной строке в двойных кавычках каждый обратный слэш нужно удваивать ("\\d+"), и это быстро становится нечитаемым.

regexp.MustCompile паникует, если шаблон некорректен, и для шаблона в исходном коде это именно то, что нужно: опечатка проявляется сразу при запуске, а не на первом запросе. Для шаблонов от пользователей или из конфигурации используйте regexp.Compile и обрабатывайте ошибку:

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

Компилируйте один раз. Компиляция гораздо дороже сопоставления. regexp.MustCompile внутри функции, которая выполняется на каждый запрос или строку, каждый раз повторяет эту работу. Кладите скомпилированный *regexp.Regexp в var уровня пакета или в поле структуры. Скомпилированный regexp можно безопасно использовать из многих горутин одновременно.

regexp.MatchString(pattern, s) компилирует и сопоставляет одним вызовом. Для разовой проверки это нормально, а в цикле расточительно.

Поиск совпадений

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

Имена методов строятся по схеме: Find + All? + String? + Submatch? + Index?.

FindString возвращает "", когда совпадения нет, и это не отличить от совпадения с пустой строкой. Когда шаблон может совпасть с пустым текстом, используйте FindStringIndex (возвращает nil, если совпадения нет) или сначала MatchString. Варианты с All возвращают nil, если ничего не совпало.

Группы захвата

Круглые скобки захватывают. FindStringSubmatch возвращает всё совпадение под индексом 0, а затем по элементу на каждую группу:

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

Всегда проверяйте результат на nil перед обращением по индексу; если совпадения нет, m[1] вызовет панику.

(?:...) группирует без захвата, для альтернативы или повторения: (?:ab)+. Именованные группы пишутся как (?P<name>...), а начиная с Go 1.22 также (?<name>...).

Замена

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

Классическая ловушка со ссылками на группы: "$1x" читается как группа с именем 1x, которой нет, и превращается в пустую строку. Пишите "${1}x".

Для фиксированной строки strings.ReplaceAll, strings.Contains и strings.Split проще и быстрее регулярного выражения. Берите regexp, когда у искомого текста есть форма, а не фиксированное значение.

Шпаргалка по синтаксису

Go использует синтаксис RE2, который покрывает привычные возможности в стиле Perl:

\d и \w совпадают только с ASCII. Для «любой буквы любого языка», включая кириллицу, используйте \pL, а для любой цифры Unicode \p{Nd}. regexp.QuoteMeta(s) экранирует все специальные символы в s, что нужно, когда шаблон строится из пользовательского ввода.

Чего не умеет RE2

Регулярные выражения Go гарантируют, что сопоставление занимает время, линейное по длине ввода. Возможности, которые нарушили бы эту гарантию, не поддерживаются:

• Нет lookahead и lookbehind: (?=...), (?!...), (?<=...), (?<!...) дают ошибку компиляции. Поскольку Go 1.22 начал принимать (?<name>...) для именованных групп, lookbehind теперь падает с запутанным сообщением invalid named capture, как показывает программа ниже.
• Нет обратных ссылок: (\w)\1 для поиска удвоенной буквы невозможен.
• Нет притяжательных квантификаторов и атомарных групп.

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

Обходной путь почти всегда один и тот же: захватить чуть больше, чем нужно, а затем отфильтровать или обрезать в Go. Выигрыш в том, что регулярное выражение Go невозможно загнать в катастрофический перебор с возвратами. Шаблон вроде (a+)+$, который может заморозить движок PCRE на коротком вводе, здесь выполняется за линейное время, и это важно, когда шаблон или ввод приходят извне.

Частые ошибки

• Компиляция в цикле или обработчике. Компилируйте один раз в переменную уровня пакета.
• Шаблоны в двойных кавычках. "\d" вообще не является корректной строкой Go; используйте обратные кавычки.
• Забытые якоря при проверке. \d{5} совпадает внутри "abc123456xyz". Используйте ^\d{5}$.
• Обращение к результату с подгруппами без проверки на nil.
• Ожидание, что \w или \b понимают не-ASCII текст. Используйте классы Unicode вроде \pL.
• regexp для фиксированных строк. Пакет strings понятнее и быстрее.