Expresiones regulares en Go con ejemplos: guía completa para principiantes

Expresiones regulares en Go (Golang): guía completa para principiantes

Las expresiones regulares (regex) son una herramienta poderosa para buscar, extraer y reemplazar texto según patrones definidos. En el lenguaje Go (Golang), el trabajo con expresiones regulares se implementa a través del paquete estándar regexp. En este artículo, analizaremos los fundamentos del trabajo con regexp en Go, revisaremos las funciones clave y proporcionaremos ejemplos prácticos que te ayudarán a comenzar a usar expresiones regulares en tus proyectos.

¿Qué son las expresiones regulares y por qué son necesarias en Go?

Una expresión regular es una secuencia de caracteres que define un patrón para buscar en un texto. Por ejemplo, puedes verificar si una cadena contiene un correo electrónico, un número de teléfono o un formato de datos específico. En Go, el paquete regexp proporciona funciones para compilar patrones, buscar coincidencias, reemplazar texto y extraer subcadenas.

Principales capacidades de regexp:

• Búsqueda — verificar la presencia de una subcadena que coincida con el patrón.
• Extracción — obtener todas las coincidencias o grupos individuales.
• Reemplazo — reemplazar fragmentos encontrados con otro texto.
• Validación — verificar el formato de una cadena (correo electrónico, contraseña, URL).

Instalación e importación del paquete regexp

El paquete regexp forma parte de la biblioteca estándar de Go, por lo que no es necesario instalar nada. Para usarlo, solo hay que importarlo al inicio del archivo:

import (    "fmt"    "regexp")

1. Compilación de la expresión regular: Compile y MustCompile

El primer paso para trabajar con expresiones regulares es compilar el patrón. En Go hay dos formas principales:

• regexp.Compile(expr) — devuelve la expresión compilada y un error si el patrón es incorrecto.
• regexp.MustCompile(expr) — similar, pero genera un panic en caso de error. Es útil para patrones estáticos.

Ejemplo:

package main

import (    "fmt"    "regexp")

func main() {    // Usamos MustCompile, ya que el patrón es correcto de antemano    re := regexp.MustCompile(`[a-z]+`)        // Compile con manejo de errores    re2, err := regexp.Compile(`[0-9]+`)    if err != nil {        fmt.Println("Error de compilación:", err)        return    }    fmt.Println(re, re2)}

2. Métodos principales de búsqueda y verificación

Después de la compilación, tenemos un objeto *regexp.Regexp con un conjunto de métodos. Veamos los más útiles.

MatchString — verificación de coincidencia

El método MatchString(s string) bool devuelve true si la cadena contiene al menos una coincidencia con el patrón.

re := regexp.MustCompile(`go`)fmt.Println(re.MatchString("golang"))   // truefmt.Println(re.MatchString("python"))   // false

FindString — búsqueda de la primera coincidencia

Devuelve la primera subcadena que coincide con el patrón.

re := regexp.MustCompile(`[0-9]+`)fmt.Println(re.FindString("Precio: 100 rublos, descuento 20%")) // "100"

FindAllString — búsqueda de todas las coincidencias

Devuelve un slice de todas las cadenas encontradas. El segundo argumento es el número máximo de coincidencias (-1 para todas).

re := regexp.MustCompile(`[0-9]+`)result := re.FindAllString("Precio: 100 rublos, descuento 20%", -1)fmt.Println(result) // ["100", "20"]

3. Extracción de grupos con subexpresiones

Los paréntesis en el patrón crean grupos de captura (capturing groups). El método FindStringSubmatch devuelve un slice donde el primer elemento es la coincidencia completa y los siguientes son los valores de los grupos.

re := regexp.MustCompile(`(\\d{4})-(\\d{2})-(\\d{2})`)date := "Fecha: 2023-12-25"matches := re.FindStringSu