Tutorial de Expressões Regulares: Um Guia Amigável para Iniciantes sobre Regex

· 12 min de leitura

Índice

O Que São Expressões Regulares e Por Que Aprendê-las?

Expressões regulares (comumente abreviadas como regex ou regexp) são ferramentas poderosas de correspondência de padrões que permitem pesquisar, validar, extrair e manipular texto usando sintaxe especializada. Pense nelas como uma linguagem de busca sofisticada que vai muito além de simples operações de "localizar e substituir".

Imagine que você precisa extrair todos os endereços de e-mail de um arquivo contendo milhares de linhas de dados de log, ou validar que o número de telefone de um usuário segue o formato correto. Usar métodos tradicionais de manipulação de strings resultaria em código verboso e difícil de manter. Expressões regulares podem realizar essas tarefas com um único padrão conciso.

Em sua essência, expressões regulares definem padrões de busca usando uma combinação de caracteres literais e metacaracteres especiais. Esses padrões podem corresponder a strings simples como "gato" ou estruturas complexas como endereços de e-mail, URLs ou números de cartão de crédito.

Por Que Você Deveria Aprender Expressões Regulares?

Aplicações do Mundo Real

Expressões regulares são usadas extensivamente em desenvolvimento de software e processamento de dados:

Dica profissional: Embora regex seja poderoso, nem sempre é a melhor ferramenta para cada trabalho. Para analisar dados estruturados complexos como HTML ou JSON, use analisadores dedicados. Regex funciona melhor para correspondência de padrões em texto simples.

Sintaxe Básica e Fundamentos

Expressões regulares consistem em dois tipos de caracteres: caracteres literais (que correspondem a si mesmos) e metacaracteres (que têm significados especiais). Vamos começar com os fundamentos.

Caracteres Literais

A regex mais simples é apenas texto simples. O padrão cat corresponderá à string exata "cat" no seu texto.

Texto: "The cat sat on the mat"
Regex: cat
Corresponde: "The cat sat on the mat"

Caracteres literais são sensíveis a maiúsculas e minúsculas por padrão, então cat não corresponderá a "Cat" ou "CAT" a menos que você use uma flag de insensibilidade a maiúsculas.

O Metacaractere Ponto (.)

O ponto . é um curinga que corresponde a qualquer caractere único, exceto caracteres de nova linha.

Texto: "cat", "cot", "cut", "c@t"
Regex: c.t
Corresponde: Todas as quatro strings

Para corresponder a um caractere de ponto literal, escape-o com uma barra invertida: \.

Texto: "file.txt"
Regex: file\.txt
Corresponde: "file.txt" (não "fileAtxt")

Âncoras: Correspondendo Posições

Âncoras não correspondem a caracteres—elas correspondem a posições no texto.

Circunflexo (^) - Início da Linha: A âncora ^ corresponde ao início de uma string ou linha.

Texto: "cat\ndog\ncat"
Regex: ^cat
Corresponde: Apenas o primeiro "cat"

Cifrão ($) - Fim da Linha: A âncora $ corresponde ao fim de uma string ou linha.

Texto: "cat\ndog\ncat"
Regex: cat$
Corresponde: Apenas o último "cat"

Combinando Âncoras: Use ambas para corresponder linhas inteiras.

Regex: ^cat$
Corresponde: Apenas linhas contendo exatamente "cat" sem nada antes ou depois

Limites de Palavra (\b)

A âncora \b corresponde a limites de palavra—posições entre caracteres de palavra e não-palavra.

Texto: "cat category caterpillar"
Regex: \bcat\b
Corresponde: Apenas a palavra isolada "cat"

Isso é incrivelmente útil para encontrar palavras inteiras sem corresponder a palavras parciais.

Sequências de Escape

Caracteres especiais em regex precisam ser escapados com uma barra invertida para corresponderem literalmente:

Caracteres Especiais Forma Escapada
. * + ? ^ $ { } [ ] ( ) | \ \. \* \+ \? \^ \$ \{ \} \[ \] \( \) \| \\

Exemplo correspondendo a um preço:

Regex: \$\d+\.\d{2}
Corresponde: "$19.99", "$5.00"

Classes de Caracteres e Intervalos

Classes de caracteres permitem definir um conjunto de caracteres e corresponder a qualquer um deles. Elas são delimitadas por colchetes.

Classes de Caracteres Básicas

Colchetes [] criam um conjunto de caracteres que corresponde a qualquer caractere único dentro.

Texto: "cat", "cot", "cut", "cit"
Regex: c[aou]t
Corresponde: "cat", "cot", "cut" (não "cit")

Intervalos de Caracteres

Use hífens para definir intervalos de caracteres:

Texto: "a1", "b2", "c3", "d4"
Regex: [a-c][1-3]
Corresponde: "a1", "b2", "c3" (não "d4")

Classes de Caracteres Negadas

Use um circunflexo ^ no início de uma classe de caracteres para negá-la—correspondendo a qualquer caractere que NÃO esteja no conjunto.

Regex: [^0-9]
Corresponde: Qualquer caractere que NÃO seja um dígito
Texto: "abc123def"
Regex: [^a-z]+
Corresponde: "123" (a sequência de não-letras minúsculas)

Classes de Caracteres Predefinidas

Regex fornece atalhos para classes de caracteres comuns:

Atalho Equivalente Descrição
\d [0-9] Qualquer dígito
\D [^0-9] Qualquer não-dígito
\w [a-zA-Z0-9_] Qualquer caractere de palavra
\W [^a-zA-Z0-9_] Qualquer caractere não-palavra
\s [ \t\n\r\f\v] Qualquer caractere de espaço em branco
\S [^ \t\n\r\f\v] Qualquer caractere não-espaço em branco

Exemplo correspondendo a um número de telefone simples:

Regex: \d{3}-\d{3}-\d{4}
Corresponde: "555-123-4567"

Dica rápida: Versões maiúsculas de classes de atalho são sempre a negação de suas contrapartes minúsculas. \d corresponde a dígitos, \D corresponde a não-dígitos.

Quantificadores: Controlando a Repetição de Correspondências

Quantificadores especificam quantas vezes um caractere ou grupo deve ser correspondido. Eles são colocados após o elemento que você deseja repetir.

Quantificadores Básicos

Exemplos de Quantificadores em Ação

Asterisco (*) - Zero ou Mais:

Regex: ca*t
Corresponde: "ct", "cat", "caat", "caaat"

Mais (+) - Um ou Mais:

Regex: ca+t
Corresponde: "cat", "caat", "caaat" (não "ct")

Ponto de Interrogação (?) - Opcional:

Regex: colou?r
Corresponde: "color" e "colour"

Contagem Exata {n}:

Regex: \d{3}
Corresponde: Exatamente três dígitos como "123"

Intervalo {n,m}:

Regex: \d{2,4}
Corresponde: 2 a 4 dígitos como "12", "123" ou "1234"

Quantificadores Gananciosos vs. Preguiçosos

Por padrão, quantificadores são gananciosos—eles correspondem ao máximo de texto possível. Adicionar ? após um quantificador o torna preguiçoso (correspondendo o mínimo possível).

Texto: "<div>content</div><div>more</div>"
Regex (ganancioso): <div>.*</div>
Corresponde: "<div>content</div><div>more</div>" (string inteira)

Regex (preguiçoso): <div>.*?</div>
Corresponde: "<div>content</div>" (apenas primeira tag)

Quantificadores preguiçosos:

Dica profissional: Correspondência gananciosa pode causar problemas de desempenho com textos grandes. Use quantificadores preguiçosos quando precisar corresponder à string mais curta possível, especialmente ao trabalhar com estruturas aninhadas.

Exemplo Prático: Correspondendo Tags HTML

Regex: <([a-z]+)>.*?</\1>
Corresponde: Tags HTML pareadas como "<p>text</p>" ou "<div>content</div>"

Este padrão usa correspondência preguiçosa para evitar capturar múltiplas tags de uma vez, e referências retroativas (cobertas a seguir) para garantir que tags de abertura e fechamento correspondam.

Grupos e Captura

Parênteses () criam grupos que servem a múltiplos propósitos: eles agrupam partes de um padrão, capturam texto correspondido para uso posterior e habilitam referências retroativas.

Agrupamento Básico

Grupos permitem aplicar quantificadores a múltiplos caracteres:

Regex: (ha)+
Corresponde: "ha", "haha", "hahaha"

Sem agrupamento, ha+ corresponderia a "ha", "haa", "haaa" (apenas o 'a' se repete).

Grupos de Captura

Grupos capturam automaticamente o texto que correspondem, que você pode referenciar depois:

Texto: "John Smith"
Regex: (\w+) (\w+)
Captura: Grupo 1 = "John", Grupo 2 = "Smith"

Na maioria das linguagens de programação, você pode acessar essas capturas:

// Exemplo JavaScript
const match = "John Smith".match(/(\w+) (\w+)/);
console.log(match[1]); // "John"
console.log(match[2]); // "Smith"

Referências Retroativas

Referências retroativas permitem corresponder ao mesmo texto que foi capturado por um grupo anteriormente no padrão. Use \1, \2, etc.

Regex: (\w+) \1
Corresponde: Palavras repetidas como "the the" ou "is is"
Regex: <([a-z]+)>.*?</\1>
Corresponde: Tags HTML correspondentes como "<div>...</div>"

Grupos Não-Capturadores

Às vezes você precisa de agrupamento sem captura. Use (?:...) para grupos não-capturadores:

Regex: (?:https?|ftp)://\S+
Corresponde: URLs começando com http, https ou ftp
(O protocolo não é capturado como um grupo)

Grupos não-capturadores melhoram o desempenho quando você não precisa referenciar o texto capturado.

Grupos de Captura Nomeados

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

Regex: (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})
Corresponde: Datas como "2026-03-31"
Acesso: match.groups.year, match.groups.month, match.groups.day

Grupos nomeados são especialmente úteis em padrões complexos onde referências numeradas se tornam confusas.

Dica rápida: Use grupos nomeados para padrões complexos