Testador e Depurador de Regex

Teste e depure expressões regulares JavaScript localmente no navegador.

Sem uploadsSem cadastroResultados instantâneos
Flags g · i · m · s · u · v · yGrupos Nomeados e de Captura + Substituir100% Local • Zero Envios
Testar Expressão Regular
Motor offline prontoEspaço de trabalho 100% privado no navegador • Sem uploads para a nuvem
100% Privado • Sem Upload de Arquivos para Servidor

Por que usar o Testador e Depurador de Regex gratuito do Utiliome?

Criado do zero para privacidade estrita, execução instantânea e sem atrito. Sem assinaturas, paywalls ou cadastro.

Paridade Nativa com ECMA-262 RegExp

Executa diretamente na engine de expressões regulares ECMAScript do seu navegador com alternância instantânea de flags para os modos global (g), case-insensitive (i), multilinha (m), dotAll (s), Unicode (u) e sticky (y).

Inspetor de Capturas Indexadas e Nomeadas

Extrai intervalos de unidades de código UTF-16 baseados em zero [start, end), subcorrespondências numeradas ($1 a $99) e dicionários de capturas nomeadas ((?<name>...)) para cada correspondência em payloads multilinha.

Prévia de Substituição e Retroreferências ao Vivo

Avalia templates de String.prototype.replace e replaceAll em tempo real usando $1, $<name>, $& (correspondência completa), $' (sufixo pós-correspondência) e tokens de escape de cifrão literal $$.

Detecção de ReDoS e Privacidade Zero-Upload

Destaca construções de quantificadores aninhados propensas a backtracking catastrófico enquanto mantém logs de produção sensíveis, bearer tokens e dados pessoais (PII) estritamente na memória local do navegador.

Utiliome vs Alternativas Tradicionais em Nuvem

Compare nosso motor WebAssembly local contra ferramentas de nuvem legadas.

Recurso Utiliome (Navegador Local) Conversores de Nuvem Legados
Paridade Nativa com ECMA-262 RegExp Executa diretamente na engine de expressões regulares ECMAScript do seu navegador com alternância instantânea de flags para os modos global (g), case-insensitive (i), multilinha (m), dotAll (s), Unicode (u) e sticky (y). Opções limitadas sem personalização avançada
Inspetor de Capturas Indexadas e Nomeadas Extrai intervalos de unidades de código UTF-16 baseados em zero [start, end), subcorrespondências numeradas ($1 a $99) e dicionários de capturas nomeadas ((?<name>...)) para cada correspondência em payloads multilinha. Requer ferramentas externas ou ajuste manual
Privacidade e Processamento 100% local no navegador (zero upload para servidor) Envia os dados para servidores externos na nuvem
Preço e Cadastro 100% gratuito para sempre e sem criar conta Exige cadastro de conta ou assinatura paga
Como funciona

Como usar o Testador e Depurador de Regex em 3 passos simples

Nenhuma instalação necessária. Tudo roda diretamente dentro do seu navegador.

1

Insira o Padrão e Alterne as Flags da Engine

Digite o corpo da sua expressão regular sem as barras delimitadoras e habilite as flags exatas do ECMAScript (g, i, m, s, u, y) usadas pelo seu runtime JavaScript ou TypeScript.

2

Cole o Texto de Exemplo e Inspecione as Capturas

Cole strings de teste ou carregue um arquivo de log local para inspecionar os limites de correspondência destacados, intervalos de índices de caracteres, posições de captura numeradas e mapeamentos de grupos (?<name>...).

3

Visualize Substituições e Copie a Expressão

Insira uma string de substituição opcional com referências $1, $<name> ou $& para verificar o texto transformado ao vivo e, em seguida, copie seu literal de regex validado.

Depurando Logs Estruturados com Grupos de Captura Nomeados e Substituições ao Vivo

Resposta Rápida: Combine grupos de captura nomeados ((?<name>...)) com as flags global (g) e multilinha (m) para fazer o parse de linhas de log estruturadas em dicionários chave-valor, verificar offsets exatos de correspondência UTF-16 e pré-visualizar transformações de string com $<name> antes de enviar o código para produção.

Ao depurar expressões regulares em telemetria multilinha ou logs de acesso, erros sutis em âncoras ou quantificadores frequentemente causam falhas silenciosas de correspondência ou deslocamento de grupos numerados. Considere duas linhas de log de aplicação estruturadas contendo timestamps ISO-8601, tags de severidade, identificadores de serviço, trace IDs hexadecimais de 16 caracteres, códigos de status HTTP e latências em ponto flutuante:

2026-11-01T14:22:08.419Z [ERROR] svc=checkout trace_id=4bf92f3577b34da6 status=502 latency_ms=184.7
2026-11-01T14:22:09.004Z [INFO] svc=inventory trace_id=00f067aa0ba902b7 status=200 latency_ms=12.3

Para analisar cada linha de forma determinística sem depender de indexação posicional frágil de arrays, associe cada campo com um grupo de captura nomeado do ECMAScript ((?<name>...)), envolva o sufixo fracionário opcional de milissegundos em um grupo de não captura ((?:...)) e habilite tanto g (iteração global) quanto m (âncoras ^ e $ por linha):

^(?<ts>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[(?<level>ERROR|WARN|INFO)\]\s+svc=(?<service>[a-z0-9_-]+)\s+trace_id=(?<trace>[0-9a-f]{16})\s+status=(?<status>\d{3})\s+latency_ms=(?<ms>\d+(?:\.\d+)?)$

Sem a flag m, ^ e $ ancoram exclusivamente no índice 0 e no final de todo o buffer, fazendo com que a expressão falhe assim que uma quebra de linha (\n) separa os registros. Com gm ativo, o depurador de grupos de captura resolve cada iteração de correspondência tanto em subcorrespondências posicionais baseadas em 1 quanto em um objeto estruturado groups:

{
  "matchIndex": 0,
  "span": [0, 99],
  "fullMatch": "2026-11-01T14:22:08.419Z [ERROR] svc=checkout trace_id=4bf92f3577b34da6 status=502 latency_ms=184.7",
  "captures": [
    "2026-11-01T14:22:08.419Z",
    "ERROR",
    "checkout",
    "4bf92f3577b34da6",
    "502",
    "184.7"
  ],
  "groups": {
    "ts": "2026-11-01T14:22:08.419Z",
    "level": "ERROR",
    "service": "checkout",
    "trace": "4bf92f3577b34da6",
    "status": "502",
    "ms": "184.7"
  }
}

Depois que os limites de captura forem verificados, você pode testar a formatação de String.prototype.replaceAll diretamente no painel de substituição. Fornecer o template [$<level>] $<service>: HTTP $<status> ($<ms>ms, trace=$<trace>) produz uma saída normalizada imediatamente:

[ERROR] checkout: HTTP 502 (184.7ms, trace=4bf92f3577b34da6)
[INFO] inventory: HTTP 200 (12.3ms, trace=00f067aa0ba902b7)

Semântica da Engine RegExp ECMA-262, Mecânica de Flags e Backtracking Catastrófico

Resposta Rápida: As expressões regulares do JavaScript são executadas em um NFA com backtracking definido pela Seção 22.2 do ECMA-262, operando em unidades de código UTF-16 de 16 bits, a menos que a flag u habilite a correspondência completa de valores escalares Unicode. Evitar quantificadores aninhados ambíguos previne travamentos exponenciais O(2^n) de ReDoS.

Execução NFA com Backtracking e Estado em `lastIndex`

Ao contrário de engines puras de Autômatos Finitos Determinísticos (DFA), as engines ECMAScript (V8 Irregexp, JavaScriptCore Yarr, SpiderMonkey) implementam um Autômato Finito Não Determinístico (NFA) com backtracking para suportar retroreferências (\1, \k<name>) e asserções lookaround arbitrárias ((?=...), (?!...), (?<=...), (?<!...)). Alternativas separadas por | são avaliadas da esquerda para a direita; quantificadores gulosos ou greedy (*, +, ?, {m,n}) consomem o máximo de caracteres possível antes de retroceder passo a passo para satisfazer os tokens subsequentes, enquanto quantificadores preguiçosos ou reluctant (*?, +?, ??, {m,n}?) tentam a expansão mais curta primeiro.

Quando g (global) ou y (sticky) está definida, RegExp.prototype.exec() lê e modifica a propriedade lastIndex da instância:

  • Global (g): Pesquisa em ou após lastIndex, avançando lastIndex para o offset final de cada correspondência (ou incrementando em um code point Unicode em correspondências de comprimento zero) e redefinindo para 0 em caso de falha.
  • Sticky (y): Ancora a correspondência estritamente em lastIndex sem avançar na busca. Se nenhuma correspondência começar em lastIndex, a busca falha imediatamente e redefine lastIndex para 0, tornando y ideal para construir analisadores léxicos zero-copy.

Terminadores de Linha, Surrogates UTF-16 e a Flag `u`

O ECMA-262 reconhece exatamente quatro code points terminadores de linha: \n (U+000A), \r (U+000D), Separador de Linha (U+2028) e Separador de Parágrafo (U+2029). Habilitar m faz com que ^ e $ correspondam aos limites adjacentes a esses quatro code points; habilitar s (dotAll) permite que . corresponda a eles.

Por padrão, strings em JavaScript são indexadas como sequências de unidades de código UTF-16 de 16 bits. Caracteres Unicode suplementares acima de U+FFFF (como emojis ou símbolos matemáticos) ocupam um par substituto (surrogate pair) de duas unidades (high surrogate 0xD800–0xDBFF seguido por low surrogate 0xDC00–0xDFFF). Sem u, /^.$/.test("🚀") avalia como false porque "🚀".length é 2. Habilitar u alterna a correspondência para valores escalares Unicode de 21 bits, desbloqueia escapes de propriedades Unicode (\p{Letter}, \p{Script=Latin}, \P{Control}) e desativa escapes de identidade permissivos legados do Anexo B para que escapes inválidos falhem rapidamente em tempo de compilação.

Gramática de Substituição `GetSubstitution` do ECMA-262

A substituição ao vivo segue a tabela padrão GetSubstitution:

  • $$: Insere um único caractere $ literal.
  • $&: Insere a substring correspondente inteira (match[0]).
  • $': Insere a substring após o intervalo correspondente.
  • $n / $nn: Insere a captura numerada n indexada a partir de 1 (1 a 99).
  • $<name>: Insere a string capturada para (?<name>...), ou uma string vazia "" quando o grupo nomeado não participou do ramo de correspondência atual.

Prevenção de Backtracking Catastrófico (ReDoS)

A Negação de Serviço por Expressão Regular (ReDoS) surge quando quantificadores aninhados ou sobrepostos — como (a+)+$, ([a-zA-Z0-9]+\s?)*$ ou (.*a){12} — correspondem a substrings idênticas através de um número exponencial de partições (O(2^n) passos) antes de falhar em um caractere final. Como o ECMA-262 omite quantificadores possessivos (++) e grupos atômicos ((?>...)), proteja seus padrões aplicando:

  1. Conjuntos de Caracteres Mutuamente Exclusivos: Substitua .* gulosos entre delimitadores por classes negadas como [^,\r\n]* para que a engine não consiga atravessar os limites do delimitador.
  2. Desdobramento de Delimitadores: Reescreva ^(\w+-?)+$ (ambíguo quando - está ausente) como ^\w+(?:-\w+)*$, reduzindo a complexidade no pior caso para um tempo estritamente linear O(n).
  3. Emulação Atômica com Lookahead: Onde o backtracking dentro de uma subexpressão deve ser proibido, capture dentro de um lookahead positivo e consuma por meio de uma retroreferência imediata: (?=(\w+))\1.

Testador de Regex vs Gerador de Regex: Qual Você Precisa?

Resposta Rápida: Use o Testador e Depurador de Regex quando você já tiver um padrão e precisar inspecionar offsets de correspondência, depurar grupos de captura nomeados, alternar flags ECMAScript ou testar substituições de string com $<name> contra payloads reais. Use o Gerador de Regex ao montar uma nova expressão visualmente ou exportar código regex multilíngue.

Embora o teste e a síntese pertençam ao mesmo fluxo de trabalho de expressões regulares, eles resolvem problemas de engenharia distintos. O Testador e Depurador de Regex é uma bancada de diagnóstico interativa para inspecionar como um padrão ECMAScript existente se comporta diante de entradas complexas do mundo real. Se, em vez disso, você precisar compor uma nova expressão a partir de blocos visuais, começar de um preset alinhado a RFCs ou exportar código com escape para Python, Go ou Rust, mude para o Gerador de Regex.

Capacidade Testador e Depurador de Regex Gerador de Regex
Tarefa Principal de Engenharia Depurar correspondências, intervalos de captura, flags e substituições em padrões existentes Construir novos padrões visualmente a partir de blocos ou presets RFC verificados
Entrada Inicial Expressão regex bruta, flags ECMAScript e texto de teste ou logs multilinha Blocos de tokens componíveis ou receitas para desenvolvedores (UUID, SemVer, IPv4, ISO-8601)
Depuração de Grupos de Captura Intervalos completos de offset [start, end), posições de array $1–$99 e dicionário (?<name>...) Validação passa/falha com casos de teste positivos e negativos
Substituição de Strings ao Vivo Prévia em tempo real de replace / replaceAll com $1, $<name>, $& e $$ Não focado em templates de transformação de texto
Exportação de Código Multilíngue Literal de regex e saída de padrão para ECMAScript / JavaScript Snippets idiomáticos para JavaScript, Python (re), Go (regexp) e Rust (regex)
Foco na Arquitetura da Engine Semântica nativa NFA com backtracking do ECMA-262 e detecção de ReDoS Portabilidade entre engines para ECMA-262, Python re e RE2 de tempo linear

Fluxo de Trabalho Recomendado

Comece no Gerador de Regex ao estruturar regras de validação para identificadores como versões semânticas, UUIDs RFC 9562 ou slugs de URL em serviços poliglotas. Assim que um padrão for implantado em um frontend ou pipeline Node.js — ou sempre que uma expressão deixar passar inesperadamente um caso de borda em logs de produção —, cole a expressão e a amostra de log bruta aqui no Testador e Depurador de Regex para inspecionar os intervalos de caracteres por correspondência, as interações de flags com lastIndex e os templates de substituição.

Perguntas frequentes

FAQ e Guia Técnico do Testador e Depurador de Regex

Tudo o que você precisa saber sobre o testador de regex online online e gratuito do Utiliome.

Por que uma regex global retorna resultados true e false alternados com RegExp.prototype.test() em JavaScript?

Quando a flag global (g) ou sticky (y) está definida em um objeto RegExp do JavaScript, chamar .test() ou .exec() modifica a propriedade lastIndex da instância para apontar imediatamente após a substring correspondente. A próxima chamada a .test() retoma a varredura a partir de lastIndex em vez do índice 0; assim que atinge o final da string sem outra correspondência, ela retorna false e redefine lastIndex de volta para 0. Para validação booleana sem estado (stateless), omita a flag g ou redefina regex.lastIndex = 0 explicitamente.

Qual é a diferença entre grupos de captura indexados, grupos de não captura e grupos de captura nomeados?

Parênteses padrão (...) armazenam substrings correspondentes em posições de captura sequenciais baseadas em 1 ($1, $2) e no array retornado por exec(). Grupos de não captura (?:...) agrupam tokens para quantificadores ou alternância sem registrar uma subcorrespondência nem deslocar os índices $n subsequentes. Grupos de captura nomeados (?<name>...) preenchem tanto sua posição numerada sequencial quanto match.groups.name (acessível como $<name> em strings de substituição), evitando quebras de índice quando os padrões evoluem.

Quando devo habilitar a flag Unicode (u) em expressões regulares do ECMAScript?

Habilite u sempre que fizer correspondência de texto de usuário não-ASCII, emojis, ideogramas suplementares CJK ou categorias de caracteres Unicode. Sem u, o JavaScript avalia strings como unidades de código UTF-16 de 16 bits, fazendo com que . ou classes negadas como [^x] dividam pares substitutos (surrogate pairs) de 4 bytes acima de U+FFFF em meios-surrogates corrompidos. Ativar u muda a correspondência para code points Unicode completos de 21 bits, habilita escapes de propriedade \p{...} como \p{Letter} e \p{Number}, e impõe validação estrita de sintaxe em escapes não reconhecidos.

Como funcionam os tokens de substituição como $&, $1 e $<name> nas prévias de substituição ao vivo?

As prévias de substituição implementam o algoritmo GetSubstitution do ECMA-262 usado por String.prototype.replace() e replaceAll(). $& insere a substring correspondente inteira, $1 a $99 inserem o grupo de captura numerado correspondente, $<name> insere o texto capturado por (?<name>...), $' insere tudo após a correspondência, o cifrão seguido de crase insere tudo antes da correspondência e $$ produz um caractere $ literal.

O que causa o backtracking catastrófico (ReDoS) e como posso reescrever padrões vulneráveis?

O backtracking catastrófico acontece em engines NFA com backtracking quando quantificadores aninhados ou sobrepostos — como (a+)+b ou ^([a-zA-Z0-9]+\s?)*$ — podem particionar a mesma sequência de entrada de O(2^n) maneiras antes de falhar em um caractere final inesperado. Elimine a ambiguidade substituindo trechos gulosos .* por classes de caracteres negadas ([^,\r\n]*), desdobrando separadores opcionais em ^[a-zA-Z0-9]+(?:\s[a-zA-Z0-9]+)*$ e limitando quantificadores abertos com limites explícitos ({1,64}). Para construir padrões compatíveis com RE2 de tempo linear do zero, use o Gerador de Regex.