Go Academy · Aula

Dicas de desempenho

Reutilize regexps compiladas

Dicas de desempenho é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 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.

A compilação tem um custo

Transformar uma cadeia de caracteres de padrão em uma expressão regular utilizável exige trabalho. Fazer isso em cada chamada desperdiça tempo, especialmente em laços ou caminhos críticos.

package main

import (
    "fmt"
    "regexp"
)

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

Compile uma vez, reutilize sempre

A regra de ouro é compilar um padrão uma vez e reutilizar o *regexp.Regexp. Uma variável no nível do pacote é o local habitual para isso.

package main

import (
    "fmt"
    "regexp"
)

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

func hasNumber(s string) bool {
    return numRe.MatchString(s)
}

func main() {
    fmt.Println(hasNumber("a1"))
    fmt.Println(hasNumber("abc"))
}

Evite compilar em laços

Nunca chame MustCompile dentro de um laço. Compile antes do laço e use o mesmo valor em cada iteração.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[a-z]+")
    inputs := []string{"go", "123", "rust"}
    for _, s := range inputs {
        fmt.Println(s, re.MatchString(s))
    }
}

Regexp pode ser compartilhada com segurança

Uma *regexp.Regexp compilada é segura para uso concorrente por várias gorrotinas. Uma única instância global pode atender a todas elas.

package main

import (
    "fmt"
    "regexp"
)

var re = regexp.MustCompile("go")

func main() {
    fmt.Println(re.MatchString("golang"))
}

Às vezes, cadeias de caracteres são mais rápidas

Para uma subsequência literal fixa, strings.Contains é mais rápido que uma expressão regular. Use expressões regulares somente quando precisar do verdadeiro poder dos padrões.

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Contains("hello world", "world"))
}

Prefira padrões ancorados

Ancorar com ^ permite que o mecanismo falhe rapidamente quando o início não corresponde, em vez de percorrer a cadeia de caracteres inteira.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("^https?://")
    fmt.Println(re.MatchString("http://site"))
    fmt.Println(re.MatchString("see http://x"))
}

Limite a quantidade de correspondências

Quando você precisa de apenas algumas correspondências, passe um n pequeno aos métodos de localização de todas as ocorrências, em vez de -1, para interromper a busca mais cedo.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.FindAllString("1 2 3 4 5", 2))
}

Tenha cuidado com padrões de retrocesso

O mecanismo RE2 do Go evita o retrocesso catastrófico, mas padrões amplos demais, como .*, ainda podem percorrer mais texto do que o necessário. Seja específico.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    broad := regexp.MustCompile(".*=.*")
    precise := regexp.MustCompile("[a-z]+=[0-9]+")
    fmt.Println(broad.MatchString("x=1"), precise.MatchString("x=1"))
}

Escape a entrada dinâmica

Se um padrão incluir texto fornecido pelo usuário, escape-o com regexp.QuoteMeta para que os caracteres especiais sejam tratados literalmente.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    user := "a.b"
    re := regexp.MustCompile(regexp.QuoteMeta(user))
    fmt.Println(re.MatchString("a.b"))
    fmt.Println(re.MatchString("axb"))
}

Armazene padrões compilados em cache

Se os padrões forem construídos durante a execução, armazene os já compilados em um mapa indexado pela cadeia de caracteres do padrão para evitar recompilar o mesmo padrão.

package main

import (
    "fmt"
    "regexp"
)

var cache = map[string]*regexp.Regexp{}

func get(p string) *regexp.Regexp {
    if re, ok := cache[p]; ok {
        return re
    }
    re := regexp.MustCompile(p)
    cache[p] = re
    return re
}

func main() {
    fmt.Println(get("[0-9]+").MatchString("7"))
}

Juntando tudo

Um validador bem ajustado compila uma vez, ancora o padrão e é compartilhado entre todas as chamadas.

package main

import (
    "fmt"
    "regexp"
)

var emailRe = regexp.MustCompile("^[a-z0-9]+@[a-z]+\\.[a-z]+$")

func main() {
    fmt.Println(emailRe.MatchString("me@site.com"))
}

Verificação rápida

Qual é a dica de desempenho mais importante para expressões regulares?

Recapitulação: dicas de desempenho

Você aprendeu a usar expressões regulares com eficiência:

Compile uma vez com MustCompile e reutilize; o uso concorrente é seguro.
Prefira strings para subsequências fixas, ancore os padrões e limite a quantidade de correspondências.
Escape a entrada dinâmica com QuoteMeta e armazene em cache os padrões criados durante a execução.

package main

import (
    "fmt"
    "regexp"
)

var re = regexp.MustCompile("^\\d{4}$")

func main() {
    for _, s := range []string{"1234", "12"} {
        fmt.Println(s, re.MatchString(s))
    }
}

Perguntas Frequentes

A aula “Dicas de desempenho” é grátis?

Sim — o texto completo de “Dicas de desempenho” é 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 “Dicas de desempenho”?

Reutilize regexps compiladas 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 4 de 4.

Quanto tempo leva a aula “Dicas de desempenho”?

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