Expressões Regulares (RegEx) para Iniciantes

Expressões regulares parecem complicadas, mas este guia vai desmistificar e ensinar você a criar padrões úteis rapidamente.

O Que São Expressões Regulares?

RegEx (ou Regex) são padrões de busca para encontrar e manipular texto. Pense nelas como um "ctrl+F turbinado".

Exemplo Simples

Texto: "Meu email é joao@email.com"
Regex: \w+@\w+\.\w+
Match: joao@email.com

Sintaxe Básica

Caracteres Literais

Correspondem a si mesmos:

gato    → encontra "gato"
123     → encontra "123"

Metacaracteres Especiais

.    → qualquer caractere (exceto nova linha)
^    → início da string
$    → fim da string
*    → 0 ou mais repetições
+    → 1 ou mais repetições
?    → 0 ou 1 repetição
[]   → conjunto de caracteres
()   → grupo de captura
|    → ou (alternativa)
\    → escape (torna literal o próximo caractere)

Classes de Caracteres

Pré-definidas

\d   → dígito [0-9]
\w   → palavra [a-zA-Z0-9_]
\s   → espaço em branco [ \t\n\r]
\D   → não-dígito
\W   → não-palavra
\S   → não-espaço
.    → qualquer caractere

Personalizadas

[abc]      → a, b ou c
[a-z]      → qualquer letra minúscula
[0-9]      → qualquer dígito
[^abc]     → qualquer coisa EXCETO a, b ou c
[a-zA-Z]   → qualquer letra

Quantificadores

a*       → 0 ou mais 'a'        ("", "a", "aa", "aaa"...)
a+       → 1 ou mais 'a'        ("a", "aa", "aaa"...)
a?       → 0 ou 1 'a'           ("", "a")
a{3}     → exatamente 3 'a'     ("aaa")
a{2,}    → 2 ou mais 'a'        ("aa", "aaa", "aaaa"...)
a{2,4}   → 2 a 4 'a'            ("aa", "aaa", "aaaa")

Âncoras

^inicio   → deve começar com "inicio"
fim$      → deve terminar com "fim"
^exato$   → deve ser exatamente "exato"
\bword\b  → palavra completa "word"

Grupos e Captura

Grupos de Captura

(abc)+           → captura "abc" repetido
(\d{3})-(\d{4}) → captura "123-4567" em 2 grupos

Grupos Não-Capturantes

(?:abc)+   → agrupa mas não captura

Alternativas

gato|cachorro   → "gato" OU "cachorro"
(Sr|Sra)\. → "Sr." OU "Sra."

Exemplos Práticos

1. Validar Email

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

Breakdown:

• ^[\w.-]+ → início, 1+ caracteres de palavra, ponto ou hífen
• @ → @ literal
• [\w.-]+ → 1+ caracteres de palavra, ponto ou hífen
• \. → ponto literal (escapado)
• \w{2,}$ → 2+ letras, fim

Matches:

• ✅ joao@email.com
• ✅ maria.silva@empresa.com.br
• ❌ @email.com
• ❌ joao@.com

2. Validar CPF (000.000.000-00)

^\d{3}\.\d{3}\.\d{3}-\d{2}$

Breakdown:

• ^\d{3}\. → início, 3 dígitos, ponto
• \d{3}\. → 3 dígitos, ponto
• \d{3}- → 3 dígitos, hífen
• \d{2}$ → 2 dígitos, fim

CPF sem formatação:

^\d{11}$

3. Telefone Brasileiro

^\(?\d{2}\)?\s?\d{4,5}-?\d{4}$

Matches:

• ✅ (11) 98765-4321
• ✅ 11 98765-4321
• ✅ 1198765-4321
• ✅ 11987654321

4. Validar Senha Forte

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

Requisitos:

• Mínimo 8 caracteres
• Pelo menos 1 minúscula
• Pelo menos 1 maiúscula
• Pelo menos 1 número
• Pelo menos 1 caractere especial

5. Extrair URLs

https?://[\w.-]+\.[a-z]{2,}(/[\w.-]*)*/?

Matches:

• ✅ https://exemplo.com
• ✅ http://site.com.br/pagina
• ✅ https://sub.dominio.org/path/to/page

6. Encontrar Hashtags

#\w+

Matches:

• ✅ #produtividade
• ✅ #regex2025

7. Validar Horário (HH:MM)

^([01]?\d|2[0-3]):[0-5]\d$

Matches:

• ✅ 09:30
• ✅ 23:59
• ❌ 25:00
• ❌ 12:60

8. Validar Data (DD/MM/AAAA)

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

Matches:

• ✅ 25/12/2024
• ✅ 01/01/2025
• ❌ 32/01/2024
• ❌ 15/13/2024

9. Remover Espaços Extras

\s+

Substituir por: Um espaço único

Antes: "Texto com espaços extras" Depois: "Texto com espaços extras"

10. Encontrar Números de Cartão de Crédito

\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}

Matches:

• ✅ 1234 5678 9012 3456
• ✅ 1234-5678-9012-3456
• ✅ 1234567890123456

Usando em Diferentes Linguagens

JavaScript

const regex = /^\d{3}\.\d{3}\.\d{3}-\d{2}$/;

// Test
regex.test("123.456.789-10");  // true

// Match
const email = "joao@email.com";
const match = email.match(/([\w.-]+)@([\w.-]+)/);
console.log(match[1]); // "joao"
console.log(match[2]); // "email.com"

// Replace
const texto = "Olá, mundo!";
const novo = texto.replace(/mundo/, "regex");
// "Olá, regex!"

// Global flag
const texto = "gato gato gato";
texto.replace(/gato/g, "cachorro");
// "cachorro cachorro cachorro"

Python

import re

# Match
pattern = r'^\d{3}\.\d{3}\.\d{3}-\d{2}$'
re.match(pattern, "123.456.789-10")  # Match object

# Search
texto = "Email: joao@email.com"
match = re.search(r'([\w.-]+)@([\w.-]+)', texto)
print(match.group(1))  # "joao"

# FindAll
texto = "gato cachorro gato"
re.findall(r'gato', texto)  # ['gato', 'gato']

# Substitute
re.sub(r'\s+', ' ', "Texto  com  espaços")
# "Texto com espaços"

PHP

// Match
$pattern = '/^\d{3}\.\d{3}\.\d{3}-\d{2}$/';
preg_match($pattern, "123.456.789-10");  // 1 (true)

// Match All
$texto = "gato cachorro gato";
preg_match_all('/gato/', $texto, $matches);
print_r($matches);

// Replace
$novo = preg_replace('/\s+/', ' ', "Texto  com  espaços");
// "Texto com espaços"

Flags (Modificadores)

i    → Case insensitive (ignora maiúsculas/minúsculas)
g    → Global (encontra todas as ocorrências)
m    → Multiline (^ e $ funcionam por linha)
s    → Dotall (. inclui nova linha)
u    → Unicode

Exemplos:

/gato/i     → encontra "gato", "Gato", "GATO"
/gato/g     → encontra todos os "gato"
/^inicio/m  → início de cada linha

Lookahead e Lookbehind

Positive Lookahead (?=...)

\d+(?= reais)  → números seguidos de " reais"

Match: "100" em "100 reais"

Negative Lookahead (?!...)

\d+(?! reais)  → números NÃO seguidos de " reais"

Positive Lookbehind (?<=...)

(?<=R\$ )\d+  → números precedidos de "R$ "

Match: "100" em "R$ 100"

Negative Lookbehind (?<!...)

(?<!R\$ )\d+  → números NÃO precedidos de "R$ "

Ferramentas para Praticar

1. Regex101 (https://regex101.com) - Melhor para aprender
2. RegExr (https://regexr.com) - Interface visual
3. RegexPal - Testes rápidos
4. Nossa ferramenta: Testador de Regex

Erros Comuns

1. Esquecer de Escapar Metacaracteres

❌ exemplo.com  → "exemplo" + qualquer char + "com"
✅ exemplo\.com → "exemplo.com"

2. Ganância (Greedy) vs Preguiça (Lazy)

❌ <.*>   → greedy, pega "<div>texto</div>"
✅ <.*?>  → lazy, pega "<div>"

3. Não Ancorar

❌ \d{11}       → encontra em qualquer parte
✅ ^\d{11}$     → string completa deve ser 11 dígitos

4. Esquecer a Flag Global

❌ texto.replace(/a/, 'b')   → substitui só o primeiro
✅ texto.replace(/a/g, 'b')  → substitui todos

Dicas de Performance

1. Seja específico: \d é mais rápido que [0-9]
2. Use âncoras: ^ e $ limitam a busca
3. Evite backtracking: Use quantificadores lazy quando possível
4. Compile regex: Em loops, compile uma vez e reutilize

Exercícios Práticos

Tente criar regex para:

1. ✍️ Validar placa de carro brasileiro (ABC-1234 ou ABC1D23)
2. ✍️ Extrair todos os números de um texto
3. ✍️ Validar código hexadecimal (#FFF ou #FFFFFF)
4. ✍️ Encontrar palavras com mais de 10 letras
5. ✍️ Validar IPv4 (0.0.0.0 a 255.255.255.255)

Respostas:

1. ^[A-Z]{3}-?\d{1}[A-Z0-9]\d{2}$
2. \d+
3. ^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$
4. \b\w{11,}\b
5. ^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$

Conclusão

Regex é uma habilidade poderosa que:

• ✅ Economiza horas de programação
• ✅ Valida dados com precisão
• ✅ Processa texto eficientemente
• ✅ É universal (funciona em quase todas as linguagens)

Próximos passos:

1. Pratique no Regex101
2. Use em projetos reais
3. Estude casos avançados (lookahead, backreferences)

Lembre-se: "Some people, when confronted with a problem, think 'I know, I'll use regular expressions.' Now they have two problems." - Mas se você aprender bem, terá uma solução! 😄