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.
Nossa equipe valida a saída do regex contra a especificação ECMA-262, o comportamento RegExp do Node.js e testes de paridade entre engines no V8 / JavaScriptCore / SpiderMonkey. O orçamento ReDoS é calibrado contra os padrões de pior caso documentados nos corpora de regex-DoS da Snort e da OWASP.
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. (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2}) corresponde a uma data ISO e nomeia cada parte. Expressões regulares são a espinha dorsal do localizar-e-substituir em cada editor de código, da validação em cada formulário, da análise de logs em cada stack de observabilidade e de grep, sed e awk — as ferramentas Unix em que metade da internet roda. Elas também são notoriamente difíceis de escrever corretamente: um quantificador errado por um ou um escape faltando pode corresponder à substring errada, perder uma correspondência inteiramente ou — no pior caso — disparar retrocesso catastrófico que toma um núcleo de CPU como refém. Um bom testador regex captura cada um desses modos de falha antes que cheguem em produção.
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 (?<name>...)), asserções lookahead e lookbehind ((?=...), (?!...), (?<=...), (?<!...)), as sete flags canônicas (g, i, m, s, u, y, d), escapes de propriedade Unicode (\p{Letter}, \p{Script=Han}) sob /u e escapes de caracteres no estilo \d. Padrões que você valida aqui colam direto na sua codebase e funcionam inalterados. Se você está portando de PCRE, Python ou Java, o explicador quebra cada token para você identificar sintaxe que não traduz (grupos atômicos, quantificadores possessivos, modificadores inline).
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 / $& / $` / $' / $$ / $<name> — exatamente o que o String.replace do JavaScript aceita. A aba Dividir aplica String.split com o regex e mostra cada parte. A aba Explicar tokeniza o padrão e anota cada pedaço em português claro, útil para revisão de código, ensino e portabilidade entre dialetos.
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 $<name> para que você leia os dados do mesmo jeito que vai consumi-los no código.
Prévia de Substituição ao Vivo com $1 / $& / $<name>
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, $<name> para nomeado, $& para a correspondência inteira, $` e $' para prefixo/sufixo, $$ para um cifrão literal. Painéis de entrada e saída lado a lado com cópia em um clique.
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 $<year>, $<month>, $<day>. Mude para a aba Substituir e tente $<day>/$<month>/$<year> para reformatar datas ISO para o formato DMA em uma única passagem — o mesmo truque funciona em qualquer chamada replace JS moderna.
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 $<name> são todos suportados — exatamente o alfabeto de substituição da especificação ECMAScript, então o que você copiar daqui roda inalterado em qualquer engine JS.
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 $<name>).
- 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 <a> e <b> captura <a> e <b>, não <a>. 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 --replaceougrep -oEdepois. - 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: truee 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 $<name> manualmente em vez de delegar paraString.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
literalcom 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;patterncorresponde em qualquer lugar. A escolha errada é o bug mais comum em validação de formulário:^faltando deixa umattacker.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
\wtratam 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
(?<year>\d{4})-(?<month>\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 $<name> 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?
new RegExp(pattern, flags) em qualquer navegador, Node.js, Deno ou Bun. Isso significa que os recursos suportados são: grupos de captura (numerados + nomeados com (?<name>...)), lookaheads (?=...) e (?!...), lookbehinds (?<=...) e (?<!...), as sete flags g/i/m/s/u/y/d, escapes de propriedade Unicode (\p{Letter}) sob /u e retro-referências \1..\9. Recursos exclusivos do PCRE como grupos atômicos (?>...), quantificadores possessivos a++, condicionais (?(1)yes|no) e modificadores inline (?i) vão lançar um erro de sintaxe. O re.VERBOSE do Python não é suportado aqui. Para regex de Python/Java/Go, porte o padrão de volta para sua engine nativa — a maioria dos padrões simples transfere inalterada, e o explicador aqui é neutro em relação ao sabor. O que cada uma das flags g, i, m, s, u, y, d faz?
.indices e .indices.groups com pares [início, fim] para cada captura; este testador usa /d por baixo dos panos para desenhar as fronteiras dos grupos. Alterne-as como chips acima do texto de teste; o literal canônico /pattern/flags é mostrado no leitor. Como escrevo grupos de captura e como me refiro a eles depois?
(\d{4})-(\d{2})-(\d{2}) te dá três grupos posicionais, acessíveis como $1, $2, $3 em substituições ou como m.groups[0..2] no painel Correspondências. Use (?<name>...) para grupos nomeados: (?<year>\d{4})-(?<month>\d{2}) te permite escrever $<year>/$<month> no modelo de substituição. Use (?:...) para um grupo não-capturador quando você só precisa de agrupamento para um quantificador ((?:foo|bar)+) — isso não cria retro-referência, o que mantém seus $1..$N numerados estáveis. Dentro do mesmo padrão, refira-se a uma captura anterior com \1, \2 etc. — útil para achar palavras duplicadas como \b(\w+)\s+\1\b. Como funcionam lookahead e lookbehind e para que servem?
(?=foo) (lookahead positivo) tem sucesso se foo segue a posição atual; (?!foo) (lookahead negativo) tem sucesso se foo NÃO segue. (?<=foo) e (?<!foo) são as contrapartes lookbehind. Usos práticos: extrair uma substring sem incluir seu entorno ((?<=\$)\d+ corresponde aos dígitos depois de um cifrão, mas $ não faz parte da correspondência), validar com múltiplas restrições em um padrão ((?=.*[A-Z])(?=.*\d).{8,} exige pelo menos uma maiúscula, um dígito e 8 caracteres) e proibir ocorrências (^(?!.*\bpassword\b) rejeita qualquer linha contendo a palavra password). O ECMA-262 moderno suporta lookbehind de comprimento variável, então (?<=^prefix-?) funciona. Por que meu regex trava o navegador e o que é retrocesso catastrófico?
(a+)+, (a|aa)+, (\w*)* ou (?:a|a?)+. Em uma entrada onde a correspondência pode falhar no último caractere, a engine tenta um número exponencial de divisões de grupo antes de desistir. Em aaaaaaaaaaaaaaaaaaaaab com o padrão (a+)+b, isso são 2^21 ≈ 2 milhões de retrocessos antes da resposta. Este testador envolve toda chamada de correspondência em um orçamento de tempo real de 250ms — se o orçamento for excedido, a iteração para e você vê um aviso Padrão expirou. Correções: ancore o padrão em suas fronteiras (^...$), prefira alternativas sem sobreposição ((a|b) em vez de (a|aa)), desenrole quantificadores aninhados (a+ em vez de (a+)+) ou reescreva para usar expressões idiomáticas tipo possessivas ((?=(a+))\1 simula a++ em JS). Qual a diferença entre este testador regex e o regex101.com?
Como faço escape de caracteres especiais como . | ( ) [ ] { } * + ? ^ $ \?
\., \|, \(, \), \[, \], \{, \}, \*, \+, \?, \^, \$, \\. A barra / não precisa de escape em um padrão passado como string (apenas em literais de regex JS entre as barras). Dentro de uma classe de caracteres [...] a maioria dos metacaracteres perde seu significado especial, então [.], [*], [+] todos correspondem a um caractere literal — os únicos metacaracteres que permanecem especiais são ], \, ^ (só no início para negar) e - (intervalo quando entre dois caracteres). Em caso de dúvida, cole o texto literal no padrão e rode o explicador: cada sequência de escape recebe uma descrição de uma linha no painel de quebra. Posso compartilhar um regex com um colega via link?
#p=...&f=gim&t=...&tab=match). Qualquer pessoa que abrir o link hidrata a página com o mesmo estado — localmente na máquina dela. Como os dados ficam no fragmento de hash, eles nunca são enviados para o servidor go-tools.org (navegadores não transmitem fragmentos em requisições) e não são registrados em nossos logs de acesso. O comprimento do link cresce com o tamanho do texto, então para amostras >2KB copie o regex via Copiar /pattern/flags e cole o texto separadamente. Para revisão colaborativa de regex sem compartilhar o texto real, compartilhe apenas o padrão e as flags — o destinatário cola o próprio corpus e obtém as mesmas correspondências. O testador suporta Unicode, emoji e scripts não-latinos?
\p{Letter} corresponde a cada letra em cada script, \p{Script=Han} corresponde a ideogramas chineses, \p{Emoji} corresponde a emoji, \p{Number} corresponde a cada dígito/numeral. Sem /u, emojis de par substituto como 👨💻 são vistos como duas unidades de código UTF-16 e padrões como ^.$ vão falhar em correspondê-los; com /u o ponto trata cada ponto de código grafema como um caractere. Para scripts RTL (árabe, hebraico), os padrões funcionam sem tratamento especial — direção é uma preocupação de tempo de renderização, não da engine de regex. Conteúdo CJK corresponde da mesma forma que o latino. Qual a diferença entre .match, .matchAll, .replace e .split com um regex?
Por que meu regex Python ou Java não funciona aqui?
(?i) e (?x) do Python não são válidas em JS — use os chips de flag acima. (2) \A e \Z do Python são ^ e $ em JS (com /m para âncoras de linha). (3) Condicionais Java/Python (?(name)yes|no) não são suportados em JS — reescreva com uma alternância. (4) Quantificadores possessivos a++ e grupos atômicos (?>...) não estão disponíveis em JS — simule com (?=(a+))\1. (5) (?P<name>...) do Python é (?<name>...) em JS. (6) \h para espaço em branco horizontal e \v para vertical não existem em JS — use [ \t] e [\n\r]. Para uma porta portátil, o explicador detalha o que cada token faz para você poder trocar a sintaxe não suportada por uma equivalente. Existe um tamanho máximo de texto ou contagem de correspondências?
grep -oE ou rg (ripgrep) — eles fazem streaming e não vão atingir um teto de renderização de UI. Para varreduras únicas de texto enorme, cole uma fatia representativa neste testador para validar o padrão, depois rode o padrão validado contra o arquivo completo no seu shell. Ferramentas relacionadas
Ver todas as ferramentas →Conversor de Maiúsculas — UPPER, lower, camelCase
Processamento de Texto
Converta texto entre UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE e mais 6 formatos instantaneamente. Grátis, no navegador, sem cadastro.
Gerador de Lorem Ipsum — Texto de Preenchimento
Processamento de Texto
Gere texto de preenchimento Lorem Ipsum na hora — por parágrafo, frase, palavra, byte ou lista. Copie ou baixe como texto puro, HTML, Markdown ou JSON. 100% grátis e privado, no navegador. Sem cadastro.
Remover linhas duplicadas de texto
Processamento de Texto
Remova linhas duplicadas de texto online — grátis, instantâneo, 100% no navegador. Ignore maiúsculas ou espaços, mantenha a primeira ou última ocorrência e veja quantas duplicatas foram removidas. Sem cadastro.
Gerador de Slug de URL — Slugify de Texto
Processamento de Texto
Transforme qualquer título em um slug de URL limpo e otimizado para SEO instantaneamente. Translitera acentos e cirílico ou mantém letras Unicode. 100% privado, no navegador.
Ordenar linhas de texto: alfabética e natural
Processamento de Texto
Ordene linhas de texto por ordem alfabética, numérica (ordem natural) ou por comprimento — crescente ou decrescente. Grátis, 100% no navegador. Também remova duplicatas, inverta e limpe listas. Sem cadastro.
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.