Folha de Referência de Padrões Regex: Expressões Comuns Explicadas

31 de março de 2026 · 12 min de leitura

Expressões regulares (regex) são uma das ferramentas mais poderosas no arsenal de um desenvolvedor. Seja validando endereços de e-mail, analisando arquivos de log, extraindo dados de texto ou construindo operações complexas de busca e substituição, regex fornece uma maneira concisa e flexível de trabalhar com padrões de texto.

Este guia abrangente cobre tudo, desde sintaxe básica até técnicas avançadas, com exemplos práticos que você pode usar imediatamente em seus projetos. Exploraremos regex em diferentes linguagens de programação, compartilharemos dicas de otimização de desempenho e ajudaremos você a evitar erros comuns que confundem até desenvolvedores experientes.

Fundamentos de Regex

Em sua essência, uma expressão regular é uma sequência de caracteres que define um padrão de busca. Quando você executa este padrão contra uma string, o motor regex tenta encontrar correspondências de acordo com as regras que você especificou.

Um padrão regex consiste em dois tipos de caracteres: caracteres literais que correspondem exatamente a si mesmos, e metacaracteres que têm significados especiais. Por exemplo, o padrão /hello/ corresponde ao texto literal "hello" em qualquer lugar de uma string. Mas /h.llo/ usa o metacaractere ponto para corresponder a "hello", "hallo", "hxllo" ou qualquer outra sequência de cinco caracteres começando com "h" e terminando com "llo".

Metacaracteres Essenciais

Aqui está uma tabela de referência dos metacaracteres regex mais fundamentais que você usará diariamente:

Escapando Caracteres Especiais

Quando você precisa corresponder a um metacaractere literal (como um ponto ou asterisco), você deve escapá-lo com uma barra invertida. Por exemplo, \. corresponde a um ponto literal, e \* corresponde a um asterisco literal.

Caracteres que precisam ser escapados incluem: . * + ? ^ $ { } [ ] ( ) | \

Classes de Caracteres e Quantificadores

Classes de caracteres permitem definir conjuntos de caracteres para corresponder, enquanto quantificadores especificam quantas vezes um padrão deve se repetir. Juntos, eles formam a espinha dorsal da maioria dos padrões regex.

Classes de Caracteres

Colchetes criam uma classe de caracteres que corresponde a qualquer caractere único dentro dos colchetes:

Quantificadores

Quantificadores especificam quantas vezes o elemento anterior deve corresponder. Eles são essenciais para corresponder padrões de comprimentos variados:

• * — Zero ou mais vezes (ganancioso)
• + — Uma ou mais vezes (ganancioso)
• ? — Zero ou uma vez (opcional)
• {3} — Exatamente 3 vezes
• {3,} — 3 ou mais vezes
• {3,6} — Entre 3 e 6 vezes
• *? — Zero ou mais vezes (preguiçoso/não-ganancioso)
• +? — Uma ou mais vezes (preguiçoso/não-ganancioso)
• ?? — Zero ou uma vez (preguiçoso)

Correspondência Gananciosa vs. Preguiçosa

Entender a diferença entre quantificadores gananciosos e preguiçosos é crucial para escrever padrões regex eficientes. Por padrão, quantificadores são gananciosos — eles correspondem ao máximo de texto possível enquanto ainda permitem que o padrão geral corresponda.

Considere este exemplo com a string "<div>content</div><div>more</div>":

• Ganancioso: <div>.*</div> corresponde à string inteira do primeiro <div> ao último </div>
• Preguiçoso: <div>.*?</div> corresponde a cada par <div>...</div> separadamente

A versão preguiçosa adiciona um ? após o quantificador, dizendo ao motor regex para corresponder o mínimo possível enquanto ainda satisfaz o padrão.

Padrões Regex Comuns

Aqui estão padrões regex testados em batalha para tarefas comuns de validação e extração. Esses padrões são usados em aplicações de produção em todo o mundo.

Validação de E-mail

Um padrão prático de validação de e-mail que cobre a maioria dos casos do mundo real:

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Este padrão garante que o e-mail tenha uma parte local (antes de @), um nome de domínio e um domínio de nível superior válido. Note que validação perfeita de e-mail é impossível apenas com regex — o padrão oficial RFC 5322 é incrivelmente complexo. Para uso em produção, considere usar uma biblioteca dedicada de validação de e-mail.

Números de Telefone

Número de telefone dos EUA com código de país opcional e várias formatações:

^(\+1[-.\s]?)?(\(?\d{3}\)?[-.\s]?)?\d{3}[-.\s]?\d{4}$

Isso corresponde a formatos como:

• 555-123-4567
• (555) 123-4567
• +1 555 123 4567
• 5551234567

URLs

Corresponde URLs HTTP e HTTPS com prefixo www opcional:

^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$

Endereços IP

Validação de endereço IPv4:

^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

Isso garante que cada octeto esteja entre 0 e 255.

Datas

Formato de data ISO 8601 (AAAA-MM-DD):

^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$

Formato de data dos EUA (MM/DD/AAAA):

^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/\d{4}$

Números de Cartão de Crédito

Validação básica de cartão de crédito (remove espaços e traços):

^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12})$

Este padrão valida cartões Visa, MasterCard, American Express e Discover. Sempre use o algoritmo de Luhn para validação real.

Senhas

Senha forte exigindo pelo menos 8 caracteres, uma maiúscula, uma minúscula, um dígito e um caractere especial:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$

Isso usa asserções lookahead (cobertas na próxima seção) para garantir que todos os requisitos sejam atendidos.

Âncoras, Grupos e Lookaheads

Esses recursos avançados dão a você controle preciso sobre onde as correspondências ocorrem e como os padrões são capturados.

Âncoras

Âncoras não correspondem a caracteres — elas correspondem a posições na string:

• ^ — Início da string (ou linha no modo multilinha)
• $ — Fim da string (ou linha no modo multilinha)
• \b — Limite de palavra (entre \w e \W)
• \B — Não-limite de palavra
• \A — Início da string (sempre, mesmo no modo multilinha)
• \Z — Fim da string (sempre, mesmo no modo multilinha)

Exemplo: \bcat\b corresponde a "cat" como uma palavra inteira, mas não o "cat" em "category" ou "concatenate".

Grupos de Captura

Parênteses criam grupos de captura que extraem substrings correspondentes:

^(\d{3})-(\d{3})-(\d{4})$

Este padrão corresponde a um número de telefone e captura o código de área, prefixo e número de linha separadamente. Você pode referenciar essas capturas em strings de substituição ou extraí-las programaticamente.

Grupos Não-Capturantes

Use (?:...) quando você precisa de agrupamento mas não quer capturar a correspondência:

(?:https?|ftp)://[^\s]+

Isso corresponde a URLs começando com http, https ou ftp sem criar um grupo de captura para o protocolo.

Grupos de Captura Nomeados

Grupos nomeados tornam seu regex mais legível e sustentável:

(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})

Você pode referenciar estes por nome em vez de por número, tornando seu código mais claro.

Asserções Lookahead

Lookaheads verificam se um padrão existe à frente sem consumir caracteres:

• (?=...) — Lookahead positivo (deve ser seguido por)
• (?!...) — Lookahead negativo (não deve ser seguido por)

Exemplo: \d+(?= dollars) corresponde a números seguidos por " dollars" mas não inclui " dollars" na correspondência.

Asserções Lookbehind

Lookbehinds verificam o que vem antes da posição atual:

• (?<=...) — Lookbehind positivo (deve ser precedido por)
• (?<!...) — Lookbehind negativo (não deve ser precedido por)

Exemplo: (?<=\$)\d+ corresponde a números precedidos por um sinal de dólar mas não inclui o $ na correspondência.

Note que JavaScript só ganhou suporte a lookbehind no ES2018, então verifique a compatibilidade se você está suportando navegadores mais antigos.

Regex em JavaScript

JavaScript fornece suporte robusto a regex através do objeto RegExp e métodos de string. Aqui está como usar regex efetivamente em aplicações JavaScript.

Criando Padrões Regex

Você pode criar padrões regex de duas maneiras:

// Notação literal (preferida para padrões estáticos)
const pattern1 = /\d{3}-\d{3}-\d{4}/;

// Construtor (útil para padrões dinâmicos)
const pattern2 = new RegExp('\\d{3}-\\d{3}-\\d{4}');

Note as barras invertidas duplas no construtor — você precisa escapar barras invertidas em strings.

Flags de Regex

JavaScript suporta várias flags que modificam o comportamento do regex: