Go Academy · Lección

Conceptos básicos de regexp

Compile y compare patrones

Conceptos básicos de regexp es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

¿Qué es una expresión regular?

Una expresión regular (regexp) es un patrón que describe un conjunto de cadenas. Go las proporciona mediante el paquete regexp.

Resultan ideales para validar y buscar texto.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    matched, _ := regexp.MatchString("go+", "gooo")
    fmt.Println(matched)
}

Coincidencia rápida con MatchString

regexp.MatchString(pattern, s) indica si el patrón aparece en cualquier parte de s. Devuelve un booleano y un error.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    ok, _ := regexp.MatchString("cat", "the cat sat")
    fmt.Println(ok)
}

Compilar un patrón

Para usarlo repetidamente, compílelo una vez con regexp.Compile. Devuelve un *regexp.Regexp reutilizable y un error si el patrón no es válido.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re, err := regexp.Compile("[0-9]+")
    fmt.Println(re.MatchString("abc123"), err)
}

MustCompile para constantes

regexp.MustCompile provoca un pánico si el patrón no es válido. Úselo para patrones fijos conocidos en tiempo de compilación, normalmente en variables de ámbito de paquete.

package main

import (
    "fmt"
    "regexp"
)

var digits = regexp.MustCompile("[0-9]+")

func main() {
    fmt.Println(digits.MatchString("order 42"))
}

Clases de caracteres

Los corchetes definen un conjunto de caracteres permitidos. [aeiou] coincide con cualquier vocal; los rangos como [a-z] coinciden con un intervalo.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[a-z]+")
    fmt.Println(re.MatchString("Hello"))
}

Clases predefinidas

Los atajos facilitan el uso de conjuntos habituales: \d representa un dígito, \w, un carácter de palabra, y \s, un espacio en blanco. En las cadenas de Go, debe escapar la barra inversa.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("\\d+")
    fmt.Println(re.MatchString("abc 99"))
}

Cuantificadores

Los cuantificadores indican cuántas veces:

*: cero o más,
+: una o más,
?: cero o una,
{2,4}: un intervalo.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("a{2,3}")
    fmt.Println(re.MatchString("aaa"))
    fmt.Println(re.MatchString("a"))
}

Anclas

Las anclas fijan una coincidencia: ^ indica el inicio del texto y $, el final. Use ambas para exigir que coincida toda la cadena.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("^go$")
    fmt.Println(re.MatchString("go"))
    fmt.Println(re.MatchString("going"))
}

Alternancia y grupos

La barra vertical | significa O, y los paréntesis agrupan partes. (cat|dog)s? coincide con cat, cats, dog o dogs.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(cat|dog)s?")
    fmt.Println(re.MatchString("dogs"))
}

Validar un formato

Los patrones anclados permiten crear validadores. Aquí comprobamos un código sencillo, de estilo ZIP, compuesto exactamente por cinco dígitos.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("^\\d{5}$")
    fmt.Println(re.MatchString("12345"))
    fmt.Println(re.MatchString("123"))
}

Coincidencias sobre bytes

Los métodos tienen versiones para cadenas y slices de bytes. Match funciona con un []byte, de forma equivalente a MatchString.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.Match([]byte("id7")))
}

Comprobación rápida

¿Qué función provoca un pánico con un patrón no válido y es la más adecuada para patrones fijos?

Repaso: fundamentos de regexp

Ha aprendido los fundamentos:

Busque coincidencias rápidamente con MatchString; compile con Compile o MustCompile.
Construya patrones con clases, cuantificadores, anclas y grupos.
Use ^ y $ como anclas para validar cadenas completas.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("^[a-z]+@[a-z]+$")
    fmt.Println(re.MatchString("hi@host"))
}

Preguntas frecuentes

¿La lección «Conceptos básicos de regexp» es gratis?

Sí — el texto completo de «Conceptos básicos de regexp» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Conceptos básicos de regexp»?

Compile y compare patrones Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Conceptos básicos de regexp»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy