Go Academy · Lección

Reemplazo de texto

Reemplace patrones con ReplaceAll

Reemplazo de texto es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 3 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.

Reemplazo basado en patrones

Las expresiones regulares pueden reescribir texto, no solo encontrarlo. ReplaceAllString sustituye cada coincidencia por una cadena de reemplazo.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.ReplaceAllString("a1b2c3", "#"))
}

Reemplazar palabras completas

Un patrón como cat|dog permite reemplazar varias alternativas en una sola pasada.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("cat|dog")
    fmt.Println(re.ReplaceAllString("my cat and dog", "pet"))
}

Compactar espacios en blanco

Una limpieza habitual consiste en reemplazar secuencias de espacios en blanco por un único espacio mediante \s+.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("\\s+")
    fmt.Println(re.ReplaceAllString("too   many    spaces", " "))
}

Hacer referencia a grupos

En el reemplazo, $1 inserta el primer grupo de captura y $2, el segundo. Así puede reorganizar las partes coincidentes.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\d+)-(\\d+)")
    fmt.Println(re.ReplaceAllString("12-34", "$2-$1"))
}

Referencias a grupos con nombre

Con los grupos con nombre, puede usar ${name} en el reemplazo para mejorar la claridad.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(?P<y>\\d{4})-(?P<m>\\d{2})")
    fmt.Println(re.ReplaceAllString("2026-05", "${m}/${y}"))
}

Llaves seguras

Use la notación con llaves ${1} cuando haya texto después de una referencia a un grupo, para que $1 no se confunda con un nombre más largo.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\d+)")
    fmt.Println(re.ReplaceAllString("7", "${1}px"))
}

Reemplazo literal

ReplaceAllLiteralString ignora las referencias $ e inserta el reemplazo exactamente como está escrito.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.ReplaceAllLiteralString("a1", "$money"))
}

Reemplazar con una función

ReplaceAllStringFunc llama a su función para cada coincidencia y sustituye el texto por lo que esta devuelve. Esto permite realizar reemplazos calculados.

package main

import (
    "fmt"
    "regexp"
    "strings"
)

func main() {
    re := regexp.MustCompile("[a-z]+")
    out := re.ReplaceAllStringFunc("go is fun", strings.ToUpper)
    fmt.Println(out)
}

Reemplazo calculado

Dentro de la función puede transformar cada coincidencia como quiera; aquí se duplica cada secuencia de dígitos encontrada envolviéndola.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    out := re.ReplaceAllStringFunc("id5 and id9", func(m string) string {
        return "<" + m + ">"
    })
    fmt.Println(out)
}

Enmascarar datos confidenciales

Un uso práctico es ocultar números, como secuencias de dígitos de tarjetas, antes de registrarlos en los logs.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("\\d{4}")
    fmt.Println(re.ReplaceAllString("card 1234 5678", "****"))
}

Trabajar con bytes

También existen variantes para slices de bytes, como ReplaceAll, que funcionan de forma equivalente a los métodos para strings con datos binarios o de búfer.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    out := re.ReplaceAll([]byte("a1b2"), []byte("#"))
    fmt.Println(string(out))
}

Comprobación rápida

¿Cómo inserta el primer grupo de captura en una cadena de reemplazo?

Repaso: reemplazar texto

Ha aprendido a reescribir texto:

ReplaceAllString sustituye las coincidencias; $1/${name} hacen referencia a grupos.
ReplaceAllLiteralString omite la expansión.
ReplaceAllStringFunc calcula cada reemplazo.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\w+)\\s(\\w+)")
    fmt.Println(re.ReplaceAllString("Ada Lovelace", "$2, $1"))
}

Preguntas frecuentes

¿La lección «Reemplazo de texto» es gratis?

Sí — el texto completo de «Reemplazo de texto» 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 «Reemplazo de texto»?

Reemplace patrones con ReplaceAll 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 3 de 4.

¿Cuánto tiempo toma la lección «Reemplazo de texto»?

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