Go Academy · Aula

Noções básicas de regexp

Compile e faça correspondência de padrões

Noções básicas de regexp é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 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.

O que é uma expressão regular?

Uma expressão regular (regexp) é um padrão que descreve um conjunto de textos. Go oferece expressões regulares por meio do pacote regexp.

Elas são perfeitas para validar e pesquisar textos.

package main

import (
    "fmt"
    "regexp"
)

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

Correspondência rápida com MatchString

regexp.MatchString(pattern, s) informa se o padrão aparece em algum lugar de s. Ele retorna um booleano e um erro.

package main

import (
    "fmt"
    "regexp"
)

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

Compilando um padrão

Para uso repetido, compile uma vez com regexp.Compile. Ele retorna um *regexp.Regexp reutilizável e um erro para padrões inválidos.

package main

import (
    "fmt"
    "regexp"
)

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

MustCompile para constantes

regexp.MustCompile causa uma interrupção se o padrão for inválido. Use-o para padrões fixos conhecidos no momento da compilação, normalmente em variáveis no nível do pacote.

package main

import (
    "fmt"
    "regexp"
)

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

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

Classes de caracteres

Colchetes definem um conjunto de caracteres permitidos. [aeiou] corresponde a qualquer vogal; intervalos como [a-z] correspondem a uma faixa.

package main

import (
    "fmt"
    "regexp"
)

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

Classes predefinidas

Atalhos facilitam conjuntos comuns: \d representa um dígito, \w um caractere de palavra e \s um espaço em branco. Em textos de Go, escape a barra invertida.

package main

import (
    "fmt"
    "regexp"
)

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

Quantificadores

Quantificadores indicam quantas vezes:

* zero ou mais,
+ uma ou mais,
? zero ou uma,
{2,4} um intervalo.

package main

import (
    "fmt"
    "regexp"
)

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

Âncoras

Âncoras fixam uma correspondência: ^ significa início do texto e $ significa fim. Use ambas para exigir que todo o texto corresponda ao padrão.

package main

import (
    "fmt"
    "regexp"
)

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

Alternância e grupos

O caractere de barra vertical | significa OR, e os parênteses agrupam partes. (cat|dog)s? corresponde a cat, cats, dog ou dogs.

package main

import (
    "fmt"
    "regexp"
)

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

Validando um formato

Padrões ancorados criam validadores. Aqui, verificamos um código simples no estilo ZIP, formado exatamente 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"))
}

Correspondência em bytes

Os métodos têm versões para textos e fatias de bytes. Match funciona com um []byte, de forma equivalente a MatchString.

package main

import (
    "fmt"
    "regexp"
)

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

Verificação rápida

Qual função causa uma interrupção diante de um padrão inválido e é mais adequada para padrões fixos?

Recapitulação: fundamentos de regexp

Você aprendeu os fundamentos:

Faça correspondências rapidamente com MatchString; compile com Compile ou MustCompile.
Crie padrões usando classes, quantificadores, âncoras e grupos.
Use ^ e $ como âncoras para validar o texto completo.

package main

import (
    "fmt"
    "regexp"
)

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

Perguntas Frequentes

A aula “Noções básicas de regexp” é grátis?

Sim — o texto completo de “Noções básicas de regexp” é 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 “Noções básicas de regexp”?

Compile e faça correspondência de padrões 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 1 de 4.

Quanto tempo leva a aula “Noções básicas de regexp”?

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