Go Academy · Lección

Búsqueda y extracción

Use FindString y las subcoincidencias

Búsqueda y extracción es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 2 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.

Más allá de las coincidencias

Buscar coincidencias indica si existe un patrón. La familia de funciones Find indica qué coincidió y dónde, de modo que puede extraer datos.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.FindString("order 42 ready"))
}

FindString

FindString(s) devuelve la primera coincidencia como cadena, o una cadena vacía si no hay ninguna.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[a-z]+")
    fmt.Printf("%q\n", re.FindString("123abc456"))
}

FindAllString

FindAllString(s, n) devuelve todas las coincidencias en un slice. Pase -1 para obtenerlas todas o un límite positivo.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.FindAllString("a1 b22 c333", -1))
}

Limitar resultados

Pase un valor positivo de n para detenerse después de ese número de coincidencias.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.FindAllString("1 2 3 4", 2))
}

Encontrar el índice

FindStringIndex(s) devuelve las posiciones inicial y final, en bytes, de la primera coincidencia como un slice de dos elementos.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("cat")
    fmt.Println(re.FindStringIndex("a cat here"))
}

Grupos de captura

Los paréntesis crean grupos de captura. FindStringSubmatch devuelve primero la coincidencia completa y después cada grupo capturado.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\d+)-(\\d+)")
    m := re.FindStringSubmatch("12-34")
    fmt.Println(m)
}

Usar valores de subcoincidencias

Acceda al slice de subcoincidencias mediante su índice: el elemento 0 es la coincidencia completa, el elemento 1 es el primer grupo, y así sucesivamente.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\d+):(\\d+)")
    m := re.FindStringSubmatch("09:30")
    fmt.Println("hour", m[1], "min", m[2])
}

Grupos con nombre

Asigne un nombre a un grupo con (?P<name>...) y, después, léalo mediante SubexpNames junto con el slice de subcoincidencias.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(?P<area>\\d{3})-(?P<num>\\d{4})")
    m := re.FindStringSubmatch("555-1234")
    for i, name := range re.SubexpNames() {
        if name != "" {
            fmt.Println(name, m[i])
        }
    }
}

Todas las subcoincidencias

FindAllStringSubmatch(s, n) devuelve un slice de slices de subcoincidencias, uno por cada coincidencia. Es muy útil para analizar muchos registros.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\w+)=(\\d+)")
    all := re.FindAllStringSubmatch("x=1 y=2", -1)
    for _, m := range all {
        fmt.Println(m[1], m[2])
    }
}

Comportamiento sin coincidencias

Cuando no coincide nada, los métodos Find devuelven una cadena vacía o un slice nil. Compruébelo antes de acceder a un índice para evitar un pánico.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    m := re.FindStringSubmatch("no digits")
    fmt.Println(m == nil)
}

Extraer datos reales

Combine grupos para extraer campos estructurados de una línea de texto.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\d{4})-(\\d{2})-(\\d{2})")
    m := re.FindStringSubmatch("date: 2026-05-30")
    fmt.Println("year", m[1])
}

Comprobación rápida

¿Qué elemento de un slice de subcoincidencias contiene la coincidencia completa?

Repaso: buscar y extraer

Ahora puede extraer datos del texto:

FindString y FindAllString devuelven coincidencias.
FindStringSubmatch devuelve la coincidencia completa y los grupos de captura.
Use grupos con nombre y compruebe si el valor es nil cuando no hay coincidencias.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\w+)@(\\w+)")
    m := re.FindStringSubmatch("user@host")
    fmt.Println(m[1], "at", m[2])
}

Preguntas frecuentes

¿La lección «Búsqueda y extracción» es gratis?

Sí — el texto completo de «Búsqueda y extracción» 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 «Búsqueda y extracción»?

Use FindString y las subcoincidencias 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 2 de 4.

¿Cuánto tiempo toma la lección «Búsqueda y extracción»?

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