Expresiones regulares en Go con ejemplos: en la práctica

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

Expresiones regulares en Go con ejemplos: en la práctica

Las expresiones regulares (regex) son una herramienta poderosa para buscar, extraer y reemplazar texto según un patrón. En Go (Golang), para trabajar con ellas se utiliza el paquete estándar regexp, que proporciona una API eficiente y segura. En este artículo, analizaremos las principales capacidades del paquete con ejemplos concretos que le ayudarán a aplicar los conocimientos de inmediato en proyectos reales.

Fundamentos del paquete regexp en Go

El paquete regexp implementa la sintaxis de expresiones regulares compatible con RE2 (excepto las referencias inversas y lookahead/lookbehind). Esto lo hace rápido y predecible. Las funciones principales son:

regexp.Compile(pattern) — compila un patrón en un objeto Regexp. Devuelve un error si el patrón es incorrecto.
regexp.MustCompile(pattern) — hace lo mismo, pero genera pánico en caso de error. Es útil para patrones estáticos.
MatchString(pattern, s) — verifica si la cadena s contiene una subcadena que coincida con el patrón.

Utilice siempre Compile para patrones dinámicos (por ejemplo, de entrada de usuario) y MustCompile para aquellos definidos estáticamente en el código.

package main

import (    "fmt"    "regexp")

func main() {    // Usamos MustCompile para un patrón estático    re := regexp.MustCompile(`hello`)    match := re.MatchString("hello world")    fmt.Println(match) // true

    // Compile para un patrón dinámico    pattern := "[0-9]+"    re2, err := regexp.Compile(pattern)    if err != nil {        fmt.Println("Error de compilación:", err)        return    }    fmt.Println(re2.MatchString("abc123")) // true}

Búsqueda y extracción de datos

A menudo no solo se necesita verificar una coincidencia, sino extraer partes específicas de la cadena. Para ello se utilizan los métodos FindString, FindStringSubmatch y FindAllString.

Extraer la primera coincidencia

package main

import (    "fmt"    "regexp")

func main() {    re := regexp.MustCompile(`\\d+`)    text := "Código: 12345, precio: 678"        // Primera coincidencia    first := re.FindString(text)    fmt.Println(first) // 12345        // Todas las coincidencias    all := re.FindAllString(text, -1)    fmt.Println(all) // [12345 678]}

Extraer grupos (submatches)

Los grupos en el patrón (indicados con paréntesis) permiten extraer partes de la coincidencia. El método FindStringSubmatch devuelve un slice donde el primer elemento es la coincidencia completa y los siguientes son los valores de los grupos.

package main

import (    "fmt"    "regexp")

func main() {    // Patrón: nombre de usuario @dominio    re := regexp.MustCompile(`(\\w+)@(\\w+\\.\\w+)`)    email := "user@example.com"        match := re.FindStringSubmatch(email)    if len(match) > 0 {        fmt.Println("Email completo:", match[0]) // user@example.com        fmt.Println("Nombre de usuario:", match[1]) // user        fmt.Println("Dominio:", match[2]) // example.com    }}

El método FindAllStringSubmatch hace lo mismo para todas las coincidencias en la cadena.

Reemplazo de texto con expresiones regulares

El paquete regexp proporciona dos métodos para reemplazar: ReplaceAllString (reemplazo simple) y ReplaceAllStringFunc (reemplazo usando una función).

Reemplazo simple

package main

import (    "fmt"    "regexp")

func main() {    re := regexp.MustCompile(`\\s+`) // uno o más espacios    text := "Hola    Mundo   Go"        result := re.ReplaceAllString(text, " ")    fmt.Println(result) // Hola Mundo Go}