Expressões regulares (regex) são padrões usados para buscar, validar e manipular texto. Em JavaScript, elas são objetos da classe RegExp e podem ser criadas de duas formas: literal ou construtor. Dominar regex é essencial para tarefas como validação de formulários, extração de dados e substituição de strings.

Nesta aula, vamos explorar a sintaxe básica, os principais métodos (test, match, replace), o uso de grupos de captura e casos comuns do dia a dia. Você verá exemplos práticos e, ao final, exercícios para consolidar o conhecimento.

Sintaxe básica

Uma expressão regular é definida entre barras /padrão/flags ou usando new RegExp('padrão', 'flags'). A forma literal é mais comum e compilada em tempo de carregamento, enquanto o construtor permite criar padrões dinamicamente.

Os padrões podem incluir caracteres literais, metacaracteres (como ., \d, \w, \s), classes de caracteres [abc], quantificadores (*, +, ?, {n,m}) e âncoras (^, $). As flags mais usadas são g (global), i (ignora maiúsculas/minúsculas) e m (multilinha).

// Forma literal
const regex1 = /ab+c/gi;

// Forma construtor
const regex2 = new RegExp('ab+c', 'gi');

// Metacaracteres comuns
\d  // dígito (0-9)
\w  // caractere alfanumérico (letras, dígitos, _)
\s  // espaço em branco (espaço, tab, quebra de linha)
\b  // borda de palavra

// Quantificadores
*    // zero ou mais
+    // um ou mais
?    // zero ou um
{n}  // exatamente n vezes
{n,} // pelo menos n vezes
{n,m}// entre n e m vezes

Exemplo prático: validar um formato simples de data dd/mm/aaaa.

const dataRegex = /^\d{2}\/\d{2}\/\d{4}$/;
console.log(dataRegex.test('29/02/2024')); // true
console.log(dataRegex.test('29/02/24'));   // false

Métodos (test, match, replace)

O método test() retorna true se o padrão for encontrado em alguma parte da string. É útil para validações booleanas. Já match() retorna um array com as correspondências ou null se não houver. Com a flag g, retorna todas as correspondências em um array simples; sem ela, retorna detalhes como grupos.

O método replace() substitui correspondências por outra string ou função de substituição. Ele é muito usado para sanitizar entradas ou formatar textos.

const texto = 'O rato roeu a roupa do rei de Roma.';

// test()
const temRato = /rato/.test(texto);
console.log(temRato); // true

// match() com flag g
const palavrasComR = texto.match(/\br\w+/gi);
console.log(palavrasComR); // [ 'rato', 'roeu', 'roupa', 'rei', 'Roma' ]

// replace() substitui a primeira ocorrência sem flag g
const novoTexto = texto.replace('rato', 'gato');
console.log(novoTexto); // 'O gato roeu a roupa do rei de Roma.'

// replace() com flag g substitui todas
const semR = texto.replace(/r/gi, 'l');
console.log(semR); // 'O lato loeu a loupa do lei de Loma.'

Outros métodos úteis incluem search() (retorna o índice da primeira correspondência) e split() (divide a string pelo padrão).

Grupos

Grupos de captura são definidos com parênteses (...). Eles permitem extrair partes específicas da correspondência e também podem ser usados para agrupar alternativas ou aplicar quantificadores a um conjunto. Os grupos são numerados a partir de 1, e o grupo 0 é sempre a correspondência completa.

Além de grupos de captura, existem grupos não capturadores (?:...) e lookaheads/lookbehinds: (?=...), (?!...), (?<=...) e (?<!...).

const telefone = '(11) 98765-4321';

// Padrão com grupos para DDD e número
const telefoneRegex = /\((\d{2})\)\s(\d{4,5})-(\d{4})/;
const match = telefone.match(telefoneRegex);
console.log(match[1]); // '11'
console.log(match[2]); // '98765'
console.log(match[3]); // '4321'

// Substituição usando grupos ($1, $2, ...)
const formatado = telefone.replace(telefoneRegex, '($1) $2-$3');
console.log(formatado); // '(11) 98765-4321'

// Grupo não capturador
const regex = /(?:\d{2})\/(\d{2})\/\d{4}/;
const data = '29/02/2024';
const m = data.match(regex);
console.log(m[1]); // '02' (o grupo 1 é o mês, o DDD não captura)

Em padrões com a flag g e match(), os grupos não são retornados; para obter grupos com múltiplas correspondências, use matchAll() (disponível em ES2020).

const texto = 'Em 2024 e 2025 teremos eventos.';
const anos = texto.matchAll(/(\d{4})/g);
for (const match of anos) {
  console.log(match[1]); // '2024', '2025'
}

Casos comuns

Expressões regulares são frequentemente usadas para validação de e-mail, CPF, telefone, URL, extração de hashtags, entre outros. Abaixo, alguns exemplos práticos.

// Validar e-mail (simplificado)
const emailRegex = /^[\w.-]+@[\w-]+\.[\w.-]+$/;
console.log(emailRegex.test('usuario@dominio.com')); // true

// Extrair hashtags
const post = 'Adoro #JavaScript e #Regex!';
const hashtags = post.match(/#\w+/g);
console.log(hashtags); // [ '#JavaScript', '#Regex' ]

// Validar CPF (somente dígitos e formato)
const cpfRegex = /^\d{3}\.\d{3}\.\d{3}-\d{2}$/;
console.log(cpfRegex.test('123.456.789-00')); // true

// Extrair números de uma string
const frase = 'Tenho 30 anos e 2 gatos.';
const numeros = frase.match(/\d+/g);
console.log(numeros); // [ '30', '2' ]

// Remover espaços extras
const textoEspacado = '  Olá,   mundo!  ';
const limpo = textoEspacado.replace(/\s+/g, ' ').trim();
console.log(limpo); // 'Olá, mundo!'

// Validar URL (simplificada)
const urlRegex = /^(https?:\/\/)?([\w.-]+)\.[a-z]{2,}(\/\S*)?$/i;
console.log(urlRegex.test('https://exemplo.com/pagina')); // true

Esses exemplos mostram como regex pode resolver problemas comuns de forma concisa. Sempre teste seus padrões em diferentes cenários para garantir robustez.

Boas práticas

  • Use a flag g somente quando necessário, pois afeta o comportamento de test() e match().
  • Prefira a forma literal para padrões estáticos; use o construtor para padrões dinâmicos.
  • Componha padrões complexos com grupos nomeados (?<nome>...) para maior legibilidade.
  • Teste regex em plataformas como regex101.com para depurar.
  • Evite regex excessivamente complexas; quebre em múltiplas validações se necessário.
  • Lembre-se de escapar barras dentro de padrões literais: /\// para representar /.

Referências

Exercícios

  1. Validação de CPF: Escreva uma função que valide se uma string está no formato XXX.XXX.XXX-XX (somente formato, não dígitos verificadores). Use test().

    2. ✓ Resposta: 
    function validaFormatoCPF(cpf) {
  const regex = /^\d{3}\.\d{3}\.\d{3}-\d{2}$/;
  return regex.test(cpf);
}
console.log(validaFormatoCPF('123.456.789-00')); // true
console.log(validaFormatoCPF('123.456.789-0'));  // false
  2. Extrair palavras: Dada a string "A programação é divertida, mas requer prática.", extraia todas as palavras que tenham mais de 5 letras usando match() e a flag g.

    3. ✓ Resposta: 
    const frase = 'A programação é divertida, mas requer prática.';
const palavrasLongas = frase.match(/\b\w{6,}\b/g);
console.log(palavrasLongas); // [ 'programação', 'divertida', 'prática' ]
  3. Substituir espaços: Substitua todos os espaços em branco por hífens em uma string, usando replace() com a flag g.

    4. ✓ Resposta: 
    const texto = 'JavaScript é incrível';
const comHifen = texto.replace(/\s/g, '-');
console.log(comHifen); // 'JavaScript-é-incrível'
  4. Capturar nome de usuário: Em um e-mail como "usuario@dominio.com", extraia o nome de usuário (parte antes do @) usando um grupo de captura e match().

    5. ✓ Resposta: 
    const email = 'usuario@dominio.com';
const regex = /^([^@]+)@/;
const match = email.match(regex);
console.log(match[1]); // 'usuario'
  5. Validar senha forte: Crie uma regex que valide se uma senha tem pelo menos 8 caracteres, contém pelo menos uma letra maiúscula, uma minúscula e um número. Use lookaheads.

    6. ✓ Resposta: 
    const senhaRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$/;
console.log(senhaRegex.test('Senha123')); // true
console.log(senhaRegex.test('senha123')); // false (sem maiúscula)