Regex Builder: teste expressões regulares visualmente (com uma folha de dicas)

Eu tenho uma confissão que fará puristas regex estremecerem: para os primeiros anos da minha carreira, EU escrevi expressões regulares copy-pasting de Stack Overflow, mudando um personagem, executando o código, vendo-o falhar, e repetindo até que aconteceu de EU ter & #39; t entender os padrões - EU intimidei-os em submissão Foi lento, e pior, os padrões que EU enviei eram frágeis de maneiras que EU podia & #39; t ver.

O que corrigiu isso foi & #39; t lendo a teoria (embora EU eventualmente tenha feito).Foi um testador visual - uma caixa onde EU digito o padrão, uma caixa onde EU colar cordas de teste, e combina que iluminar o instante que EU mudar algo De repente EU poderia ver por que \d+ Agarrei mais do que eu queria ou por que meu padrão de e-mail rejeitou um endereço perfeitamente válido. Regex deixou de ser um jogo de adivinhação e se tornou um ciclo de feedback apertado.

É exatamente isso que o Construtor Regex no Toolz.dev é. Você escreve um padrão, solta dados de teste, alterna sinalizadores e observa as correspondências e grupos capturados destacarem em tempo real. Ele é executado inteiramente no seu navegador, então as linhas de log ou dados do usuário você' estão testando contra nunca são carregados em lugar nenhum. Este guia é a referência regex que eu gostaria que I' tinha naquela época - os padrões que eu realmente reutilizo, uma folha de dicas completa e o único erro que pode derrubar um servidor de produção.

tl;dr: Cole seu padrão e teste as strings no Construtor Regex e alterne o g/i/m Bandeiras para ver o destaque das partidas ao vivo. Comece simples, adicione restrições para eliminar falsos positivos e teste as entradas contraditórias para evitar retrocessos catastróficos. Para dados extraídos, emparelhe-os com o formatador json e conversor de base64. Todos do lado do cliente, todos gratuitos.

O que exatamente é uma expressão regular?

Uma expressão regular - regex ou regexp - é uma cadeia compacta que descreve um padrão de pesquisa Em vez do & quot; encontrar a palavra cat, & quot; poderá dizer & quot; encontrar qualquer número de cinco dígitos, & quot; & quot; encontrar qualquer coisa que pareça um e - mail, & quot; ou & quot; encontrar cada linha que comece com ERROR. & quot; Quase todas as linguagens e editores os suportam, o que torna a habilidade tão portátil: aprenda-a uma vez e você a use em JavaScript, Python, seu grepe seu IDE's Find-and-substituir.

O conceito vem da teoria formal da linguagem dos anos 1950, e Ken Thompson o conectou à computação na década de 1960 para edição de texto. Que a história importa por uma razão prática, voltarei a: "regulares" As linguagens têm limites, e é por isso que o Regex não pode analisar genuinamente estruturas aninhadas como HTML, não importa o quão inteligente você seja.

Onde eu aceito o Regex em uma semana normal: validando a entrada do usuário antes que ele chegue ao banco de dados, retirando campos de linhas de log não estruturadas, fazendo localizar e substituir uma base de código inteira que uma pesquisa simples não pode expressar e filtrar dados durante uma migração. o Construtor Regex É onde eu prototipo cada um deles antes de chegar perto do código real.

Aqui estão os blocos de construção fundamentais - o alfabeto a partir do qual você monta padrões:

Quais padrões regex todo desenvolvedor deve manter à mão?

Esses são os que eu testei, quebrou, consertei e agora mantenho um arquivo de trecho pessoal. Copie-os diretamente para o Construtor Regex E jogue seus próprios estojos de borda neles.

E-mail (o tipo prático)

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Isso combina [email protected] e [email protected]e rejeita @example.com ou user@com. Aqui está a honestidade importante: a gramática do e-mail completo em RFC 5322 é monstruosamente complexo - tecnicamente permite strings citadas e comentários que quase ninguém usa. Don' persegue 100% de conformidade RFC com um regex. Combine os 99% práticos com o padrão acima e confirme se o endereço é real enviando um e-mail de verificação. Esse e#39; é o erro que mais vejo: equipes queimando dias em um & quot;airtight" e-mail regex que ainda pode e#39; t dizer uma caixa de entrada real a partir de um erro de digitação.

URL

^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$

fósfor https://toolz.dev e http://www.example.com/path?query=value; rejeita ftp://... e texto simples.

NÚMERO DE TELEFO

^(\+1)?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$

Flexível o suficiente para 555-123-4567, (555) 123-4567, +1 555.123.4567, e 5551234567.

endereço IPv4

^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

A alternância aninhada é o que impõe que cada octeto permaneça em 0–255, por isso rejeita corretamente 999.999.999.999.

Verificação de senha forte

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$

Requer pelo menos 8 caracteres com letras minúsculas, maiúsculas, dígitos e símbolos. o (?=...) cada lookaheads afirma uma condição sem consumir caracteres - um truque legal que vale a pena entender.

Data ISO (aaaa-mm-dd)

^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$

fósfor 2026-07-11, rejeita 2026-13-01 e 2026-02-32.

cor hexagonal

^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$

fósfor #4466EE, #abc, #000000.

A folha de dicas do regex

Mantenha isso preso. É a referência que mais verifico.

âncoras

quantificadores

Aulas de personagens

Grupos e lookaround

bandeira

Como você constrói e depura um padrão sem perder uma hora?

Meu processo é chato de propósito, porque a chata é repetível:

1. Comece com a coisa mais simples que corresponde a um exemplo real. Não tente lidar com todos os casos de uma vez.
2. Cole as strings de teste positivas e negativas no Construtor Regex- coisas que deveriam corresponder e coisas que não deveriam.
3. Aperte para matar falsos positivos. Adicionar âncoras (^, $) para que o padrão corresponda a toda a string e troque . Para classes específicas, como [a-z] ou [^,].
4. Jogue uma entrada contraditória nele- strings vazias, entradas enormes, Unicode e caracteres regex literais como dados.
5. Só então otimizar.

Quando algo se comporta mal, é quase sempre uma das três coisas. se isso Combina demais, seus quantificadores são gananciosos - torná-los preguiçosos (*?) ou suas aulas mais específicas. se isso Combina muito pouco, provavelmente você precisa do i Bandeira ou esqueci de escapar de um personagem especial. se isso não corresponde a absolutamente nada, verifique se há metacaracteres sem escapamento (., *, +, (, [, {, etc.) destinado a ser literal ou personagens invisíveis, como guias ocultas em sua string de teste.

O que é um retrocesso catastrófico e por que você deveria temer isso?

Esta é a seção que eu tatuaria em novos desenvolvedores, se pudesse. No início, enviei um regex de validação de entrada que parecia completamente inocente, e uma tarde uma única solicitação atrelou um núcleo de CPU a 100% e permaneceu lá. O padrão era o problema.

Quando um mecanismo Regex não consegue encontrar uma correspondência, ele retrocessos- recua e tenta outras formas de satisfazer o padrão Certas formas fazem explodir exponencialmente o número de caminhos O exemplo do livro didático:

^(a+)+$

Alimente uma entrada como aaaaaaaaaaaaaaaaaaaab (uma corrida de a terminando em um b), e os quantificadores aninhados dão ao motor um número astronômico de maneiras de dividir o as, tudo o que ele tenta antes de concluir o "nenhuma correspondência." Seu aplicativo congela. Esta é uma verdadeira classe de negação de serviço chamada refaz (negação de serviço regular da expressão), e os invasores a exploram.

Como se manter seguro:

1. Nunca aninhar quantificadores. (a+)+, (a*)*, e (a+)* são bandeiras vermelhas.
2. Use grupos atômicos ou quantificadores possessivos Onde o motor os suporta: (?>a+) ou a++.
3. Seja específico. [a-z]+ retrocede menos do que .+ Porque tem menos caminhos para explorar.
4. Ancore seus padrões Portanto, o motor falha rapidamente em entradas que não combinam.
5. Teste com strings que quase combinam, mas falham no final- isso e #39; é o pior caso para retrocesso.

Se você estiver em movimento, esse problema simplesmente não existe, o que me leva à próxima seção.

Como o regex difere entre os idiomas?

A sintaxe central viaja bem, mas os detalhes mordem. Essas são as diferenças que eu realmente tropecei.

Javascript:

const regex = /\d{3}-\d{4}/g;
const pattern = new RegExp('\\d{3}-\\d{4}', 'g'); // note the doubled backslashes
'555-1234'.match(regex);              // ["555-1234"]
const m = '2026-07-11'.match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/);
m.groups.year;                        // "2026"

Cuidado: Lookbehind só chegou no ES2018, \d Corresponde apenas aos dígitos ASCII e o g bandeira faz .test() com estado lastIndex- uma fonte sutil de bugs em loops.

Python:

import re
pattern = re.compile(r'\d{3}-\d{4}')      # raw strings avoid double-escaping
pattern.findall('Call 555-1234 or 555-5678')  # ['555-1234', '555-5678']

Sempre use strings cruas (r'...'). lembrar re.match apenas âncoras no início - use re.search encontrar em qualquer lugar. e re.VERBOSE Permite escrever padrões comentados com várias linhas, que salvam vidas complexas.

PHP: Padrões precisam de delimitadores ('/\d{3}-\d{4}/'), ele usa o poderoso motor PCRE e preg_match retornos 1, 0, ou false no erro - então verifique com ===.

VAI: Usa o motor RE2, que deliberadamente DROPS lookaheads, lookbehinds e backreferences em troca de uma garantia de correspondência de tempo linear. Isso significa que nenhum retrocesso catastrófico é possível - uma compensação genuinamente diferente que vale a pena conhecer quando você escolhe um idioma para correspondência de entrada não confiável.

Um exemplo real: analisando uma linha de log do Apache

Aqui está o tipo de coisa que o Regex é genuinamente ótimo. Uma linha padrão de log de acesso Apache se parece com:

192.168.1.1 - frank [11/Jul/2026:10:27:10 -0500] "GET /api/users HTTP/1.1" 200 1234

Este padrão o separa:

^(\S+) \S+ (\S+) \[([^\]]+)\] "(\S+) (\S+) (\S+)" (\d{3}) (\d+)$

Cole ambos no Construtor Regex E cada grupo capturado se ilumina separadamente:

Uma vez que os grupos se alinham no testador, traduzindo-o para um re.findall em python ou um match() em JavaScript é trivial - e você já sabe que funciona.

Perguntas frequentes

O que é um construtor Regex?

Um Regex Builder é uma ferramenta interativa onde você digita uma expressão regular e imediatamente a vê compatibilizado com as strings de teste, com correspondências e grupos capturados destacados. Ele substitui o loop lento write-run-fail-rewrite em seu código por um ativo. o Construtor Regex No Toolz.dev faz isso inteiramente no seu navegador, então os dados de teste permanecem em sua máquina.

Os padrões regex são idênticos em todas as linguagens de programação?

A sintaxe principal é quase idêntica, mas os detalhes são suficientes para causar bugs. O JavaScript mais antigo não tinha look Behind, o mecanismo RE2 do GO não tem lookaheads ou referências indiretas, e os nomes de Python em grupos com (?P<name>...) Em alguns contextos. Sempre confirme um padrão na linguagem que você está realmente direcionando, em vez de assumir a portabilidade.

Como faço para validar um endereço de e-mail com o Regex?

Use um padrão prático como ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$, que lida com a grande maioria dos endereços reais Não tente a conformidade RFC 5322 completa em um regex - a gramática é muito complexa e você & #39; ainda rejeitará endereços válidos ou aceitará erros de digitação. Combine o regex com um e-mail de verificação para confirmar que a caixa de entrada realmente existe.

Por que meu regex congela o aplicativo?

Quase sempre retrocesso catastrófico. Padrões com quantificadores aninhados como (a+)+ Crie um número exponencial de caminhos correspondentes quando eles se encontrarem com entradas que quase correspondem, mas que falharão, e o mecanismo tenta todos eles. Remova os quantificadores aninhados, prefira classes de personagens específicas a .+, e adicione âncoras para que o motor possa falhar rapidamente.

Posso usar regex para analisar HTML ou JSON?

Não, não para nada além da extração trivial HTML e JSON não são linguagens regulares - eles permitem aninhamento arbitrário que regex fundamentalmente não pode rastrear Use um analisador real: DOMParser ou Cheerio para HTML, e JSON.parse Ou uma ferramenta JSON para JSON. Regex é a ferramenta errada que a estrutura do momento aninha.

Qual é a diferença entre ganância e combinar preguiçoso?

Quantificadores gananciosos (*, +, ?) Pegue o máximo possível e volte atrás, se necessário; preguiçosos (*?, +?, ??) Pegue o mínimo possível e expanda apenas se for forçado. contra <b>bold</b>, ganancioso <.*> Engole a corda inteira enquanto preguiçoso <.*?> pára no primeiro <b>. Escolher o certo geralmente é a solução quando um padrão combina demais.

Como faço para escapar de caracteres especiais no regex?

Coloque uma barra invertida na frente de qualquer metacaractere que você quer dizer literalmente: \., \*, \+, \?, \(, \), \[, \], \{, \}, \^, \$, \|, e \\. A maioria dos idiomas também oferece um ajudante para escapar de uma corda inteira para você - re.escape() em Python, por exemplo - o que é mais seguro do que escapar manualmente quando a string vem da entrada do usuário.

O que significam as bandeiras regex g, i e m?

g (global) encontra cada partida em vez de parar no primeiro, i (Ignorar Case) torna o padrão insensível à maiúsculas e minúsculas m (multilina) faz ^ e $ Combine a cada quebra de linha em vez de apenas o início e o fim da string. Eles se combinam livremente, então gim Faz todos os três. A Freqüente Gotcha em JavaScript: reutilizando um g Regex em todas as chamadas é transportado lastIndex entre eles, o que faz test() alternar verdadeiro e falso - recrie o padrão ou reinicie lastIndex.

O que é um lookahead no regex?

Um lookahead afirma que algo não segue ou não se segue, sem consumi-lo. foo(?=bar) fósfor foo Somente quando bar vem a seguir; foo(?!bar) Corresponde somente quando não. Olhe por trás ((?<=...), (?<!...)) faz o mesmo ao contrário, e aterrissou em JavaScript moderno, Python e PCRE - mas não em Go' s RE2, que rejeita ambos de imediato As regras de senha são o uso clássico: ^(?=.*\d)(?=.*[a-z]).{8,}$ Empilha as afirmações para que cada requisito seja verificado independentemente na mesma posição.

Como faço para combinar um número de telefone com regex?

Para um formato específico, seja explícito e não inteligente: ^\(\d{3}\) \d{3}-\d{4}$ fósfor (555) 123-4567. Para tolerar separadores variados, permita os opcionais como ^\+?1?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$. A numeração dos telefones é confusa entre os países, portanto, valide apenas o formato que você realmente aceita e normalize para dígitos antes de armazenar - construa e teste o padrão ao vivo antes de confiar nele.

Embrulhando

O Regex passou da minha habilidade mais temida para uma das mais usadas no momento em que comecei a construir padrões em um testador ao vivo, em vez de adivinhar em meu editor. Comece simples, teste contra entradas reais e contraditórias, respeite o retrocesso catastrófico e mantenha uma biblioteca pessoal de padrões em que você confia.

o Construtor Regex no Toolz.dev faz esse loop rápido, com correspondência em tempo real, destaque de grupo e alternâncias de sinalizador - tudo em execução no seu navegador para que seus dados de teste permaneçam privados Quando seu padrão extrai JSON, entregue-o ao formatador json; quando ele captura um blob de base64, decodifique-o com o conversor de base64. Ou navegue por todas as mais de 600 ferramentas gratuitas em Toolz.dev.