Cheatsheet de Expressoes Regulares: Colecao de Padroes Mais Usados

Por Que Aprender Expressoes Regulares?

Expressoes regulares (Regular Expression, Regex) sao como um canivete suico para desenvolvedores. No inicio parecem dificeis, mas uma vez dominadas, voce pode substituir dezenas de linhas de codigo de processamento de strings por uma unica linha. Validacao de e-mail, extracao de telefone, parsing de logs, substituicao de texto - as expressoes regulares brilham em praticamente qualquer tarefa que envolva strings.

A razao pela qual muitos desenvolvedores temem expressoes regulares e que a sintaxe nao e compreensivel a primeira vista. Codigo como /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/ parece uma mensagem criptografada. Porem, entendendo a sintaxe basica, esse padrao pode ser lido logicamente. Neste artigo, primeiro explicaremos a sintaxe fundamental das expressoes regulares e depois decomporemos um por um os padroes frequentemente usados na pratica.

Entendendo a Sintaxe Basica Sistematicamente

A sintaxe das expressoes regulares pode ser dividida em quatro categorias principais: metacaracteres, quantificadores, grupos e ancoras.

Metacaracteres: Caracteres com Significado Especial

Metacaracteres representam conjuntos especificos de caracteres ou condicoes.

Quantificadores: Expressando Repeticao

Quantificadores especificam quantas vezes o elemento anterior se repete.

Ancoras e Limites

Ancoras correspondem a posicoes, nao caracteres.

Grupos e Captura

Usando parenteses, voce pode agrupar padroes e capturar partes correspondentes.

const dateStr = '2025-12-25';
const regex = /(\d{4})-(\d{2})-(\d{2})/;

const match = dateStr.match(regex);
console.log(match[0]); // '2025-12-25' (correspondencia completa)
console.log(match[1]); // '2025' (primeiro grupo - ano)
console.log(match[2]); // '12'   (segundo grupo - mes)
console.log(match[3]); // '25'   (terceiro grupo - dia)

Colecao de Padroes Praticos: Decompondo um por um

1. Validacao de E-mail

O padrao de e-mail e um exemplo classico de expressoes regulares. Vamos decompor passo a passo.

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

Decomposicao do padrao:

• ^ - Inicio da string
• [a-zA-Z0-9._%+-]+ - Parte local (antes do @): letras, numeros, ponto, sublinhado, etc., 1 ou mais
• @ - Simbolo @ (literal)
• [a-zA-Z0-9.-]+ - Nome do dominio: letras, numeros, ponto, hifen, 1 ou mais
• \. - Ponto (precisa de escape)
• [a-zA-Z]{2,} - Dominio de nivel superior: 2 ou mais letras (com, br, museum, etc.)
• $ - Fim da string

Tratamento de casos limite: Esse padrao valida a maioria dos e-mails comuns, mas nao segue completamente o padrao RFC 5322. Por exemplo, e-mails com aspas como "user name"@example.com nao correspondem. Na pratica, apos validar o formato, confirmar enviando um e-mail real e o mais seguro.

2. Verificacao de Forca de Senha

Para validar regras complexas de senha com expressoes regulares, usamos lookahead.

// Minimo 8 caracteres, maiusculas, minusculas, numeros, caracteres especiais
const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;

Decomposicao do padrao:

• (?=.*[a-z]) - Deve conter pelo menos 1 minuscula (lookahead)
• (?=.*[A-Z]) - Deve conter pelo menos 1 maiuscula
• (?=.*\d) - Deve conter pelo menos 1 numero
• (?=.*[@$!%*?&]) - Deve conter pelo menos 1 caractere especial
• [A-Za-z\d@$!%*?&]{8,} - 8 ou mais caracteres permitidos

O lookahead (?=...) verifica se o padrao existe, mas nao consome caracteres. Isso permite verificar varias condicoes simultaneamente.

3. Validacao de Telefone

Padrao para validar numeros de celular brasileiros.

const phoneRegex = /^\(?[1-9]{2}\)?\s?9?\d{4}-?\d{4}$/;

Decomposicao do padrao:

• \(?[1-9]{2}\)? - DDD com ou sem parenteses
• \s? - Espaco opcional
• 9? - Digito 9 opcional (celular)
• \d{4} - 4 digitos
• -? - Hifen opcional
• \d{4} - Ultimos 4 digitos

phoneRegex.test('(11) 91234-5678');  // true
phoneRegex.test('11912345678');       // true
phoneRegex.test('11 91234 5678');     // false (espacos no meio)

4. Validacao de Nome

Para validar nomes em portugues, podemos usar o intervalo Unicode.

const nameRegex = /^[A-Za-zÀ-ÖØ-öø-ÿ\s]{2,50}$/;

nameRegex.test('Joao Silva');   // true
nameRegex.test('Maria');        // true
nameRegex.test('123');          // false (numeros)

[A-Za-zÀ-ÖØ-öø-ÿ] inclui letras latinas e caracteres acentuados.

5. Validacao de URL

Padroes de URL podem ser complexos porque precisam suportar varios formatos.

const urlRegex = /^(https?:\/\/)?(www\.)?[\w-]+(\.[a-z]{2,})+([\/\w.-]*)*\/?$/i;

Decomposicao do padrao:

• (https?:\/\/)? - Protocolo (http:// ou https://) opcional
• (www\.)? - www. opcional
• [\w-]+ - Nome do dominio
• (\.[a-z]{2,})+ - TLD como .com, .com.br, etc. (1 ou mais)
• ([\/\w.-]*)* - Caminho (opcional)
• \/?$ - Barra final opcional
• Flag i - Ignora maiusculas/minusculas

6. Validacao de Endereco IPv4

Cada octeto de um endereco IPv4 deve estar no intervalo 0-255. Expressando com regex:

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

Decomposicao do padrao (correspondendo 0-255):

• 25[0-5] - 250-255
• 2[0-4]\d - 200-249
• [01]?\d\d? - 0-199

ipv4Regex.test('192.168.1.1');     // true
ipv4Regex.test('256.1.1.1');       // false (256 fora do intervalo)
ipv4Regex.test('192.168.001.001'); // true (zeros a esquerda permitidos)

Otimizacao de Performance

A maior causa de lentidao em expressoes regulares e o backtracking. Quando quantificadores gananciosos sao usados excessivamente, o desempenho pode degradar drasticamente.

Quantificadores Gananciosos vs Preguicosos

// Ganancioso (Greedy) - corresponde o maximo possivel
'<div>content</div><div>more</div>'.match(/<div>.*<\/div>/);
// Resultado: '<div>content</div><div>more</div>' (tudo)

// Preguicoso (Lazy) - corresponde o minimo
'<div>content</div><div>more</div>'.match(/<div>.*?<\/div>/);
// Resultado: '<div>content</div>' (apenas o primeiro)

Adicionar ? apos o quantificador o torna preguicoso: *?, +?, ??

Dicas de Otimizacao

1. Use ancoras: Limite claramente o escopo com ^ e $
2. Use classes de caracteres especificas: Em vez de .*, use [^<]* para limitar
3. Use grupos nao-capturantes: Se nao precisa capturar, use (?:...)

// Grupo de captura - mais lento (armazena resultado)
/(abc)+/

// Grupo nao-capturante - mais rapido (nao armazena)
/(?:abc)+/

Diferencas entre Linguagens

Usando Expressoes Regulares em JavaScript

const str = 'Entre em contato pelo support@example.com ou sales@example.com';
const regex = /[\w.-]+@[\w.-]+\.\w+/g;

// Encontrar todas as correspondencias
const emails = str.match(regex);
// ['support@example.com', 'sales@example.com']

// Substituicao
const masked = str.replace(regex, '[e-mail oculto]');
// 'Entre em contato pelo [e-mail oculto] ou [e-mail oculto]'

// Divisao
'a,b;c:d'.split(/[,;:]/);
// ['a', 'b', 'c', 'd']

// Correspondencia iterativa (matchAll)
for (const match of str.matchAll(/(\w+)@(\w+\.\w+)/g)) {
  console.log(`Local: ${match[1]}, Dominio: ${match[2]}`);
}

Usando o Regex Tester do Toolypet

O mais dificil ao escrever expressoes regulares e obter feedback imediato. O Regex Tester do Toolypet resolve esse problema:

• Veja os resultados de correspondencia em tempo real inserindo o padrao e a string de teste
• Visualizacao do que cada grupo de captura correspondeu
• Teste facilmente varias flags (g, i, m) com toggles
• Modelos de padroes frequentemente usados disponiveis

Ao debugar expressoes regulares complexas, validar primeiro no Toolypet e muito mais eficiente do que testar diretamente no codigo.