Expressões regulares explicadas: padrões, grupos e exemplos reais

Regex parece ruído de teclado — \d{3}-\d{4} —, mas é uma linguagem pequena para descrever texto. Aprenda os blocos básicos, como o motor realmente compara e os padrões que valem a pena memorizar.

📂 Fundamentos para desenvolvedores ⏱ Cerca de 14 minutos 📶 Intermediário 🛠️ Combina com: testador de regex

O que você vai aprender

  • Ler uma regex em voz alta e dizer o que ela corresponde
  • Usar classes de caracteres, quantificadores, âncoras e grupos com confiança
  • Saber quando a correspondência gulosa morde — e como a correspondência preguiçosa resolve
  • Escrever padrões para e-mails, datas, números de telefone e linhas de log
  • Reconhecer os padrões que congelam um programa (backtracking catastrófico)
Neste guia
  1. O que é uma expressão regular
  2. Os blocos de construção
  3. Como o mecanismo realmente corresponde: guloso, preguiçoso e backtracking
  4. Padrões que valem a pena memorizar
  5. Flags: os interruptores que mudam tudo
  6. Erros comuns
  7. Teste: testador de regex
  8. Perguntas frequentes

O que é uma expressão regular

A expressão regular (regex) é um padrão que descreve um conjunto de strings. Em vez de escrever código que diz “verifique cada caractere um por um”, você escreve uma descrição compacta — \d{3}-\d{4} — e pergunta: este texto contém algo com esse formato?

Regexes estão em todos os lugares: buscando em um editor, validando um formulário, renomeando mil arquivos, analisando um log, destacando correspondências em uma página. Elas não são uma linguagem de programação própria, mas quase todas as linguagens incorporam a mesma sintaxe básica — aprenda uma vez e ela acompanha você do JavaScript ao Python até a linha de comando.

O problema é a legibilidade. A regex é famosa por ser write-only: um padrão que você escreveu no mês passado pode parecer ruído de linha hoje. A solução não é evitar a regex, mas construir padrões a partir de pequenas peças nomeadas e testá-los — que é exatamente para isso que servem este guia e o testador associado.

Os blocos de construção

Quase todo padrão é montado a partir destas peças:

PeçaSignificadoExemplo
abcCaracteres literaiscorresponde a abc exatamente
.Qualquer caractere único (exceto quebra de linha)a.c corresponde a abc, a-c
\d \w \sDígito, caractere de palavra, espaço em branco\d corresponde a 7
\D \W \SOs opostos (não um dígito etc.)\D corresponde a a
[abc] [a-z] [^0-9]Classe de caracteres / classe negada[aeiou] corresponde a uma vogal
* + ? {n} {n,m}Quantificadores: 0+, 1+, 0/1, exatamente n, n a m\d{3} corresponde a três dígitos
^ $ \bÂncoras: início, fim, fronteira de palavra^cat corresponde apenas no início
( ) (?: ) (?<name> )Grupo de captura, não captura, grupo nomeado(\d+)-(\d+) captura dois números
|Alternância (ou)cat|dog corresponde a qualquer um
\Escape: torna um caractere especial literal\. corresponde a um ponto real

Duas peças causam a maioria dos bugs de iniciantes. Primeiro, . é especial — para corresponder a um ponto literal em example.com você precisa escrever example\.com, ou seu padrão também corresponde a exampleXcom. Segundo, uma classe de caracteres [.] não precisa de escape dentro dos colchetes — a maioria dos caracteres perde sua magia ali.

Como o mecanismo realmente corresponde: guloso, preguiçoso e backtracking

Um mecanismo de regex lê seu padrão da esquerda para a direita e tenta corresponder, um passo de cada vez. Quando encontra um quantificador como .* ele é guloso por padrão: ele pega o máximo possível e depois devolve caracteres um de cada vez até que o resto do padrão se encaixe. Esse processo — tentar, falhar, devolver — se chama backtracking.

<p>first</p> <p>second</p>
Pattern: <p>.*</p>      → matches the WHOLE line (greedy)
Pattern: <p>.*?</p>     → matches <p>first</p> only (lazy)

Adicionar ? depois de um quantificador o torna preguiçoso: corresponde ao mínimo possível. Guloso é o padrão certo para “tudo até o fim”; preguiçoso é o padrão certo para “a próxima tag de fechamento”. Escolher errado é o motivo mais comum de um padrão corresponder a muito mais (ou muito menos) do que o esperado.

Backtracking catastrófico. Um padrão como (a+)+$ em uma longa string de a's pode levar efetivamente para sempre: o mecanismo tenta exponencialmente muitas maneiras de dividir os mesmos caracteres. A regra: nunca aninhe quantificadores sobre escolhas sobrepostas e prefira um padrão específico ([^<]*) em vez de um vago (.*) dentro de um grupo repetido.

Padrões que valem a pena memorizar

Guarde estes como pontos de partida — teste cada um com seus dados reais antes de colocá-los em produção:

# A simple email check (good enough for a form hint, not proof)
\b[\w.+-]+@[\w-]+\.[\w.]+\b

# Date: YYYY-MM-DD
^\d{4}-\d{2}-\d{2}$

# North American phone number, flexible separators
^\+?1?[-. ]?\(?\d{3}\)?[-. ]?\d{3}[-. ]?\d{4}$

# A word, with its position: capture the username from user@host
^(?<user>[\w.+-]+)@(?<host>[\w-]+\.[\w.]+)$

# Lines starting with ERROR in a log file (multiline flag m)
^ERROR: (.*)$

Note que o padrão de e-mail é deliberadamente imperfeito: o padrão real para endereços de e-mail é tão complicado que uma única regex para “todos os e-mails válidos” tem centenas de caracteres e ainda assim está errada. A abordagem profissional é uma verificação simples de sanidade mais o envio real de um e-mail de confirmação.

Flags: os interruptores que mudam tudo

FlagEfeito
gGlobal — encontra todas as correspondências, não só a primeira
iCase-insensitive — cat corresponde a CAT
mMultiline — ^ e $ correspondem ao início/fim das linhas
sDot-all — . também corresponde a quebras de linha
uModo Unicode — tratamento correto de emoji e caracteres astrais

O m flag surpreende mais as pessoas: sem ele, ^ERROR só corresponde bem no início de todo o texto, não no início de cada linha em um arquivo de log. Se seu padrão funciona em uma linha, mas não em um arquivo, o m ausente é a primeira coisa a verificar.

Erros comuns

  • Usando .* quando você quer dizer [^<]* ou \S+. Padrões vagos fazem backtracking e correspondem demais; padrões específicos são mais rápidos e seguros.
  • Esquecer de escapar ., (, + em texto literal. file.txt como padrão também corresponde a fileatxt.
  • Validar e-mail com uma regex gigante. Use uma verificação simples e depois confirme enviando um e-mail.
  • Analisar HTML ou estruturas aninhadas com regex. HTML não é uma linguagem regular — um parser é a ferramenta certa, e a regex quebrará na primeira tag aninhada.
  • Quantificadores aninhados como (a+)+ ou (.*)*. O congelamento clássico. Reescreva com um único quantificador sobre uma classe precisa.
  • Esquecer a g flag. Em muitas ferramentas, só a primeira correspondência é retornada, a menos que você peça todas elas.

Teste: testador de regex

Cada padrão deste guia é testável: cole-o no testador de regex, digite seu próprio texto abaixo e veja as correspondências destacadas ao vivo — com cada grupo de captura listado.

Abrir o testador de regex →

Continue aprendendo

Perguntas frequentes

Qual sabor de regex devo aprender?

A sintaxe básica é a mesma em quase todos os lugares. JavaScript, Python, Java e Go concordam no básico da tabela acima; eles diferem nos detalhes (lookbehind, sintaxe de grupo nomeado, tratamento de Unicode). Aprenda o básico e depois consulte a documentação da sua linguagem para os detalhes — e teste no testador de regex, que usa o mecanismo JavaScript do seu navegador.

O que é um grupo de captura e por que eu usaria um?

Os parênteses fazem dois trabalhos: agrupam parte de um padrão e, por padrão, também capturam o que corresponderam, para que você possa reutilizá-lo — por exemplo, transformando 2026-11-21 em 21/11/2026 com uma substituição como $3/$2/$1. Use (?:…) quando só precisar de agrupamento e não quiser a captura.

Por que minha regex está lenta ou congelando a página?

Quase sempre backtracking catastrófico: quantificadores aninhados sobre escolhas sobrepostas, em uma entrada longa. Simplifique o padrão, substitua .* por uma classe negada ou adicione uma âncora para que o mecanismo falhe rápido em vez de tentar todas as divisões.

Qual é a diferença entre * e +?

* significa “zero ou mais” — a peça pode estar totalmente ausente. + significa “um ou mais” — precisa aparecer pelo menos uma vez. \\d* corresponde a uma string vazia; \\d+ não. Essa diferença de um caractere é uma fonte frequente de padrões que correspondem quando não deveriam.

A regex pode validar um endereço de e-mail corretamente?

Nenhuma regex prática cobre o padrão completo — strings entre aspas, comentários e domínios incomuns a tornam absurdamente longa. Um padrão curto mais um e-mail de confirmação é a resposta profissional; a regex é um caça-erros de digitação, não uma prova.