Expressões Regulares (RegExp)

Uma expressão regular (ou RegExp) é uma sequência de caracteres que define um padrão de busca textual. Elas são a ferramenta ideal para validar dados (como e-mails, CEPs e senhas), extrair informações de textos desestruturados e fazer substituições dinâmicas.

Em JavaScript, você pode declarar uma regex de forma literal entre barras como /padrao/flags ou dinamicamente usando o construtor new RegExp("padrao", "flags"). Elas funcionam tanto em métodos próprios da classe RegExp (test e exec) quanto em métodos nativos de String (match, matchAll, replace, search e split).

Métodos essenciais de busca e validação

Os métodos nativos de RegExp e String para executar testes, buscas e extrações no dia a dia.

`RegExp.prototype.test()`

Verifica se o padrão existe dentro de uma string e devolve um booleano (true ou false).

Sintaxe: regex.test(texto)
Devolve: true se o padrão for encontrado no texto; caso contrário, false.

const temDigito = /\d/.test('Código 42');
console.log(temDigito);
console.log(/\d/.test('Sem números'));

Mostra

true
false

Ao usar a flag g (global), o método test() armazena o índice da última busca na propriedade lastIndex. Chamadas sucessivas com a mesma instância continuarão de onde pararam e podem alternar entre true e false!

`RegExp.prototype.exec()`

Executa uma busca detalhada e devolve um array com o texto casado, o índice e os grupos de captura, ou null.

Sintaxe: regex.exec(texto)
Devolve: Um array com a correspondência e propriedades extras (index, input, groups), ou null.

const regex = /item: (\w+)/;
const resultado = regex.exec('Pedido item: caderno pronto');
console.log(resultado[0]);
console.log(resultado[1]);

Mostra

item: caderno
caderno

Se a correspondência falhar, exec() devolve null. Tentar acessar posições como resultado[0] diretamente sem verificar antes causará um erro TypeError.

`String.prototype.match()`

Busca correspondências da regex em uma string. Sem a flag g traz detalhes do primeiro casamento; com g devolve todos os casamentos.

Sintaxe: texto.match(regex)
Devolve: Um array com os casamentos encontrados, ou null se nada for encontrado.

const texto = 'Ana comprou 3 maçãs e 12 bananas';
const numeros = texto.match(/\d+/g);
console.log(numeros);

Mostra

[ '3', '12' ]

Se nada for encontrado, match() devolve null em vez de um array vazio []. Para evitar erros ao ler .length ou iterar, use um fallback como texto.match(...) || [].

`String.prototype.matchAll()`

Devolve um iterador com todas as correspondências completas, incluindo índices e grupos de captura. Exige a flag global g.

Sintaxe: texto.matchAll(regex)
Devolve: Um iterador de arrays com detalhes de cada casamento.

const texto = 'ID: 10, ID: 25, ID: 80';
const pares = [...texto.matchAll(/ID: (\d+)/g)].map((m) => m[1]);
console.log(pares);

Mostra

[ '10', '25', '80' ]

O método matchAll() lança um TypeError imediato se a expressão regular não tiver a flag g (global) configurada.

`String.prototype.replace() com RegExp`

Substitui trechos que combinam com a expressão regular por outro texto ou pelo valor retornado de uma função.

Sintaxe: texto.replace(regex, novoTextoOuFuncao)
Devolve: Uma nova string com as substituições realizadas.

const dataIso = '2026-11-06';
const br = dataIso.replace(/(\d{4})-(\d{2})-(\d{2})/, '$3/$2/$1');
console.log(br);

Mostra

06/11/2026

Sem a flag g, o replace() substitui apenas a primeira ocorrência encontrada no texto. Use /padrao/g (ou replaceAll) para substituir todas.

`String.prototype.search()`

Procura a primeira ocorrência de uma regex na string e devolve a posição do índice numérico inicial.

Sintaxe: texto.search(regex)
Devolve: O índice da primeira correspondência, ou -1 se não for encontrada.

const frase = 'A reunião será às 14h';
const posicao = frase.search(/\d+/);
console.log(posicao);

Mostra

O método search() ignora a flag g e sempre busca apenas a primeira ocorrência. Ele também converte qualquer argumento em RegExp.

`String.prototype.split() com RegExp`

Divide a string em um array de partes usando uma expressão regular como delimitador flexível.

Sintaxe: texto.split(regex)
Devolve: Um array de strings com as partes divididas.

const dados = 'maçã, banana ; uva ,laranja';
const itens = dados.split(/\s*[,;]\s*/);
console.log(itens);

Mostra

[ 'maçã', 'banana', 'uva', 'laranja' ]

Se a regex do split() contiver grupos de captura com parênteses (), os separadores capturados também serão inseridos no array resultante!

Classes de caracteres e atalhos

Metacaracteres que representam categorias inteiras de símbolos sem precisar listá-los um a um.

`Classes básicas (\d, \w, \s)`

Atalhos prontos para casar dígitos (\d), caracteres alfanuméricos (\w) e espaços (\s), ou suas negações (\D, \W, \S).

Sintaxe: /\d/ (dígito), /\w/ (palavra), /\s/ (espaço)
Devolve: Metacaracteres de padrão (não devolvem valor sozinhos).

const placa = 'ABC-1234';
const letras = placa.match(/\D+/g);
const numeros = placa.match(/\d+/g);
console.log(letras[0]);
console.log(numeros[0]);

Mostra

ABC-
1234

O atalho \w equivale ao conjunto ASCII [A-Za-z0-9_]. Ele NÃO inclui caracteres acentuados (como á, é, ç) nem alfabetos não-latinos sem flags específicas.

`Conjuntos e intervalos ([abc], [a-z], [^...])`

Define uma lista de caracteres permitidos entre colchetes. Com hífen vira intervalo, e com ^ no início vira negação.

Sintaxe: /[abc]/ (um dos três), /[0-9]/ (intervalo), /[^0-9]/ (negação)
Devolve: Metacaracteres de padrão (não devolvem valor sozinhos).

const texto = 'Nota final: B+';
const conceito = texto.match(/[ABCD][+-]?/);
console.log(conceito[0]);

Mostra

B+

Dentro de colchetes, metacaracteres como ponto (.) e asterisco (*) perdem o significado especial e viram caracteres literais, exceto o hífen (-) e o circunflexo (^) na primeira posição.

`Ponto curinga (.)`

Casa qualquer caractere individual, exceto quebras de linha (\n ou \r).

Sintaxe: /c.rro/ (casa "carro", "corro", "c1rro")
Devolve: Metacaractere de padrão (não devolve valor sozinho).

const nomes = ['gato', 'pato', 'rato', 'mato'];
const rimas = nomes.filter((n) => /.ato/.test(n));
console.log(rimas);

Mostra

[ 'gato', 'pato', 'rato', 'mato' ]

Para buscar um ponto literal (como em extensões de arquivo .js ou endereços web), você precisa escapá-lo com barra invertida: \.

Quantificadores e repetições

Controle quantas vezes um caractere, conjunto ou grupo pode se repetir no padrão.

`Quantificadores (*, +, ?)`

Definem quantas vezes o item anterior pode se repetir: * (0 ou mais), + (1 ou mais) e ? (opcional: 0 ou 1).

Sintaxe: /a*/ (zero ou mais), /a+/ (um ou mais), /a?/ (opcional)
Devolve: Metacaracteres de padrão (não devolvem valor sozinhos).

const protocolos = ['http', 'https'];
const padrao = /^https?$/;
console.log(protocolos.every((p) => padrao.test(p)));

Mostra

true

Por padrão, quantificadores em regex são gulosos (greedy): eles tentam casar a maior quantidade possível de texto. Adicione ? após o quantificador (ex: +?) para torná-lo preguiçoso (lazy).

`Intervalos numéricos ({n}, {min,}, {min,max})`

Especifica o número exato ou uma faixa de repetições permitidas para o caractere ou grupo anterior.

Sintaxe: /\d{4}/ (exatos 4), /\d{2,4}/ (entre 2 e 4), /\d{3,}/ (no mínimo 3)
Devolve: Metacaracteres de padrão (não devolvem valor sozinhos).

const anoValido = /^\d{4}$/.test('2026');
const anoCurto = /^\d{4}$/.test('26');
console.log(anoValido);
console.log(anoCurto);

Mostra

true
false

Nunca coloque espaços depois da vírgula dentro das chaves: {2, 4} vira busca por texto literal e falha como quantificador. Escreva sempre {2,4}.

Âncoras e limites de posição

Posicione o padrão no início, no fim ou em fronteiras de palavras sem consumir caracteres.

`Início e fim (^ e $)`

Âncoras de posição: ^ casa o início do texto e $ casa o fim, garantindo que o padrão cubra a string inteira.

Sintaxe: /^inicio/ (começa com), /fim$/ (termina com), /^exato$/ (toda a string)
Devolve: Âncoras de posição (não devolvem valor sozinhas).

console.log(/^\d+$/.test('12345'));
console.log(/^\d+$/.test('123abc45'));

Mostra

true
false

Sem ^ e $, uma regex como /\d{3}/ retornará true para "abc12345def" pois ela procura o padrão em qualquer parte da string, e não na totalidade.

`Borda de palavra (\b e \B)`

Casa na fronteira entre um caractere de palavra (\w) e um caractere que não é de palavra (espaços, pontuações ou início/fim).

Sintaxe: /\bpalavra\b/ (apenas a palavra exata)
Devolve: Âncoras de posição (não devolvem valor sozinhas).

const frase = 'Aprenda js hoje no json e nodejs';
const casamentos = frase.match(/\bjs\b/g);
console.log(casamentos);

Mostra

[ 'js' ]

O delimitador \b depende de \w (letras ASCII, números e sublinhado). Em palavras acentuadas (como "café"), há uma fronteira de palavra entre a letra e o acento se o caractere não for ASCII.

Grupos, alternância e flags

Estruturação avançada com subexpressões, operadores lógicos e modificadores de execução.

`Grupos e alternância (( ) e |)`

Agrupa subexpressões entre parênteses para aplicar quantificadores ou extrair trechos, e usa | como operador OU.

Sintaxe: /(segunda|terca|quarta)/ (alternância), /(\d{2})\/(\d{2})/ (grupos)
Devolve: Sintaxe de agrupamento e operador condicional.

const arquivos = ['foto.png', 'dados.csv', 'icone.jpg'];
const imagens = arquivos.filter((arq) => /\.(png|jpg|gif)$/.test(arq));
console.log(imagens);

Mostra

[ 'foto.png', 'icone.jpg' ]

Parênteses normais ( ) criam grupos de captura que armazenam os trechos na memória. Se precisar agrupar apenas para lógica sem capturar, use grupos não-capturantes: (?:padrao).

`Grupos nomeados (?<nome>)`

Atribui nomes descritivos aos grupos de captura, permitindo acessá-los diretamente pela propriedade .groups[nome].

Sintaxe: /(?<ano>\d{4})-(?<mes>\d{2})-(?<dia>\d{2})/
Devolve: Objeto groups preenchido no resultado de exec() ou match().

const regex = /(?<codigo>[A-Z]{3})-(?<numero>\d{4})/;
const { groups } = regex.exec('Voo: GOL-1234');
console.log(groups.codigo);
console.log(groups.numero);

Mostra

GOL
1234

Se a regex não encontrar correspondência, o resultado será null e tentar ler .groups causará erro. Use desestruturação segura com fallback: const { groups } = regex.exec(...) ?? {};

`Modificadores (flags g, i, m, s, u)`

Letras adicionadas ao fim da expressão que alteram seu comportamento: global (g), sem diferenciar maiúsculas (i), multilinha (m), ponto casa tudo (s) e unicode (u).

Sintaxe: /padrao/gims ou new RegExp("padrao", "gi")
Devolve: Modificadores de compilação da regex.

const texto = 'JavaScript e javascript e JAVASCRIPT';
const matches = texto.match(/javascript/gi);
console.log(matches.length);

Mostra

A flag g faz os métodos test() e exec() manterem estado interno (lastIndex). Para validações simples em formulários, evite a flag g para não gerar falsos negativos intercalados.

Quer testar? Copie um exemplo e rode no Rascunho.