Tutorial de Expressões Regulares em Golang

Introdução

Este laboratório demonstra como usar expressões regulares (regular expressions) em Golang.

Expressões Regulares (Regular Expressions)

O laboratório exige que você complete o código para realizar várias tarefas relacionadas a expressões regulares em Golang.

• Use o pacote regexp para realizar tarefas relacionadas a expressões regulares.
• Use MatchString para testar se um padrão corresponde a uma string.
• Use Compile para otimizar uma struct Regexp.
• Use MatchString para testar uma correspondência como Compile.
• Use FindString para encontrar a correspondência para a expressão regular.
• Use FindStringIndex para encontrar a primeira correspondência e retornar os índices de início e fim da correspondência em vez do texto correspondente.
• Use FindStringSubmatch para retornar informações para p([a-z]+)ch e ([a-z]+).
• Use FindStringSubmatchIndex para retornar informações sobre os índices das correspondências e subcorrespondências.
• Use FindAllString para encontrar todas as correspondências para uma expressão regular.
• Use FindAllStringSubmatchIndex para aplicar a todas as correspondências na entrada, não apenas a primeira.
• Use Match para testar uma correspondência com argumentos []byte e remover String do nome da função.
• Use MustCompile para criar variáveis globais com expressões regulares.
• Use ReplaceAllString para substituir subconjuntos de strings por outros valores.
• Use ReplaceAllFunc para transformar o texto correspondente com uma função fornecida.

## Para uma referência completa sobre expressões regulares em Go, verifique
## a documentação do pacote [`regexp`](https://pkg.go.dev/regexp).

Aqui está o código completo:

// Go oferece suporte integrado para [expressões regulares](https://en.wikipedia.org/wiki/Regular_expression).
// Aqui estão alguns exemplos de tarefas comuns relacionadas a regexp
// em Go.

package main

import (
    "bytes"
    "fmt"
    "regexp"
)

func main() {

    // Isso testa se um padrão corresponde a uma string.
    match, _ := regexp.MatchString("p([a-z]+)ch", "peach")
    fmt.Println(match)

    // Acima, usamos um padrão de string diretamente, mas para
    // outras tarefas de regexp, você precisará `Compile` uma
    // struct `Regexp` otimizada.
    r, _ := regexp.Compile("p([a-z]+)ch")

    // Muitos métodos estão disponíveis nessas structs. Aqui está
    // um teste de correspondência como vimos anteriormente.
    fmt.Println(r.MatchString("peach"))

    // Isso encontra a correspondência para a expressão regular.
    fmt.Println(r.FindString("peach punch"))

    // Isso também encontra a primeira correspondência, mas retorna o
    // índices de início e fim para a correspondência em vez do
    // texto correspondente.
    fmt.Println("idx:", r.FindStringIndex("peach punch"))

    // As variantes `Submatch` incluem informações sobre
    // tanto as correspondências de padrão completo quanto as subcorrespondências
    // dentro dessas correspondências. Por exemplo, isso retornará
    // informações para `p([a-z]+)ch` e `([a-z]+)`.
    fmt.Println(r.FindStringSubmatch("peach punch"))

    // Da mesma forma, isso retornará informações sobre o
    // índices de correspondências e subcorrespondências.
    fmt.Println(r.FindStringSubmatchIndex("peach punch"))

    // As variantes `All` dessas funções se aplicam a todas as
    // correspondências na entrada, não apenas a primeira. Para
    // por exemplo, encontrar todas as correspondências para uma expressão regular.
    fmt.Println(r.FindAllString("peach punch pinch", -1))

    // Essas variantes `All` estão disponíveis para as outras
    // funções que vimos acima também.
    fmt.Println("all:", r.FindAllStringSubmatchIndex(
        "peach punch pinch", -1))

    // Fornecer um inteiro não negativo como o segundo
    // argumento para essas funções limitará o número
    // de correspondências.
    fmt.Println(r.FindAllString("peach punch pinch", 2))

    // Nossos exemplos acima tinham argumentos de string e usavam
    // nomes como `MatchString`. Também podemos fornecer
    // argumentos `[]byte` e remover `String` do
    // nome da função.
    fmt.Println(r.Match([]byte("peach")))

    // Ao criar variáveis globais com expressões
    // regulares, você pode usar a variação `MustCompile`
    // de `Compile`. `MustCompile` entra em pânico em vez de
    // retornar um erro, o que o torna mais seguro para usar para
    // variáveis globais.
    r = regexp.MustCompile("p([a-z]+)ch")
    fmt.Println("regexp:", r)

    // O pacote `regexp` também pode ser usado para substituir
    // subconjuntos de strings por outros valores.
    fmt.Println(r.ReplaceAllString("a peach", "<fruit>"))

    // A variante `Func` permite que você transforme o texto correspondente
    // com uma função fornecida.
    in := []byte("a peach")
    out := r.ReplaceAllFunc(in, bytes.ToUpper)
    fmt.Println(string(out))
}

Resumo

Este laboratório demonstra como usar expressões regulares (regular expressions) em Golang para realizar várias tarefas, como testar se um padrão corresponde a uma string, encontrar a correspondência para a expressão regular e substituir subconjuntos de strings por outros valores.