Docs ejecutables de Go: Expresiones regulares

Q: ¿Cómo compruebo si un string coincide con una regex en Go?

Compila el patrón una vez con regexp.MustCompile, escribiéndolo como raw string entre comillas invertidas para que las barras invertidas no necesiten escape, y luego llama a re.MatchString(s). Sin anclas (^ y $), MatchString devuelve true si el patrón coincide en cualquier parte del string.

Q: ¿El regexp de Go admite lookahead y lookbehind?

No. El regexp de Go usa la sintaxis RE2, que no tiene lookahead, lookbehind ni referencias hacia atrás. A cambio, la búsqueda tarda un tiempo lineal respecto al tamaño de la entrada, así que un patrón o una entrada hostiles no pueden colgar tu programa. Usa grupos de captura y un poco de código Go, o divide la comprobación en dos regex.

Q: ¿Qué diferencia hay entre regexp.Compile y regexp.MustCompile?

Compile devuelve el patrón compilado y un error. MustCompile provoca un panic ante un patrón no válido. Usa MustCompile para los patrones escritos en tu código fuente, normalmente en una variable a nivel de paquete, para que una errata falle al arrancar. Usa Compile para los patrones que vienen de usuarios o de archivos de configuración.

Q: ¿Cómo obtengo los grupos de captura de una regex en Go?

Usa FindStringSubmatch, que devuelve un slice donde el índice 0 es la coincidencia completa y los índices 1, 2, ... son los grupos, o nil si no hay coincidencia. Para todas las coincidencias usa FindAllStringSubmatch(s, -1). Los grupos con nombre (?P \d{4}) se pueden buscar con re.SubexpIndex("year").

Compila una vez y luego busca

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
}

Escribe los patrones como literales raw string entre comillas invertidas. En un string normal entre comillas dobles cada barra invertida tiene que duplicarse ("\\d+"), lo que enseguida se vuelve ilegible.

regexp.MustCompile provoca un panic si el patrón no es válido, que es justo lo que quieres para un patrón escrito en tu código fuente: una errata falla al arrancar, no en la primera petición. Para los patrones que vienen de usuarios o de la configuración, usa regexp.Compile y maneja el error:

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

Compila una vez. Compilar es mucho más caro que buscar. Un regexp.MustCompile dentro de una función que se ejecuta por cada petición o por cada línea repite ese trabajo cada vez. Guarda el *regexp.Regexp compilado en una var a nivel de paquete o en un campo de un struct. Un regexp compilado es seguro para usarlo desde muchas goroutines a la vez.

regexp.MatchString(pattern, s) compila y busca en una sola llamada. Está bien para una comprobación puntual y es un desperdicio dentro de un bucle.

Encontrar coincidencias

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

Los nombres de los métodos siguen un patrón: Find + All? + String? + Submatch? + Index?.

Parte	Significado
`All`	todas las coincidencias que no se solapan; recibe un límite `n` (`-1` para todas)
`String`	trabaja con un `string`; sin él, el método recibe y devuelve `[]byte`
`Submatch`	devuelve también los grupos de captura
`Index`	devuelve desplazamientos en bytes en lugar del texto

FindString devuelve "" cuando no hay coincidencia, lo que no se distingue de coincidir con un string vacío. Cuando el patrón puede coincidir con texto vacío, usa FindStringIndex (devuelve nil si no hay coincidencia) o MatchString antes. Las variantes All devuelven nil cuando nada coincide.

Grupos de captura

Los paréntesis capturan. FindStringSubmatch devuelve la coincidencia completa en el índice 0 y luego una entrada por grupo:

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

Comprueba siempre nil antes de indexar el resultado; si no hay coincidencia, m[1] provoca un panic.

(?:...) agrupa sin capturar, para alternancias o repeticiones: (?:ab)+. Los grupos con nombre se escriben (?P<name>...), y desde Go 1.22 también (?<name>...).

Reemplazar

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

Una trampa clásica con las referencias a grupos: "$1x" se lee como un grupo llamado 1x, que no existe, y se expande a un string vacío. Escribe "${1}x".

Para un string fijo, strings.ReplaceAll, strings.Contains y strings.Split son más sencillos y más rápidos que un regexp. Recurre a regexp cuando el texto que buscas tiene una forma en lugar de un valor fijo.

Referencia rápida de sintaxis

Go usa la sintaxis RE2, que cubre las funciones conocidas del estilo de Perl:

Sintaxis	Coincide con
`.`	cualquier carácter salvo el salto de línea (con `(?s)`, también el salto de línea)
`\d` `\w` `\s`	dígito, carácter de palabra `[0-9A-Za-z_]`, espacio en blanco (solo ASCII)
`\D` `\W` `\S`	las negaciones
`[abc]` `[^abc]` `[a-z]`	clases de caracteres
`\pL` `\p{Greek}`	clases Unicode: cualquier letra, cualquier carácter griego
`*` `+` `?` `{n,m}`	repetición, voraz
`*?` `+?` `??`	repetición, perezosa
`^` `$`	inicio y fin del texto (de la línea, con `(?m)`)
`\b`	límite de palabra (ASCII)
`a\|b`	alternancia
`(?i)`	sin distinguir mayúsculas desde ese punto hasta el final del grupo que lo contiene; normalmente se escribe al principio del patrón

\d y \w solo coinciden con ASCII. Para "cualquier letra de cualquier idioma", usa \pL, y para cualquier dígito Unicode, \p{Nd}. regexp.QuoteMeta(s) escapa todos los caracteres especiales de s, lo que necesitas al construir un patrón a partir de la entrada del usuario.

Lo que RE2 no puede hacer

El regexp de Go garantiza que la búsqueda tarda un tiempo lineal respecto a la longitud de la entrada. Las funciones que romperían esa garantía no están soportadas:

Sin lookahead ni lookbehind: (?=...), (?!...), (?<=...) y (?<!...) son errores de compilación. Como Go 1.22 empezó a aceptar (?<name>...) para los grupos con nombre, un lookbehind falla ahora con el confuso mensaje invalid named capture, como muestra el siguiente programa.
Sin referencias hacia atrás: (\w)\1 para encontrar una letra repetida no es posible.
Sin cuantificadores posesivos ni grupos atómicos.

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

El apaño es casi siempre el mismo: captura un poco más de lo que necesitas y luego filtra o recorta en Go. La recompensa es que un regexp de Go no puede caer en un backtracking catastrófico. Un patrón como (a+)+$, que puede congelar un motor PCRE con una entrada corta, aquí se ejecuta en tiempo lineal, lo que importa cuando el patrón o la entrada vienen de fuera.

Errores comunes

Compilar dentro de un bucle o un handler. Compila una vez en una variable a nivel de paquete.
Patrones entre comillas dobles. "\d" ni siquiera es un string válido de Go; usa comillas invertidas.
Olvidar las anclas al validar. \d{5} coincide dentro de "abc123456xyz". Usa ^\d{5}$.
Indexar el resultado de un submatch sin comprobar nil.
Esperar que \w o \b entiendan texto que no es ASCII. Usa clases Unicode como \pL.
Usar regexp para strings fijos. El paquete strings es más claro y más rápido.

Preguntas frecuentes

¿Cómo compruebo si un string coincide con una regex en Go?

Compila el patrón una vez con regexp.MustCompile, escribiéndolo como raw string entre comillas invertidas para que las barras invertidas no necesiten escape, y luego llama a re.MatchString(s). Sin anclas (^ y $), MatchString devuelve true si el patrón coincide en cualquier parte del string.

¿El regexp de Go admite lookahead y lookbehind?

No. El regexp de Go usa la sintaxis RE2, que no tiene lookahead, lookbehind ni referencias hacia atrás. A cambio, la búsqueda tarda un tiempo lineal respecto al tamaño de la entrada, así que un patrón o una entrada hostiles no pueden colgar tu programa. Usa grupos de captura y un poco de código Go, o divide la comprobación en dos regex.

¿Qué diferencia hay entre regexp.Compile y regexp.MustCompile?

Compile devuelve el patrón compilado y un error. MustCompile provoca un panic ante un patrón no válido. Usa MustCompile para los patrones escritos en tu código fuente, normalmente en una variable a nivel de paquete, para que una errata falle al arrancar. Usa Compile para los patrones que vienen de usuarios o de archivos de configuración.

¿Cómo obtengo los grupos de captura de una regex en Go?

Usa FindStringSubmatch, que devuelve un slice donde el índice 0 es la coincidencia completa y los índices 1, 2, ... son los grupos, o nil si no hay coincidencia. Para todas las coincidencias usa FindAllStringSubmatch(s, -1). Los grupos con nombre (?P<year>\d{4}) se pueden buscar con re.SubexpIndex("year").

Conceptos relacionados