Folha de Referência de Expressões Regulares para Desenvolvedores

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

Introdução às Expressões Regulares

Expressões regulares (regex) são ferramentas poderosas de correspondência de padrões que todo desenvolvedor deveria dominar. Elas fornecem uma maneira concisa e declarativa de buscar, validar e manipular dados de texto sem escrever código verboso de manipulação de strings.

Seja construindo validação de formulários, analisando arquivos de log, extraindo dados de APIs ou limpando conjuntos de dados, regex oferece uma solução elegante. Um único padrão regex pode substituir dezenas de linhas de lógica condicional, tornando seu código mais sustentável e menos propenso a erros.

Linguagens de programação modernas como JavaScript, Python, Java, PHP e Ruby todas têm suporte integrado a regex. Uma vez que você aprende a sintaxe, pode aplicar essas habilidades em praticamente qualquer ambiente de desenvolvimento.

Sintaxe Básica e Elementos

Compreender os blocos fundamentais de regex é essencial antes de enfrentar padrões complexos. Esses elementos centrais formam a fundação de cada expressão regular que você escreverá.

Caracteres Literais

Os padrões regex mais simples correspondem a caracteres literais exatamente como aparecem. O padrão cat corresponde à string "cat" onde quer que ocorra em seu texto.

A maioria dos caracteres alfanuméricos são literais, mas certos caracteres especiais (chamados metacaracteres) têm significados especiais e devem ser escapados com uma barra invertida quando você quer correspondê-los literalmente.

Metacaracteres Essenciais

Escapando Caracteres Especiais

Quando você precisa corresponder metacaracteres literalmente, prefixe-os com uma barra invertida. Por exemplo, para corresponder a um ponto literal, use \. em vez de apenas .

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

// Corresponder a um ponto de interrogação literal
const pattern = /What\?/;
pattern.test("What?"); // true

// Corresponder a um valor em dólar
const price = /\$\d+\.\d{2}/;
price.test("$19.99"); // true

Classes de Caracteres e Quantificadores

Classes de caracteres permitem que você corresponda a qualquer caractere de um conjunto específico, enquanto quantificadores controlam quantas vezes um padrão deve se repetir. Juntos, eles formam a espinha dorsal da correspondência de padrões flexível.

Classes de Caracteres Predefinidas

Conjuntos de Caracteres Personalizados

Colchetes definem conjuntos de caracteres personalizados. O padrão [aeiou] corresponde a qualquer vogal única, enquanto [0-9a-fA-F] corresponde a qualquer dígito hexadecimal.

Use um acento circunflexo dentro dos colchetes para negar o conjunto: [^0-9] corresponde a qualquer caractere que NÃO seja um dígito.

// Corresponder a qualquer vogal
const vowels = /[aeiou]/gi;
"Hello World".match(vowels); // ["e", "o", "o"]

// Corresponder apenas consoantes
const consonants = /[^aeiou\s]/gi;
"Hello".match(consonants); // ["H", "l", "l"]

Quantificadores em Detalhe

Quantificadores especificam quantas vezes o elemento anterior deve corresponder. Eles são gananciosos por padrão, o que significa que correspondem ao máximo de texto possível.

• {n} - Exatamente n vezes: \d{4} corresponde exatamente 4 dígitos
• {n,} - Pelo menos n vezes: \d{3,} corresponde 3 ou mais dígitos
• {n,m} - Entre n e m vezes: \d{2,4} corresponde 2, 3 ou 4 dígitos
• * - Zero ou mais (equivalente a {0,})
• + - Um ou mais (equivalente a {1,})
• ? - Zero ou um (equivalente a {0,1})

Âncoras e Limites de Palavras

Âncoras não correspondem a caracteres—elas correspondem a posições na string. Elas são essenciais para correspondência de padrões precisa quando você precisa garantir que o texto apareça em locais específicos.

Âncoras de Posição

O acento circunflexo ^ corresponde ao início de uma string (ou linha no modo multilinha), enquanto o cifrão $ corresponde ao final. Estes são inestimáveis para validação onde a string inteira deve corresponder a um padrão.

// Validar que a string inteira são dígitos
const onlyDigits = /^\d+$/;
onlyDigits.test("12345"); // true
onlyDigits.test("123abc"); // false

// Corresponder linhas começando com "Error"
const errorLines = /^Error/gm;
const logs = "Info: Starting\nError: Failed\nError: Timeout";
logs.match(errorLines); // ["Error", "Error"]

Limites de Palavras

A âncora \b corresponde a limites de palavras—posições entre caracteres de palavra e não-palavra. É perfeita para corresponder palavras inteiras sem acidentalmente corresponder partes de palavras maiores.

A âncora \B corresponde a posições que NÃO são limites de palavras.

// Corresponder "cat" apenas como palavra inteira
const wholeCat = /\bcat\b/;
wholeCat.test("cat"); // true
wholeCat.test("cats"); // false
wholeCat.test("concatenate"); // false

// Corresponder "cat" dentro de palavras
const partialCat = /\Bcat\B/;
partialCat.test("concatenate"); // true
partialCat.test("cat"); // false

Limites de palavras são particularmente úteis para operações de busca e substituição onde você quer evitar correspondências parciais. Eles também são essenciais ao construir destacadores de sintaxe ou analisadores de código.

Grupos e Captura

Parênteses em regex servem múltiplos propósitos: eles agrupam partes de padrões juntas, capturam texto correspondido para uso posterior e habilitam retrorreferências dentro do próprio padrão.

Grupos de Captura

Parênteses criam grupos de captura numerados que armazenam o texto correspondido. Você pode referenciar essas capturas em strings de substituição ou extraí-las programaticamente.

// Extrair componentes de data
const datePattern = /(\d{4})-(\d{2})-(\d{2})/;
const match = "2026-03-31".match(datePattern);
// match[0]: "2026-03-31" (correspondência completa)
// match[1]: "2026" (ano)
// match[2]: "03" (mês)
// match[3]: "31" (dia)

// Reformatar datas usando capturas
const text = "Date: 2026-03-31";
const reformatted = text.replace(/(\d{4})-(\d{2})-(\d{2})/, "$2/$3/$1");
// Resultado: "Date: 03/31/2026"

Grupos Não-Capturantes

Use (?:...) para agrupar padrões sem criar uma captura. Isso melhora a performance e mantém sua numeração de captura limpa quando você só precisa de agrupamento para alternância ou quantificadores.

// Agrupar sem capturar
const protocol = /(?:https?|ftp):\/\//;
protocol.test("https://example.com"); // true

// Compare com captura (sobrecarga desnecessária)
const protocolCapture = /(https?|ftp):\/\//;
// Cria um grupo de captura extra que não precisamos

Grupos de Captura Nomeados

Motores regex modernos suportam capturas nomeadas usando sintaxe (?<name>...). Isso torna seus padrões autodocumentados e mais fáceis de manter.

// Capturas nomeadas para clareza
const emailPattern = /(?<user>[\w.]+)@(?<domain>[\w.]+)/;
const match = "[email protected]".match(emailPattern);
console.log(match.groups.user); // "john.doe"
console.log(match.groups.domain); // "example.com"

// Usar em substituições
const masked = "[email protected]".replace(
  /(?<user>[\w.]+)@(?<domain>[\w.]+)/,
  "***@$<domain>"
);
// Resultado: "***@example.com"

Retrorreferências

Referencie capturas anteriores dentro do mesmo padrão usando \1, \2, etc. Isso é poderoso para corresponder padrões repetidos ou espelhados.

// Corresponder palavras repetidas
const repeated = /\b(\w+)\s+\1\b/;
repeated.test("hello hello"); // true
repeated.test("hello world"); // false

// Corresponder tags HTML
const htmlTag = /<(\w+)>.*?<\/\1>/;
htmlTag.test("<div>content</div>"); // true
htmlTag.test("<div>content</span>"); // false

Flags e Modificadores de Regex

Flags modificam como o motor regex interpreta seu padrão. Elas são adicionadas após o delimitador de fechamento na maioria das linguagens (por exemplo, /pattern/flags em JavaScript).

Flags Comuns

• g (global) - Encontrar todas as correspondências em vez de parar após a primeira correspondência
• i (case-insensitive) - Ignorar maiúsculas/minúsculas ao corresponder letras
• m (multiline) - Fazer ^ e $ corresponderem limites de linha em vez de limites de string
• s (dotall) - Fazer . corresponder caracteres de nova linha
• u (unicode) - Habilitar suporte completo a Unicode
• y (sticky) - Corresponder apenas a partir da posição lastIndex

// Busca sem distinção de maiúsculas/minúsculas
const pattern = /hello/i;
pattern.test("HELLO"); // true
pattern.test("Hello"); // true

// Flag global para múltiplas correspondências
const digits = /\d+/g;
"Phone: 555-1234, Fax: 555-5678".match(digits);
// ["555", "1234", "555", "5678"]

// Modo multilinha
const headers = /^#.+$/gm;
const markdown = "# Title\nContent\n## Subtitle";
markdown.match(headers); // ["# Title", "## Subtitle"]

Padrões Comuns e Suas Aplicações

Vamos explorar padrões regex testados em batalha para tarefas comuns de desenvolvimento. Esses padrões foram refinados através de uso no mundo real e lidam com casos extremos que você pode não considerar inicialmente.

Validação de Email

Validação de email é notoriamente complexa devido às especificações RFC, mas este padrão prático lida com 99% dos endereços de email do mundo real:

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

// Emails válidos
emailPattern.test("[email protected]"); // true
emailPattern.test("[email protected]"); // true

// Emails inválidos
emailPattern.test("invalid@"); // false
emailPattern.test("@example.com"); // false
emailPattern.test("[email protected]"); // false

Para aplicações de produção, considere usar uma biblioteca dedicada de validação de email que lida com domínios internacionalizados e todos os casos extremos RFC. Você também pode usar nossa Ferramenta de Validação de Email para testar padrões de email interativamente.

Correspondência de URL

Corresponder e extrair URLs de texto com este padrão abrangente:

const urlPattern