Expresiones regulares en Go con ejemplos: guía completa

Expresiones regulares en Go: una potente herramienta para trabajar con texto

Las expresiones regulares (regex) son una herramienta indispensable para buscar, extraer y reemplazar texto según un patrón. En el lenguaje Go (Golang), el trabajo con expresiones regulares se implementa a través del paquete estándar regexp. Este proporciona una forma rápida y segura de trabajar con patrones, utilizando una sintaxis cercana a Perl y RE2. En este artículo, analizaremos las funciones principales del paquete con ejemplos prácticos.

1. Fundamentos del trabajo con el paquete regexp

El paquete regexp sigue el principio de "compila una vez, usa muchas veces". Esto mejora el rendimiento al aplicar un mismo patrón repetidamente. Funciones principales:

• regexp.Compile(expr) — compila una expresión regular. Devuelve *Regexp y un error.
• regexp.MustCompile(expr) — hace lo mismo, pero genera un panic en caso de error. Es útil para inicializar variables globales.
• regexp.MatchString(expr, s) — verifica si la cadena s contiene al menos una coincidencia con el patrón.

package main

import (    "fmt"    "regexp")

func main() {    // Verificación simple: ¿la cadena contiene dígitos?    matched, _ := regexp.MatchString(`\\d+`, "Pedido №12345")    fmt.Println(matched) // true

    // Compilamos el patrón para uso múltiple    re := regexp.MustCompile(`[a-z]+`)    fmt.Println(re.MatchString("hello")) // true    fmt.Println(re.MatchString("HELLO")) // false}

Tenga en cuenta: por defecto, MatchString busca una coincidencia parcial (como strings.Contains). Para una coincidencia completa de la cadena con el patrón, use los anclajes ^ y $.

2. Búsqueda y extracción de datos

Para buscar todas las coincidencias o la primera aparición, use los métodos FindString, FindAllString, FindStringSubmatch y sus análogos para slices de bytes.

2.1. Búsqueda de la primera coincidencia

re := regexp.MustCompile(`\\b\\w+@\\w+\\.\\w+\\b`)email := re.FindString("Contáctenos: support@example.com o info@test.org")fmt.Println(email) // support@example.com

2.2. Búsqueda de todas las coincidencias

re := regexp.MustCompile(`\\d{4}`)numbers := re.FindAllString("Códigos: 1234, 5678, 9012", -1)fmt.Println(numbers) // [1234 5678 9012]

El segundo argumento de FindAllString es el número máximo de coincidencias. -1 significa "todas".

2.3. Grupos de captura (submatch)

Los grupos de captura permiten extraer partes de la coincidencia. Se definen con paréntesis ().

re := regexp.MustCompile(`(\\w+)@(\\w+\\.\\w+)`)match := re.FindStringSubmatch("user@example.com")fmt.Println(match) // [user@example.com user example.com]// match[0] — coincidencia completa// match[1] — primer grupo (user)// match[2] — segundo grupo (example.com)

3. Reemplazo de texto con expresiones regulares

El paquete regexp proporciona dos métodos principales para el reemplazo:

• ReplaceAllString(src, repl) — reemplaza todas las coincidencias con la cadena repl.
• ReplaceAllStringFunc(src, replFunc) — reemplaza cada coincidencia usando una función de callback.

3.1. Reemplazo simple

re := regexp.MustCompile(`\\s+`)result := re.ReplaceAllString("Muchos   espacios   aquí", " ")fmt.Println(result) // "Muchos espacios aquí"

3.2. Reemplazo usando grupos de captura

En la cadena de reemplazo se puede hacer referencia a los grupos mediante $1, $2, etc.

re := regexp.MustCompile(`(\\w+)\\s+(\\w+)`)result := re.ReplaceAllString("Iván Petrov", "$2, $1")