Teste expressões regulares online. Analise correspondências, corrija erros e crie padrões eficazes para busca de dados.
Nenhuma correspondência encontrada
Nenhum conteúdo não correspondente
Permite verificar padrões RegExp em tempo real, o que simplifica o desenvolvimento e depuração de padrões de busca complexos.
Permite considerar sensibilidade a maiúsculas/minúsculas, busca global, modo multilinha e outras configurações usadas em linguagens de programação.
Permite criar rapidamente expressões para processamento automático de grandes arrays de texto, logs e código HTML.
Expressões regulares (Regex) são uma linguagem de padrões usada para buscar, validar e processar texto.
Com regex, você pode:
encontrar partes específicas do texto (por exemplo, email, URLs, números)
validar formatos de dados (validação de formulários)
substituir e limpar texto
extrair dados estruturados de strings
Regex é amplamente utilizado em desenvolvimento, análise de dados, SEO e automação.
Esta ferramenta permite testar expressões regulares em tempo real e ver imediatamente os resultados.
Com ela, você pode:
verificar se uma string corresponde a um padrão
visualizar todas as correspondências em um texto
depurar expressões complexas
testar diferentes variações de regex sem escrever código
As expressões regulares não são totalmente universais. O suporte à sintaxe depende da linguagem de programação e do motor utilizado.
Motor | Uso | Características |
|---|---|---|
JavaScript (ECMAScript) | Navegadores, Node.js | Lookbehind limitado (depende da versão) |
PCRE | PHP, várias ferramentas | Um dos motores mais poderosos |
Python (re) | Python | Falta de alguns recursos do PCRE |
Java (Pattern) | Java | Sintaxe rigorosa |
.NET | C# | Recursos avançados |
Sempre teste seu regex no ambiente de destino. Preste atenção às diferenças de suporte a lookbehind e Unicode. Para compatibilidade multiplataforma, prefira padrões mais simples.
Flags são parâmetros que alteram como o padrão é processado. Elas permitem controlar o uso de maiúsculas/minúsculas, o escopo da busca (uma linha ou várias linhas) e a interpretação dos caracteres.
Flag | Significado |
|---|---|
i | Ignorar maiúsculas/minúsculas |
g | Busca global |
m | Modo multilinha |
s | Dotall (inclui \n em .) |
u | Unicode |
Tipo | Símbolo | Descrição |
|---|---|---|
Âncoras (posições) | ^ | Início da string |
Âncoras (posições) | $ | Fim da string |
Âncoras (posições) | \b | Limite de palavra |
Âncoras (posições) | \B | Não é limite de palavra |
Metacaracteres | . | Qualquer caractere, exceto nova linha (\n) |
Metacaracteres | | | Operador OU |
Metacaracteres | \ | Caractere de escape |
Literais | a | Caractere “a” |
Literais | ab | String “ab” |
Quantificadores | * | 0 ou mais repetições |
Quantificadores | ? | 0 ou 1 repetição |
Quantificadores | + | 1 ou mais repetições |
Quantificadores | {5} | Exatamente 5 repetições |
Quantificadores | {5,} | 5 ou mais repetições |
Quantificadores | {5,10} | Entre 5 e 10 repetições |
Classes de caracteres | \s | Espaço em branco |
Classes de caracteres | \S | Não espaço em branco |
Classes de caracteres | \w | Caractere de palavra (alfanumérico + underscore) |
Classes de caracteres | \W | Não caractere de palavra |
Classes de caracteres | \d | Dígito |
Classes de caracteres | \D | Não dígito |
Sequências de escape | [\b] | Backspace |
Sequências de escape | \c | Caractere de controle |
Sequências de escape | \n | Nova linha |
Sequências de escape | \t | Tabulação |
Sequências de escape | \r | Retorno de carro |
Sequências de escape | \ZZZ | Caractere octal |
Sequências de escape | \xZZ | Caractere hexadecimal |
Sequências de escape | \0 | Caractere nulo |
Sequências de escape | \v | Tabulação vertical |
Grupos | (xyz) | Grupo de captura |
Grupos | (?:xyz) | Grupo não capturante |
Conjuntos e intervalos | [xyz] | Qualquer um de x, y, z |
Conjuntos e intervalos | [^xyz] | Qualquer exceto x, y, z |
Conjuntos e intervalos | [a-q] | Intervalo de a a q |
Conjuntos e intervalos | [0-7] | Intervalo de 0 a 7 |
Padrões de substituição | $` | Texto antes da correspondência |
Padrões de substituição | $' | Texto após a correspondência |
Padrões de substituição | $+ | Último grupo capturado |
Padrões de substituição | $& | Correspondência completa |
Padrões de substituição | $n | Grupo capturado (ex: $1, $2) |
Lookarounds | (?=xyz) | Lookahead positivo |
Lookarounds | (?!xyz) | Lookahead negativo |
Lookarounds | (?<=xyz) | Lookbehind positivo |
Lookarounds | (?<!xyz) | Lookbehind negativo |
Comentários | (?#comment) | Comentário (ignorado pelo motor) |
Tarefa | Regex |
|---|---|
Apenas números | ^\d+$ |
Apenas letras latinas | ^[A-Za-z]+$ |
Data (DD.MM.YYYY) | \d{2}\.\d{2}\.\d{4} |
Domínio | ^[a-z0-9.-]+\.[a-z]{2,}$ |
URL | https?:\/\/[^\s]+ |
Slug | ^[a-z0-9-]+$ |
Email (básico) | ^[^\s@]+@[^\s@]+\.[^\s@]+$ |
Email (estrito) | ^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$ |
Telefone | ^\+?\d{7,15}$ |
Tags HTML | <[^>]+> |
Senha forte | ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[\W_]).{12,}$ |
UUID | ^[0-9a-fA-F-]{36}$ |
Cor HEX | ^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$ |
IP (IPv4) | ^(\d{1,3}\.){3}\d{1,3}$ |
Endereço MAC | ^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$ |
Expressões regulares parecem simples, mas possuem muitas nuances.
Falta de escape: . corresponde a qualquer caractere → use \.
Uso incorreto de quantificadores: *, +, {} aplicam-se ao elemento anterior
Confusão entre greedy e lazy: .* é guloso → use .*? para mínimo
Falta de âncoras ^ e $: correspondências podem ocorrer em qualquer parte da string
Sensibilidade a maiúsculas: "Test" ≠ "test" → use flag i
Espaços em branco: \s inclui tabs, quebras de linha etc.
Uso de \w com Unicode: geralmente \w = [A-Za-z0-9_] (sem кирílico, etc.)
Parsing de formatos complexos (HTML, JSON) com regex: pouco confiável → use parsers
Padrões muito complexos: difíceis de manter e depurar
Quantificadores aninhados: ex. (.*)+ pode causar backtracking catastrófico
Padrões sem limite: .* pode degradar o desempenho em textos grandes
Observe que as expressões regulares nesta ferramenta são processadas de acordo com o padrão ECMAScript (JavaScript RegExp). Isso significa que o comportamento dos padrões corresponde a como eles funcionam em um navegador ou código JavaScript. Algumas construções, como escape de caracteres (/ e /), podem se comportar da mesma forma, mesmo que pareçam diferentes. Se você está acostumado com expressões regulares em outras linguagens (por exemplo, Python, PHP, .NET ou POSIX), note que elas podem ter diferenças na sintaxe e lógica de correspondência.
Esta ferramenta permite testar expressões regulares (RegEx) e verificar sua operacionalidade. RegEx é amplamente usado em programação, processamento de dados e análise de SEO.
Com ela, você pode buscar, substituir e analisar padrões de texto, simplificando o trabalho com grandes quantidades de dados.
Expressões regulares (regex) são ferramentas poderosas de correspondência de padrões para pesquisar, validar e manipular texto. Elas são essenciais para validação de dados, operações de busca e tarefas de processamento de texto.
Nosso testador de expressões regulares permite que você insira padrões e strings de teste para ver as correspondências em tempo real. Você pode experimentar diferentes padrões e ver quais partes do seu texto correspondem à expressão.
Padrões comuns incluem validação de e-mail, números de telefone, datas, URLs e códigos postais. Aprenda os metacaracteres básicos como ., *, +, ?, ^, $ e classes de caracteres como \d, \w, \s.
Sinalizadores frequentemente usados incluem i (ignorância de maiúsculas/minúsculas), g (pesquisa global), m (modo multilinha) e u (suporte Unicode). Eles ajudam a controlar a busca e a correspondência com mais precisão.
Padrões complexos com retrocesso podem ser lentos em grandes textos. Otimize sendo específico, evitando quantificadores aninhados e usando âncoras (^ e $) sempre que possível. Teste o desempenho com tamanhos de dados realistas.
Grupos de captura são partes de uma expressão regular (definidas por parênteses) que permitem extrair subseções específicas do texto que correspondem ao padrão. Isso é útil para reformatar ou extrair dados específicos.
Um quantificador 'guloso' (por exemplo, `.*`) tentará corresponder o máximo de caracteres possível. Um quantificador 'preguiçoso' (por exemplo, `.*?`) tentará corresponder o mínimo de caracteres possível. A escolha depende do comportamento de correspondência desejado.
A maioria das implementações modernas de expressões regulares suporta Unicode, permitindo a correspondência de caracteres em diferentes idiomas e alfabetos. No entanto, o suporte exato pode variar entre linguagens de programação e ferramentas.
