Go Academy · Aula

Substituição de texto

Use padrões ReplaceAll

Substituição de texto é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Substituição baseada em padrões

Expressões regulares podem reescrever textos, não apenas encontrá-los. ReplaceAllString troca todas as correspondências por um texto de substituição.

package main

import (
    "fmt"
    "regexp"
)

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

Substituindo palavras completas

Um padrão como cat|dog permite substituir várias alternativas em uma única passagem.

package main

import (
    "fmt"
    "regexp"
)

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

Reduzindo espaços em branco

Uma limpeza comum é substituir sequências de espaços em branco por um único espaço usando \s+.

package main

import (
    "fmt"
    "regexp"
)

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

Referenciando grupos

Na substituição, $1 insere o primeiro grupo de captura e $2 o segundo. Isso reorganiza as partes correspondentes.

package main

import (
    "fmt"
    "regexp"
)

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

Referências a grupos nomeados

Com grupos nomeados, você pode usar ${name} na substituição para maior clareza.

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}"))
}

Chaves seguras

Use as chaves ${1} quando houver texto após uma referência a um grupo, para que $1 não seja confundido com um nome mais longo.

package main

import (
    "fmt"
    "regexp"
)

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

Substituição literal

ReplaceAllLiteralString ignora as referências $ e insere a substituição exatamente como foi escrita.

package main

import (
    "fmt"
    "regexp"
)

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

Substituir com uma função

ReplaceAllStringFunc chama a sua função para cada correspondência e substitui o texto pelo que ela retornar. Isso permite fazer substituições calculadas.

package main

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

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

Substituição calculada

Dentro da função, você pode transformar cada correspondência como quiser; neste caso, cada sequência de dígitos encontrada é duplicada ao ser envolvida.

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)
}

Mascarar dados sensíveis

Um uso prático é ocultar números, como sequências de dígitos semelhantes a números de cartão, antes de registrá-los.

package main

import (
    "fmt"
    "regexp"
)

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

Trabalhar com bytes

Também existem variantes para fatias de bytes, como ReplaceAll, que espelham os métodos para cadeias de caracteres e trabalham com dados binários ou de memória intermediária.

package main

import (
    "fmt"
    "regexp"
)

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

Verificação rápida

Como você insere o primeiro grupo de captura em uma cadeia de substituição?

Recapitulação: substituição de texto

Você aprendeu a reescrever texto:

ReplaceAllString troca as correspondências; $1/${name} fazem referência aos grupos.
ReplaceAllLiteralString ignora a expansão.
ReplaceAllStringFunc calcula cada substituição.

package main

import (
    "fmt"
    "regexp"
)

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

Perguntas Frequentes

A aula “Substituição de texto” é grátis?

Sim — o texto completo de “Substituição de texto” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Substituição de texto”?

Use padrões ReplaceAll Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Substituição de texto”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy