Expressões Regulares em Go com exemplos: guia completo para iniciantes

Expressões Regulares em Go (Golang): guia completo para iniciantes

Expressões regulares (regex) são uma ferramenta poderosa para buscar, extrair e substituir texto com base em padrões definidos. Na linguagem Go (Golang), o trabalho com expressões regulares é implementado através do pacote padrão regexp. Neste artigo, vamos abordar os fundamentos do trabalho com regexp em Go, examinar as funções principais e fornecer exemplos práticos que ajudarão você a começar a usar expressões regulares em seus projetos.

O que são expressões regulares e por que são necessárias em Go?

Uma expressão regular é uma sequência de caracteres que define um padrão para busca em texto. Por exemplo, você pode verificar se uma string contém um email, número de telefone ou um formato específico de dados. Em Go, o pacote regexp fornece funções para compilar padrões, buscar correspondências, substituir texto e extrair substrings.

Principais capacidades do regexp:

• Busca — verificar a existência de uma substring que corresponde ao padrão.
• Extração — obter todas as correspondências ou grupos individuais.
• Substituição — substituir trechos encontrados por outro texto.
• Validação — verificar o formato de uma string (email, senha, URL).

Instalação e importação do pacote regexp

O pacote regexp faz parte da biblioteca padrão do Go, portanto não é necessário instalar nada. Para usá-lo, basta importá-lo no início do arquivo:

import (    "fmt"    "regexp")

1. Compilação da expressão regular: Compile e MustCompile

O primeiro passo ao trabalhar com expressões regulares é compilar o padrão. Em Go, existem duas maneiras principais:

• regexp.Compile(expr) — retorna a expressão compilada e um erro, se o padrão for inválido.
• regexp.MustCompile(expr) — similar, mas causa pânico (panic) em caso de erro. Conveniente para padrões estáticos.

Exemplo:

package main

import (    "fmt"    "regexp")

func main() {    // Usamos MustCompile, pois o padrão é sabidamente válido    re := regexp.MustCompile(`[a-z]+`)        // Compile com tratamento de erro    re2, err := regexp.Compile(`[0-9]+`)    if err != nil {        fmt.Println("Erro de compilação:", err)        return    }    fmt.Println(re, re2)}

2. Métodos principais de busca e verificação

Após a compilação, temos um objeto *regexp.Regexp com um conjunto de métodos. Vamos examinar os mais úteis.

MatchString — verificação de correspondência

O método MatchString(s string) bool retorna true se a string contiver pelo menos uma correspondência com o padrão.

re := regexp.MustCompile(`go`)fmt.Println(re.MatchString("golang"))   // truefmt.Println(re.MatchString("python"))   // false

FindString — busca da primeira correspondência

Retorna a primeira substring que corresponde ao padrão.

re := regexp.MustCompile(`[0-9]+`)fmt.Println(re.FindString("Preço: 100 reais, desconto 20%")) // "100"

FindAllString — busca de todas as correspondências

Retorna um slice de todas as strings encontradas. O segundo argumento é o número máximo de correspondências (-1 para todas).

re := regexp.MustCompile(`[0-9]+`)result := re.FindAllString("Preço: 100 reais, desconto 20%", -1)fmt.Println(result) // ["100", "20"]

3. Extração de grupos usando subexpressões

Parênteses no padrão criam grupos de captura (capturing groups). O método FindStringSubmatch retorna um slice onde o primeiro elemento é a correspondência completa e os seguintes são os valores dos grupos.

re := regexp.MustCompile(`(\\d{4})-(\\d{2})-(\\d{2})`)date := "Data: 2023-12-25"matches := re.FindStringSu