Testador Regex Grátis — Depure e Combine Padrões Online
Teste padrões de expressões regulares instantaneamente contra qualquer texto. Destaque ao vivo, grupos de captura, prévia de substituição, divisão e explicador. Regex JavaScript, 100% privado, sem cadastro, grátis e online.
O Que É um Testador Regex?
Um testador regex (testador de expressões regulares) é uma ferramenta que te deixa escrever um padrão regex, colar um pedaço de texto de teste e ver exatamente o que o padrão corresponde — com grupos de captura, prévia de substituição e quebra de flags — sem recompilar código ou rodar um script. Para desenvolvedores, ele encurta o ciclo de minutos para milissegundos: ajuste o padrão, observe os destaques se moverem, embarque o regex com confiança.
Uma expressão regular é uma linguagem compacta para descrever padrões de texto. `\d+` corresponde a um ou mais dígitos. `[A-Za-z_]\w*` corresponde a um identificador típico. `(?
Este testador roda a engine RegExp ECMA-262 nativa que vem em cada navegador moderno — a mesma engine que você chama de JavaScript, TypeScript, Node.js, Deno ou Bun. Isso significa: grupos de captura (numerados e nomeados com `(? O que o testador mostra além das correspondências brutas: o painel Correspondências e grupos de captura lista cada correspondência com seus deslocamentos [início, fim) e o valor de cada grupo de captura — a mesma informação que você obteria de `String.prototype.matchAll` com a flag /d, mas disposta para varredura visual. A aba Substituir mostra uma prévia de substituição ao vivo suportando o alfabeto completo de modelos $1 / $& / $` / $' / $$ / $ Para privacidade: cada operação é local. Seu padrão e seu texto de teste nunca saem da página — eles não são registrados, não são enviados para um serviço de analytics, não são armazenados em disco. Apenas suas preferências de UI (aba ativa + quais flags você costuma usar) persistem no localStorage. Isso torna esta ferramenta segura para amostras de log redatadas, padrões proprietários, configuração interna e padrões que incluem pistas sobre o schema dos seus dados. Comparado a testadores apoiados em servidor como o regex101, a história de privacidade e latência é estritamente melhor; o trade-off é o suporte a um único sabor (apenas JavaScript). Se você é novo em regex, o menu Padrões comuns vem com iniciadores testados em batalha: endereço de e-mail, URL, IPv4, UUID, cor hex, data ISO, número de telefone EUA e um padrão para aparar espaço em branco no final. Carregue um, observe as correspondências contra o texto de amostra fornecido, depois mute o padrão um caractere de cada vez para sentir como a engine responde. Combine isto com a ferramenta Diferenças de Texto quando quiser comparar antes/depois de uma limpeza guiada por regex, com Formatador JSON quando sua entrada ou saída esperada for JSON, ou com Codificador URL quando as strings que você corresponde forem URL-encoded.
// The pattern you build in this tester drops straight into JavaScript.
// Example: extract every ISO date from a string with named groups.
const pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g;
const text = 'shipped 2026-05-21, scheduled 2026-06-30';
for (const m of text.matchAll(pattern)) {
console.log(m.groups.year, m.groups.month, m.groups.day);
// → 2026 05 21
// → 2026 06 30
}
// Same regex, used in a replace with $<name> templates:
text.replace(pattern, '$<day>/$<month>/$<year>');
// → 'shipped 21/05/2026, scheduled 30/06/2026'
// With the /d flag, every match carries [start, end] indices
// per capture group — the Matches panel uses this to paint offsets.
const p2 = /(?<year>\d{4})-(?<month>\d{2})/gd;
const m = [...text.matchAll(p2)][0];
m.indices.groups.year; // [8, 12] Principais Recursos
Destaque de Correspondência ao Vivo
Cada correspondência no seu texto de teste acende no instante em que seu padrão é analisado. Cores alternadas tornam correspondências adjacentes fáceis de contar visualmente, e o badge de contagem acima do resultado te diz o total exato — sem botão Executar, sem atraso de debounce maior que 200ms.
Painel Lateral de Grupos de Captura
O painel Correspondências e grupos de captura à direita lista cada correspondência como um card com seus deslocamentos [início, fim), o texto completo da correspondência e cada grupo de captura posicional + nomeado dentro dela. Grupos nomeados se identificam como $
Prévia de Substituição ao Vivo com $1 / $& / $
Mude para a aba Substituir para ver sua substituição aplicada em tempo real. O alfabeto completo de substituição ECMAScript funciona: $1..$N para posicional, $
Dividir com Fronteiras Regex
A aba Dividir chama String.prototype.split com seu regex e mostra cada parte como uma lista numerada. Partes vazias são renderizadas com um glifo ⏎ para que você veja como a engine lidou com delimitadores adjacentes — útil para depurar a limpeza de entrada estilo CSV.
Explicador de Padrões (Token por Token)
A aba Explicar tokeniza seu padrão em chips coloridos por classe (escape / quantificador / classe de caracteres / grupo / âncora / alternância) e anota cada chip com uma descrição de uma linha. Leia seu próprio regex de volta para si mesmo antes de embarcar; use para revisão de código ou ensino.
Seguro contra ReDoS (Timeout de Tempo Real)
Cada chamada de correspondência é envolvida em um orçamento de 250 milissegundos. Formatos clássicos de retrocesso catastrófico como `(a+)+`, `(a|aa)+b` e quantificadores profundamente aninhados abortam de forma limpa com um aviso Padrão expirou — a página continua responsiva em vez de travar a aba. Detecção sem sandbox no lado do servidor.
Biblioteca de Padrões Comuns
Iniciadores testados em batalha para os oito padrões que desenvolvedores mais usam: e-mail, URL, IPv4, UUID v4, cor hex, data ISO, número de telefone EUA e aparar espaço em branco no final. Cada um carrega com uma amostra correspondente para você ver o regex funcionando antes de adaptá-lo.
Compartilhamento por Permalink (Sem Upload)
Copiar link codifica padrão + flags + texto de amostra no hash da URL (#p=…&f=gim&t=…). Navegadores nunca transmitem fragmentos de URL em requisições, então um link compartilhado reproduz seu estado na máquina do destinatário sem tocar os servidores go-tools.org. Autocontido, amigável à auditoria.
100% Privado, Apenas no Navegador
Seu regex e texto de teste nunca saem do seu dispositivo. Sem requisições de rede, sem logs, sem analytics sobre o que você digita. Verifique em DevTools → Network: zero requisições quando você digita. Seguro para padrões proprietários, logs redatados e qualquer texto que você não colaria no regex101.
Exemplos Trabalhados
Extrair todos os endereços de e-mail de um parágrafo
[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,} /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g Cole o padrão com a flag /g ativada, jogue um parágrafo na área de teste e cada e-mail acende na visualização destacada. O painel Correspondências e grupos de captura à direita lista cada endereço com seus deslocamentos [início, fim) — útil quando você quer canalizar o mesmo regex para grep, sed ou um editor de código.
Capturar partes da data com grupos nomeados
(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2}) /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g Os grupos nomeados do ECMA-262 aparecem no painel direito como $
Localizar/substituir com retro-referências $1
(\w+) (\w+)
Substituição: $2, $1 → João Silva → Silva, João
Dois grupos de captura sem nome, modelo de substituição $2, $1, e a aba Substituir te dá uma prévia ao vivo. $&, $`, $', $$ e $
Remover espaços em branco no final de cada linha
[ \t]+$
/[ \t]+$/gm
Combine as flags /g (global) e /m (multiline) para que $ ancore no final de cada linha, não apenas no final da entrada. A aba Substituir com uma prévia de substituição vazia mostra um diff limpo: tabs e espaços no final somem, a prosa fica intacta. O mesmo regex com a flag /s (dotAll) desligada impede que . cruze quebras de linha.
Detectar retrocesso catastrófico e sobreviver
(a+)+b
Texto de teste: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac
Os quantificadores + aninhados formam um padrão ReDoS clássico. Em um testador ingênuo isso trava a aba. Aqui o guarda de tempo real dispara após 250ms, aparece o aviso Padrão expirou e a página continua responsiva. Ancore o padrão, mude para uma alternância sem sobreposição ou use expressões idiomáticas tipo atômicas — e teste de novo.
Dividir uma linha estilo CSV por delimitadores mistos
[,;|]\s*
alpha, beta; gamma | delta → ["alpha", "beta", "gamma", "delta"]
Mude para a aba Dividir. Qualquer vírgula, ponto-e-vírgula ou pipe (seguido de espaço opcional) vira uma fronteira de parte. Útil para limpar listas de tags copiadas, normalizar entrada do usuário ou pré-processar campos de log antes de um parser CSV de verdade — veja CSV para JSON quando os dados realmente forem RFC 4180.
Como Usar o Testador Regex
- 1
Digite seu padrão entre as barras
Jogue qualquer expressão regular ECMA-262 no campo /…/. Padrões inválidos destacam em vermelho com uma mensagem do parser; padrões válidos seguem para a correspondência ao vivo.
- 2
Alterne as flags que você precisa
g (global), i (case-insensitive), m (multilinha), s (dotAll), u (unicode), y (sticky), d (índices). Cada chip acende quando está ativo; o leitor à direita do padrão mostra o literal canônico.
- 3
Cole seu texto de teste
Correspondências destacam em cores alternadas conforme você digita. O painel Correspondências e grupos de captura à direita lista cada correspondência com deslocamentos [início, fim) e o valor de cada grupo de captura (grupos nomeados rotulados como $
). - 4
Mude de aba para Substituir, Dividir ou Explicar
Substituir pré-visualiza um modelo de substituição junto com a entrada. Dividir fatia em cada fronteira de correspondência. Explicar quebra o padrão token por token com uma descrição em português claro por elemento.
- 5
Copie o literal ou compartilhe um permalink
Copiar /pattern/flags joga o literal regex canônico na sua área de transferência para uso direto em JavaScript / TypeScript / Node. Copiar link codifica o estado completo em um hash de URL (sem upload) para que um colega possa reproduzi-lo localmente.
Erros Comuns de Regex
Esqueceu da flag /g e só conseguiu uma correspondência
Sem /g (ou /y), a engine para depois da primeira correspondência. Os métodos match, matchAll, replace e split todos se comportam diferente em torno da flag global. Alterne /g e rode de novo; a contagem acima dos resultados pula de 1 para N.
Padrão: /\d+/ → '1 22 333' rende apenas ['1']
Padrão: /\d+/g → '1 22 333' rende ['1', '22', '333']
Quantificador ganancioso consumiu demais
`.+` consome o máximo possível, então `<.+>` contra ` e ` captura ` e `, não ``. Use quantificadores preguiçosos (`.+?`), classes de caracteres mais restritivas (`[^>]+`) ou ancore com lookarounds.
Padrão: /<.+>/ → corresponde a '<a> e <b>'
Padrão: /<[^>]+>/ → corresponde a '<a>' e '<b>' separadamente
Retrocesso catastrófico de quantificadores aninhados
`(a+)+b` contra uma string longa que falha explode exponencialmente. O aviso Padrão expirou dispara depois de 250ms; reescreva para remover o aninhamento: `a+b` faz o mesmo trabalho em tempo linear. Simulação de grupo atômico `(?=(a+))\1b` é outra opção.
Padrão: /(a+)+b/ em 'aaaaaaaaaaaaaaaaaaaaac' → timeout
Padrão: /a+b/ na mesma entrada → 'sem correspondência' instantâneo
Âncoras $ e ^ não se comportam como \A e \Z do Python
Em JavaScript, `^` e `$` significam início-de-linha / fim-de-linha APENAS quando /m está ativo; caso contrário significam início-da-string / fim-da-string. `\A` e `\Z` do Python (que sempre significam fronteiras de string) não existem em JS. Alterne /m conforme necessário.
Padrão: /^Error/ em um log multilinha sem /m → corresponde apenas à primeira linha
Padrão: /^Error/m na mesma entrada → corresponde a cada linha começando com Error
Usou $1 em uma string mas chamou replace com uma função
`text.replace(re, '$1')` expande a retro-referência. `text.replace(re, () => '$1')` passa a string literal '$1' porque funções não veem tokens de modelo. Dentro da função, grupos de captura chegam como argumentos posicionais.
text.replace(/(\w+)/, m => '$1') → rende o literal '$1'
text.replace(/(\w+)/, (_, g1) => g1.toUpperCase()) → usa a captura
Caracteres Unicode não correspondendo com \w ou .
O `\w` padrão é `[A-Za-z0-9_]`. Para corresponder a cada letra em cada script, habilite /u e mude para `\p{Letter}` (`\p{L}`). O ponto também para em quebras de linha por padrão — use /s (dotAll) quando quiser um verdadeiro qualquer-caractere.
Padrão: /\w+/ corresponde a 'hello' mas não a 'héllo' ou '你好'
Padrão: /\p{Letter}+/u corresponde aos três Colou um padrão PCRE; recebeu um SyntaxError
JavaScript não suporta grupos atômicos `(?>...)`, quantificadores possessivos `a++`, modificadores inline `(?i)`, condicionais `(?(1)yes|no)` ou `\A` / `\Z`. O erro do parser nomeia a construção problemática — reescreva para o equivalente suportado em JS (simulação de lookaround, alternância de flag separada, alternância).
Padrão: (?i)foo → SyntaxError: grupo inválido
Padrão: foo com a flag /i ativada → mesmo efeito
Quem Usa Esta Ferramenta
- Validar Entradas de Formulário Antes de Embarcar
- Confirme que seu regex de e-mail / telefone / CEP / nome de usuário corresponde ao que você espera — e rejeita o que você não quer — em casos extremos (nomes unicode, plus-aliasing, formatos internacionais) antes que a validação chegue em produção e rejeite usuários reais.
- Extrair Dados de Logs e Configurações
- Construa um padrão que extrai IDs de requisição, códigos de status, latências ou linhas de stack trace de uma fatia arbitrária de log. Grupos nomeados tornam os dados autodocumentados; o painel Correspondências mostra deslocamentos para que você possa canalizar o mesmo regex para `rg --replace` ou `grep -oE` depois.
- Localizar/Substituir em uma Codebase
- Rascunhe um padrão de refatoração (ex: `(\w+)\.apply\(null,\s*\[(.*?)\]\)` → `$1($2)`) aqui, pré-visualize a substituição contra trechos representativos, depois cole o regex validado no localizar/substituir do projeto inteiro do seu editor com confiança.
- Conferência Rápida de um Padrão Encontrado Online
- Colou um regex do StackOverflow ou de um blog? Jogue na aba Explicar — cada token recebe anotação em português claro. Pega problemas sutis (`.+?` onde você queria `.+`, âncoras `^`/`$` faltando, quantificadores acidentalmente gananciosos) antes que o regex caia no seu código.
- Ensinar Regex para um Colega de Equipe
- Abra a aba Explicar em um padrão funcionando e passe por ele token por token. A codificação de cores (escape / quantificador / classe de caracteres / grupo / âncora / alternância) deixa o aprendiz ver o formato estrutural do regex, não apenas os caracteres.
- Portar um Padrão Entre Linguagens
- Tem um regex Python ou PCRE que você precisa usar em JavaScript? Cole aqui. Se ele compila, o explicador te mostra a semântica equivalente em JS; se não compila, o erro do parser nomeia a construção problemática (grupos atômicos, quantificadores possessivos, `(?i)` inline) para você saber exatamente o que reescrever.
- Depurar um Regex Lento em Produção
- Se um regex de servidor é suspeito de retrocesso catastrófico, cole-o neste testador com uma amostra da entrada. O guarda de tempo real de 250ms dispara em casos patológicos, dando um diagnóstico imediato antes que você precise de ferramentas de profiler — e o explicador aponta a causa raiz do quantificador aninhado.
Notas de Engine e Algoritmo
- Engine RegExp ECMA-262 (Navegador Nativo)
- Usa `new RegExp(pattern, flags)` e a engine que vem com V8 / JavaScriptCore / SpiderMonkey — a mesma semântica de regex que você obtém em JavaScript em qualquer lugar. Padrões que validam aqui rodam inalterados em Node.js, Deno, Bun e cada navegador moderno.
- Iteração de Correspondência via String.matchAll
- A iteração global usa `text.matchAll(regex)` em vez de um loop manual lastIndex, para que cada correspondência carregue seus grupos de captura, grupos nomeados e (com /d) índices [início, fim]. Correspondências de largura zero são tratadas com o avanço padrão +1 lastIndex para evitar loops infinitos.
- Timeout de Tempo Real para Proteção ReDoS
- Um orçamento de 250 milissegundos envolve cada chamada de correspondência, substituição e divisão. A engine ainda pode retroceder internamente em uma única tentativa de correspondência, mas a iteração externa coopera com o orçamento — padrões patológicos abortam com `timedOut: true` e a UI exibe um aviso em vez de travar a aba.
- Reimplementação de Modelo de Substituição
- A aba Substituir analisa $1..$N, $&, $`, $', $$ e $
manualmente em vez de delegar para `String.replace`, para que a prévia se comporte identicamente entre engines (Safari antigo, Node antigo) onde modelos de grupo nomeado têm casos extremos. A saída é exatamente o que as engines JavaScript atuais produzem. - Tokenizador de Padrões para o Explicador
- A aba Explicar roda um tokenizador feito à mão que classifica cada fragmento de padrão (escape / metachar / quantificador / classe de caracteres / abertura-de-grupo / fechamento-de-grupo / âncora / alternância). Construções desconhecidas caem para `literal` com uma nota genérica para que o explicador nunca descarte conteúdo silenciosamente.
- Permalinks via Hash de URL (Nunca Transmitido)
- O estado de compartilhamento é codificado no fragmento location.hash (`#p=…&f=…&t=…&tab=…`). Navegadores nunca transmitem o fragmento em requisições HTTP, então os servidores go-tools.org recebem zero dados quando um permalink é aberto. A hidratação acontece inteiramente no dispositivo do destinatário.
Boas Práticas de Regex
- Ancore Padrões Quando Você Quiser
- `^pattern$` corresponde a uma string exata; `pattern` corresponde em qualquer lugar. A escolha errada é o bug mais comum em validação de formulário: `^` faltando deixa um `attacker.com/` no início passar por uma checagem de domínio; `$` faltando deixa lixo no final passar. Use a aba Combinar contra amostras deliberadamente quebradas para confirmar o que é rejeitado.
- Prefira Grupos Não-Capturadores para Estrutura Pura
- `(?:foo|bar)+` e `(foo|bar)+` são funcionalmente idênticos, mas o primeiro não aloca um grupo de captura. Pegue `(?:…)` sempre que o grupo existir apenas para um quantificador ou alternância — mantém seus $1..$N numerados estáveis e economiza uma quantidade pequena de trabalho da engine.
- Use a Flag /u para Qualquer Coisa Além de ASCII
- Sem /u, o ponto e `\w` tratam caracteres de par substituto (emoji, pontos de código fora do BMP) como duas unidades UTF-16. Com /u, eles são um ponto de código cada — o que seus usuários vão perceber. /u também habilita `\p{Letter}` e outros escapes de propriedade. Defina /u como padrão para padrões novos a menos que tenha uma razão específica para não fazer.
- Nomeie Seus Grupos de Captura
- `(?
\d{4})-(? \d{2})` é autodocumentado. Seis meses depois quando você ler o regex de volta, `m.groups.year` é obviamente o ano — `m[1]` não é. Modelos de substituição com $ sobrevivem ao reordenamento de grupos também: modelos posicionais quebram no momento em que alguém adiciona outro grupo. - Teste Casos de Falha, Não Apenas Sucesso
- Um testador regex é para as falhas. Confirme o que seu padrão corresponde, depois mute deliberadamente o texto de teste para ver o que ele não corresponde — espaço em branco no início, espaço em branco no fim, partes faltando, partes extras, case errado, scripts misturados. Padrões que passam entrada válida mas aceitam lixo são os bugs que a produção expõe primeiro.
Perguntas Frequentes
Meu regex ou texto de teste é enviado para o seu servidor?
Qual sabor de regex este testador usa — PCRE, Python, Java, JavaScript?
O que cada uma das flags g, i, m, s, u, y, d faz?
Como escrevo grupos de captura e como me refiro a eles depois?
Como funcionam lookahead e lookbehind e para que servem?
Por que meu regex trava o navegador e o que é retrocesso catastrófico?
Qual a diferença entre este testador regex e o regex101.com?
Como faço escape de caracteres especiais como . | ( ) [ ] { } * + ? ^ $ \?
Posso compartilhar um regex com um colega via link?
O testador suporta Unicode, emoji e scripts não-latinos?
Qual a diferença entre .match, .matchAll, .replace e .split com um regex?
Por que meu regex Python ou Java não funciona aqui?
Existe um tamanho máximo de texto ou contagem de correspondências?
Ferramentas relacionadas
Ver todas as ferramentas →Comparar dois textos — Diff
Processamento de Texto
Compare dois textos na hora no seu navegador. Vista lado a lado, destaque palavra a palavra, exportação para diff unificado, opções para ignorar maiúsculas/espaços/linhas vazias. 100 % navegador — sem upload.
Contador de Palavras e Caracteres Grátis
Processamento de Texto
Conte palavras, caracteres, frases, parágrafos e tempo de leitura instantaneamente. Contador em tempo real com verificação de limites do Twitter, meta description e Instagram. Grátis, privado, sem cadastro.
Conversor de Base Numérica — Binário, Hex, Decimal e Octal
Ferramentas de Conversão
Converta números entre binário, hexadecimal, decimal, octal e qualquer base personalizada (2-36) instantaneamente. Gratuito, privado, sem cadastro — todo o processamento acontece no seu navegador.
Decodificador e Codificador Base64
Codificação e Formatação
Decodifique e codifique Base64 online gratuitamente. Conversão em tempo real com suporte completo a UTF-8 e emoji. 100% privado — executa no seu navegador. Sem necessidade de cadastro.
Gerador Crontab e Construtor de Expressão Cron
Data e Hora
Crie, valide e decodifique expressões cron no navegador. Pré-visualização ao vivo da próxima execução em horário local ou UTC. Sintaxe POSIX de 5 campos, presets, descrição em linguagem clara. Grátis, privado, sem cadastro.
Conversor CSV para JSON
Codificação e Formatação
Converta CSV para JSON no navegador. RFC 4180, inferência de tipos, cabeçalho, seguro para inteiros grandes. 100% privado, sem upload.