Guia Completo de Regex: Referência Rápida de Expressões Regulares

O que é Regex?

Expressões regulares (regex ou regexp) são sequências de caracteres que definem padrões de busca. São uma das ferramentas mais poderosas para processamento de texto, correspondência de padrões e extração de dados.

Por que Usar Expressões Regulares?

Regex é essencial para:

• Validação de formulários (email, telefones, senhas)
• Extração de dados (análise de logs, scraping de páginas web)
• Processamento de texto (localizar e substituir, formatação)
• Refatoração de código (renomear variáveis, atualizar sintaxe)
• Sanitização de entradas (segurança, prevenção de ataques de injeção)

Como Ler Este Guia

Este guia está organizado em seções progressivas:

1. Fundamentos - Sintaxe básica e padrões
2. Recursos Avançados - Lookarounds, grupos nomeados, Unicode
3. Específico por Linguagem - Exemplos em Python, JavaScript, PHP, C#, Java, Go, Ruby
4. Regex no VS Code - Transformações find/replace com mais de 20 exemplos
5. Padrões Comuns - Padrões prontos para copiar: emails, URLs, datas, etc.
6. Casos de Uso Práticos - Aplicações do mundo real
7. Solução de Problemas - Erros comuns e dicas de desempenho

Cada seção inclui:

• Explicações claras
• Exemplos visuais
• Trechos de código para copiar
• Dicas profissionais e armadilhas

Caracteres Literais

O regex mais simples é uma sequência literal de caracteres:

abc

Corresponde a: "abc" em "The abc sequence"

Sensibilidade a Maiúsculas/Minúsculas

Por padrão, regex é sensível a maiúsculas:

• Hello corresponde a "Hello" mas NÃO a "hello"
• Use a flag i para correspondência insensível: /hello/i

---

Caracteres Especiais (Metacaracteres)

Estes 12 caracteres têm significado especial em regex e devem ser escapados com \ para corresponder literalmente:

. ^ $ * + ? { } [ ] \ | ( )

Exemplos:

• \. corresponde a um ponto literal
• \$ corresponde a um cifrão
• \( corresponde a um parêntese literal

Caractere	Escape	Exemplo	Corresponde
. (ponto)	\.	3\.14	"3.14"
$ (cifrão)	\$	\$100	"$100"
* (asterisco)	\*	a\*b	"a*b"

---

Classes de Caracteres

Classes de Caracteres Predefinidas

Padrão	Descrição	Equivalente	Exemplo	Corresponde
\d	Qualquer dígito	[0-9]	\d\d	"42"
\D	Qualquer não-dígito	[^0-9]	\D+	"abc"
\w	Caractere de palavra	[a-zA-Z0-9_]	\w+	"hello_123"
\W	Não-palavra	[^a-zA-Z0-9_]	\W	"@", "#"
\s	Espaço em branco	[ \t\n\r\f\v]	\s+	" " (espaços)
\S	Não-espaço	[^ \t\n\r\f\v]	\S+	"hello"
.	Qualquer caractere exceto nova linha	-	a.c	"abc", "a1c"

Dica Profissional: \w NÃO inclui letras Unicode por padrão. Use \p{L} para suporte Unicode (JavaScript/Python).

Classes de Caracteres Customizadas

Padrão	Descrição	Exemplo	Corresponde
[abc]	Corresponde qualquer de a, b ou c	[aeiou]	Vogais: "a", "e", "i", "o", "u"
[^abc]	Corresponde qualquer exceto a, b ou c	[^0-9]	Não-dígitos
[a-z]	Faixa: letras minúsculas	[a-z]+	"hello"
[A-Z]	Faixa: letras maiúsculas	[A-Z]+	"HELLO"
[0-9]	Faixa: dígitos	[0-9]{4}	"2025"
[a-zA-Z]	Combinado: todas as letras	[a-zA-Z0-9]	Alfanumérico

Exemplos:

[aeiou]       → Corresponde qualquer vogal
[^aeiou]      → Corresponde qualquer consoante (não vogal)
[a-z0-9]      → Corresponde letras minúsculas e dígitos
[a-zA-Z0-9_]  → Igual a \w (caracteres de palavra)

---

Quantificadores

Quantificadores especificam quantas vezes um padrão deve corresponder.

Quantificadores Básicos

Padrão	Descrição	Exemplo	Corresponde
*	0 ou mais	ab*c	"ac", "abc", "abbc", "abbbc"
+	1 ou mais	ab+c	"abc", "abbc" (NÃO "ac")
?	0 ou 1 (opcional)	colou?r	"color", "colour"
{n}	Exatamente n vezes	\d{4}	"2025" (exatamente 4 dígitos)
{n,}	n ou mais vezes	\d{2,}	"42", "123", "9999"
{n,m}	Entre n e m vezes	\d{2,4}	"42", "123", "2025"

Quantificadores Gulosos vs. Preguiçosos

Guloso (padrão): Corresponde o máximo possível

<.*>      → Corresponde: "<div>Olá</div>" (string inteira)

Preguiçoso (não-guloso): Corresponde o mínimo possível (adicione ? após o quantificador)

<.*?>     → Corresponde: "<div>" e "</div>" separadamente

Guloso	Preguiçoso	Descrição
*	*?	0 ou mais (preguiçoso)
+	+?	1 ou mais (preguiçoso)
?	??	0 ou 1 (preguiçoso)
{n,m}	{n,m}?	Entre n e m (preguiçoso)

Exemplo:

Texto: "Olá" e "Mundo"

• ".*" corresponde: "Olá" e "Mundo" (guloso)
• ".*?" corresponde: "Olá" e "Mundo" separadamente (preguiçoso)

---

Âncoras e Limites

Âncoras correspondem a posições, não caracteres.

Padrão	Descrição	Exemplo	Corresponde
^	Início de string/linha	^Olá	"Olá Mundo" (no início)
$	Fim de string/linha	Mundo$	"Olá Mundo" (no fim)
\b	Limite de palavra	\bgato\b	"gato" em "O gato sentou" (NÃO "gatoParágrafo")
\B	Não-limite de palavra	\Bgato	"gatoParágrafo" (gato NÃO no limite)
\A	Início de string (não linha)	\AOlá	Só corresponde se "Olá" está no início absoluto
\z	Fim de string (não linha)	Mundo\z	Só corresponde se "Mundo" está no fim absoluto
\Z	Fim de string (antes da nova linha final)	Mundo\Z	Corresponde "Mundo" ou "Mundo\n"

Exemplos:

^gato$        → Corresponde: "gato" (linha inteira é "gato")
\bgato\b      → Corresponde: "gato" em "o gato sentou" (palavra inteira)
\Bgato        → Corresponde: "gato" em "gatoParágrafo" (NÃO no limite)

Modo Multilinha (flag m):

• Sem m: ^ e $ correspondem início/fim da string inteira
• Com m: ^ e $ correspondem início/fim de cada linha

---

Grupos e Alternância

Grupos de Captura

Grupos de captura (...) lembram o texto correspondido:

(\d+)-(\d+)   → Corresponde: "123-456"
                Grupo 1: "123"
                Grupo 2: "456"

Retroreferências (reutilizar grupos capturados):

(\w)\1        → Corresponde: "aa", "bb", "cc" (caractere repetido)
(\w+) \1      → Corresponde: "olá olá" (palavra repetida)

Grupos Não-Capturadores

Use (?:...) quando precisar de agrupamento mas não precisa capturar:

(?:https?://)  → Agrupa "http://" ou "https://" sem capturar

Por que usar não-capturadores?

• Desempenho mais rápido (sem overhead de memória)
• Retroreferências mais limpas (grupos numerados só contam grupos de captura)

Alternância (OU)

Use | para "corresponde isto OU aquilo":

gato|cachorro  → Corresponde: "gato" ou "cachorro"
cin(za|zenta)  → Corresponde: "cinza" ou "cinzenta"

Exemplos:

(Sr|Sra|Dr)\.?   → Corresponde: "Sr.", "Sra.", "Dr."
https?://        → Corresponde: "http://" ou "https://"

Asserções Lookaround

Lookarounds são asserções de largura zero que correspondem a uma posição (como âncoras) mas com condições.

Lookahead Positivo (?=...)

Corresponde se o padrão à frente corresponder (mas não o consome):

\d(?=px)      → Corresponde: "10" em "10px" (NÃO a parte "px")

Caso de uso: Validação de senha

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

Detalhamento:

• (?=.*[A-Z]) - Deve conter maiúscula
• (?=.*[a-z]) - Deve conter minúscula
• (?=.*\d) - Deve conter dígito
• (?=.*[@$!%*?&]) - Deve conter caractere especial
• .{8,} - Pelo menos 8 caracteres

Lookahead Negativo (?!...)

Corresponde se o padrão à frente NÃO corresponder:

\d(?!px)      → Corresponde: "10" em "10em" (NÃO "10px")

Caso de uso: Excluir certas palavras

\b(?!teste)\w+  → Corresponde palavras que NÃO começam com "teste"

Lookbehind Positivo (?<=...)

Corresponde se o padrão atrás corresponder:

(?<=\$)\d+    → Corresponde: "100" em "$100" (NÃO a parte "$")

Caso de uso: Extrair preços

(?<=Preço: \$)\d+\.\d{2}  → Corresponde: "29,99" em "Preço: $29,99"

Lookbehind Negativo (?<!...)

Corresponde se o padrão atrás NÃO corresponder:

(?<!\$)\d+    → Corresponde: "100" mas NÃO em "$100"

Tabela Resumo:

Tipo	Sintaxe	Descrição	Exemplo
Lookahead Positivo	(?=...)	Corresponde se seguido por...	q(?=u) corresponde "q" em "queen"
Lookahead Negativo	(?!...)	Corresponde se NÃO seguido por...	q(?!u) corresponde "q" em "iraque"
Lookbehind Positivo	(?<=...)	Corresponde se precedido por...	(?<=\$)\d+ corresponde "10" em "$10"
Lookbehind Negativo	(?<!...)	Corresponde se NÃO precedido por...	(?<!\$)\d+ corresponde "10" em "10"

---

Grupos de Captura Nomeados

Grupos nomeados (?<nome>...) tornam regex mais legível:

JavaScript:

const dateRegex = /(?<ano>\d{4})-(?<mes>\d{2})-(?<dia>\d{2})/;
const match = '2025-01-17'.match(dateRegex);

console.log(match.groups.ano);  // "2025"
console.log(match.groups.mes);  // "01"
console.log(match.groups.dia);  // "17"

Python:

import re

pattern = r'(?P<ano>\d{4})-(?P<mes>\d{2})-(?P<dia>\d{2})'
match = re.search(pattern, '2025-01-17')

print(match.group('ano'))   # "2025"
print(match.group('mes'))   # "01"
print(match.group('dia'))   # "17"

C#:

var pattern = @"(?<ano>\d{4})-(?<mes>\d{2})-(?<dia>\d{2})";
var match = Regex.Match("2025-01-17", pattern);

Console.WriteLine(match.Groups["ano"].Value);  // "2025"

---

Grupos Atômicos e Quantificadores Possessivos

Grupos Atômicos (?>...)

Uma vez correspondido, o grupo não retrocede. Previne retrocesso catastrófico:

(?>\d+)bar    → Corresponde: "123bar" (rápido)

Sem grupo atômico:

\d+bar        → Tenta: "123bar", "12bar", "1bar" (lento em falha)

Quantificadores Possessivos

Guloso	Possessivo	Descrição
*	*+	0 ou mais (sem retrocesso)
+	++	1 ou mais (sem retrocesso)
?	?+	0 ou 1 (sem retrocesso)

Caso de uso: Prevenir retrocesso catastrófico em padrões complexos.

---

Suporte Unicode

Engines modernas de regex suportam categorias e scripts Unicode.

Categorias Unicode \p{...}

JavaScript (ES2018+):

const letras = /\p{L}+/u;      // Qualquer letra (qualquer idioma)
const numeros = /\p{N}+/u;     // Qualquer número
const moeda = /\p{Sc}/u;       // Símbolos de moeda

Python:

import regex  # Nota: requer módulo 'regex', não 're'

letras = regex.compile(r'\p{L}+')

Categorias Unicode Comuns:

Categoria	Descrição	Exemplo
\p{L}	Letra	"a", "字", "א"
\p{N}	Número	"1", "①", "一"
\p{S}	Símbolo	"$", "©", "♥"
\p{Sc}	Símbolo de moeda	"$", "€", "¥"
\p{P}	Pontuação	".", "!", "?"
\p{Z}	Separador	Espaço, tab

Scripts Unicode:

/\p{Script=Greek}/u     → Corresponde letras gregas: "α", "β", "γ"
/\p{Script=Cyrillic}/u  → Corresponde cirílico: "а", "б", "в"
/\p{Script=Han}/u       → Corresponde caracteres chineses

Negação:

/\P{L}+/u   → Corresponde qualquer coisa que NÃO seja letra

---

Modificadores e Flags

Flags alteram como padrões regex são interpretados.

Flag	Nome	Descrição	Exemplo
i	Insensível	Ignora maiúsculas	/olá/i corresponde "Olá"
g	Global	Encontra todas correspondências	/gato/g encontra todos "gato"
m	Multilinha	^ e $ correspondem início/fim de linha	/^olá/m
s	Dotall	. corresponde novas linhas também	/a.b/s corresponde "a\nb"
u	Unicode	Habilita recursos Unicode	/\p{L}+/u
x	Estendido	Ignora espaços (free-spacing)	Permite comentários
y	Sticky	Corresponde em posição exata	Só JavaScript

Exemplos:

Insensível (i):

/olá/i.test('OLÁ')   // true

Global (g):

'gato cão gato'.match(/gato/g)   // ["gato", "gato"]

Multilinha (m):

const texto = 'Linha 1\nLinha 2';
/^Linha 2/m.test(texto)   // true (sem 'm': false)

Dotall (s):

/a.b/s.test('a\nb')   // true (sem 's': false)

Modificadores Inline

Aplicar flags a parte do padrão:

(?i)olá        → "olá" insensível
(?-i)MUNDO     → "MUNDO" sensível
(?i:olá)       → Só "olá" é insensível

---

Padrões Condicionais

Sintaxe: (?(condição)verdadeiro|falso)

Exemplo: Corresponder strings com ou sem aspas

("|')?[^"'\r\n]*(?(1)\1)

Detalhamento:

• ("|')? - Opcionalmente captura aspas de abertura
• [^"'\r\n]* - Corresponde conteúdo
• (?(1)\1) - Se grupo 1 correspondeu (aspas de abertura), corresponde aspas de fechamento iguais

Corresponde:

• "olá" ✅
• 'mundo' ✅
• teste ✅ (sem aspas)
• "misto' ❌ (aspas incompatíveis)

---

Comentários em Regex

Comentários Inline (?# comentário)

\d{3}(?# código de área)-\d{3}(?# prefixo)-\d{4}(?# número de linha)

Modo Free-Spacing (flag x)

Ignora espaços e permite comentários:

(?x)
  \d{3}     # código de área
  -         # separador
  \d{3}     # prefixo
  -         # separador
  \d{4}     # número de linha

Muito mais legível para padrões complexos!

Esta seção será preenchida com exemplos completos em Python, JavaScript, PHP, C#, Java, Go e Ruby em breve.

Seção em breve com 28 exemplos práticos de transformações no VS Code.

Esta seção fornece mais de 25 padrões regex prontos para uso.

Validação de Email

^[\w.-]+@[\w.-]+\.[a-z]{2,}$

Números de Telefone (BR)

^(\+?55)?\s?\(?([0-9]{2})\)?\s?([0-9]{4,5})-?([0-9]{4})$

Datas (ISO 8601)

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

URLs

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

Endereços IPv4

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

Cores Hexadecimais

^#?([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$

Senha Forte

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

Nome de Usuário (3-16 caracteres)

^[a-zA-Z0-9_-]{3,16}$

UUID v4

^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$

E mais de 15 padrões com documentação completa!

Aplicações de regex do mundo real em desenvolvimento.

Validação de Formulários

const validadores = {
  email: /^[\w.-]+@[\w.-]+\.[a-z]{2,}$/i,
  telefone: /^\(?\d{2}\)?[-.\s]?\d{4,5}[-.\s]?\d{4}$/
};

Extração de Dados

Extrair emails do texto:

import re
emails = re.findall(r'[\w.-]+@[\w.-]+\.[a-z]{2,}', texto)

Análise de Logs

padrao = r'(?P<ip>[\d.]+).+(?P<status>\d{3})'

Refatoração de Código

Converter chamadas antigas de API no VS Code:

Localizar: apiClient\.get\('([^']+)'\)
Substituir: fetch('$1').then(r => r.json())

Erros Comuns

1. Esquecer de Escapar Caracteres Especiais

❌ Errado: arquivo.txt
✅ Correto: arquivo\.txt

2. Guloso vs Preguiçoso

❌ Guloso: <.*> corresponde todo <div>texto</div>
✅ Preguiçoso: <.*?> corresponde <div> e </div> separadamente

3. Não Usar Âncoras

❌ /\d{3}/ corresponde "123" em "abc123def"
✅ /^\d{3}$/ só corresponde exatamente "123"

Dicas de Desempenho

1. Use classes de caracteres específicas em vez de .
2. Ancore padrões quando possível
3. Evite quantificadores aninhados (retrocesso catastrófico)
4. Use grupos atômicos para desempenho
5. Compile padrões para reutilização

Depuração

1. Teste em regex101.com
2. Use modo verbose com comentários
3. Divida padrões complexos em partes
4. Teste casos extremos

Ferramentas Online

Testadores de Regex

• regex101.com - Melhor testador com explicações
• regexr.com - Construtor visual de regex
• regexpal.com - Simples e rápido

Visualizadores

• debuggex.com - Diagramas ferroviários
• regexper.com - Ferramenta visual

Recursos de Aprendizado

• regexone.com - Lições interativas
• regexlearn.com - Guia passo a passo
• regular-expressions.info - Documentação

Extensões IDE

• Regex Previewer (VS Code)
• Regex Tester (VS Code)

Classes de Caracteres

Padrão	Corresponde
\d	Dígito [0-9]
\w	Palavra [a-zA-Z0-9_]
\s	Espaço em branco
.	Qualquer caractere

Quantificadores

Padrão	Significado
*	0 ou mais
+	1 ou mais
?	0 ou 1
{n}	Exatamente n

Âncoras

Padrão	Significado
^	Início de linha
$	Fim de linha
\b	Limite de palavra

Flags

Flag	Significado
i	Insensível
g	Global
m	Multilinha
s	Dotall

Questões Gerais

P: Qual é a diferença entre quantificadores gulosos e preguiçosos?

R: Gulosos correspondem o máximo possível. Preguiçosos (*?, +?) correspondem o mínimo possível.

P: Como corresponder um ponto literal?

R: Escape com barra invertida: \.

P: O que é retrocesso catastrófico?

R: Quando regex tenta muitas combinações, causando lentidão. Evite quantificadores aninhados como (a+)+.

P: Regex pode validar email perfeitamente?

R: Não. Use regex para formato básico, depois verifique via email.

P: Como corresponder em múltiplas linhas?

R: Use a flag s, ou use [\s\S]* em vez de .*.

Específico do VS Code

P: Como substituir com maiúscula no VS Code?

R: Use \u (maiúscula próximo), \U (maiúscula todos).

P: Posso usar regex na busca de arquivos do VS Code?

R: Sim! Pressione Ctrl+Shift+F e habilite regex (Alt+R).

Extensão Chrome Regex Data Extractor

Nosso Regex Data Extractor ajuda você a extrair dados de páginas web usando padrões deste guia.

Recursos Principais

• Biblioteca de Padrões: Padrões pré-construídos
• Teste ao Vivo: Teste regex em qualquer página web
• Exportação Multi-Formato: CSV, JSON, Excel, PDF
• Extração em Lote: Extrair de múltiplas páginas

Exemplo: Extrair Emails

1. Instale o Regex Data Extractor
2. Navegue para qualquer página web
3. Clique no ícone da extensão
4. Digite o padrão: [\w.-]+@[\w.-]+\.[a-z]{2,}
5. Clique em "Extrair"
6. Exporte para CSV/JSON

Exemplo: Extrair Preços

Padrão: R\$\s?([0-9]{1,3}(?:\.[0-9]{3})*,?[0-9]{2})
Captura: R$ 1.234,56, R$ 99,99

Dicas Profissionais

• Salve padrões usados frequentemente
• Use grupos nomeados para dados estruturados
• Teste padrões primeiro
• Exporte para análise de dados

Obter Regex Data Extractor →