Gerador de Padrões Regex

Construa expressões regulares visualmente com blocos de tokens e receitas RFC verificadas.

Sem uploadsSem cadastroResultados instantâneos
13 Modelos RFC e Dev VerificadosConstrutor Visual de Regras e QuantificadoresSnippets JS · Python · Go · Rust
Gerar Regex
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 Gerador de Padrões Regex gratuito do Utiliome?

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

Blocos Visuais de Tokens Componíveis

Construa expressões regulares legíveis passo a passo encadeando âncoras, classes de caracteres, quantificadores limitados, grupos de não captura ((?:...)) e capturas nomeadas ((?<name>...)).

Receitas para Desenvolvedores Alinhadas a RFCs

Carregue predefinições verificadas para e-mails práticos segundo a RFC 5322, endereços IPv4/IPv6 limitados, timestamps ISO-8601 / RFC 3339, tags SemVer 2.0.0, UUIDs da RFC 9562, URLs, slugs de URL e cores hexadecimais CSS.

Snippets de Código Multilíngue

Exporte código pronto para compilar em JavaScript (RegExp), Python (re.compile com raw strings), Go (regexp.MustCompile com literais brutos) e Rust (regex::Regex), adaptando a sintaxe de grupos nomeados automaticamente.

Validação Instantânea de Casos de Teste e Privacidade

Verifique strings de amostra positivas e negativas ao vivo enquanto ajusta os blocos. Cada personalização de receita, validação e exportação de código roda 100% no cliente, sem chamadas de rede.

Utiliome vs Alternativas Tradicionais em Nuvem

Compare nosso motor WebAssembly local contra ferramentas de nuvem legadas.

Recurso Utiliome (Navegador Local) Conversores de Nuvem Legados
Blocos Visuais de Tokens Componíveis Construa expressões regulares legíveis passo a passo encadeando âncoras, classes de caracteres, quantificadores limitados, grupos de não captura ((?:...)) e capturas nomeadas ((?<name>...)). Opções limitadas sem personalização avançada
Receitas para Desenvolvedores Alinhadas a RFCs Carregue predefinições verificadas para e-mails práticos segundo a RFC 5322, endereços IPv4/IPv6 limitados, timestamps ISO-8601 / RFC 3339, tags SemVer 2.0.0, UUIDs da RFC 9562, URLs, slugs de URL e cores hexadecimais CSS. 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 Gerador de Padrões Regex em 3 passos simples

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

1

Selecione uma Receita Verificada ou Adicione Blocos de Tokens

Escolha uma predefinição testada segundo RFCs (e-mail, IPv4/IPv6, data ISO-8601, SemVer, UUID, URL, slug ou cor hexadecimal) ou anexe âncoras, conjuntos de caracteres, literais e quantificadores visualmente.

2

Configure Âncoras, Grupos e Strings de Teste

Alterne entre validação exata de string (^...$) e correspondência de substrings, atribua agrupamentos nomeados ((?<name>...)) ou de não captura ((?:...)), e verifique casos de teste positivos e negativos.

3

Copie a Regex Bruta ou o Código Multilíngue

Exporte o padrão bruto ou copie snippets idiomáticos em JavaScript, Python, Go ou Rust com escape de raw strings e sintaxe de captura específica de cada motor aplicados.

Compondo um Padrão de Produção a Partir de Blocos Visuais até Código Multilíngue

Resposta Rápida: Encadeie blocos de tokens ancorados sequencialmente, atribua nomes semânticos aos campos via grupos de captura nomeados ((?<name>...)), valide contra casos de teste positivos e negativos de casos extremos (edge cases) e exporte snippets idiomáticos de raw strings adaptados para JavaScript, Python, Go e Rust.

Escrever expressões regulares densas manualmente e de cabeça frequentemente introduz defeitos sutis — como pontos sem escape (. correspondendo a qualquer caractere em vez do ponto literal .), ausência de âncoras de início/fim ou bugs de zero à esquerda. Usando a composição visual de tokens, suponha que você precise de um validador estrito de Versionamento Semântico 2.0.0 (SemVer) que aceite um prefixo opcional v e extraia os identificadores de metadados major, minor, patch, prerelease e build.

Cada regra estrutural mapeia de forma limpa para uma sequência explícita de blocos de tokens:

{
  "anchoring": "exact_line (^...$)",
  "blocks": [
    { "type": "literal", "value": "v", "quantifier": "optional (?)" },
    { "type": "named_capture", "name": "major", "pattern": "0|[1-9]\\d*" },
    { "type": "literal", "value": "." },
    { "type": "named_capture", "name": "minor", "pattern": "0|[1-9]\\d*" },
    { "type": "literal", "value": "." },
    { "type": "named_capture", "name": "patch", "pattern": "0|[1-9]\\d*" },
    {
      "type": "non_capturing",
      "pattern": "-(?<prerelease>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)",
      "quantifier": "optional (?)"
    },
    {
      "type": "non_capturing",
      "pattern": "\\+(?<build>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)",
      "quantifier": "optional (?)"
    }
  ]
}

Observe como 0|[1-9]\d* aplica a Seção 2 do SemVer 2.0.0 permitindo 0 enquanto rejeita zeros à esquerda como 01, e como os agrupamentos de não captura (?:...)? protegem os delimitadores - e + sem criar grupos numerados extras. Validar contra casos de teste positivos e negativos e exportar código multilíngue produz declarações precisas para cada motor automaticamente:

# Padrão sintetizado para ECMAScript / Rust
^v?(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$

# Casos de teste positivos (Correspondem)
1.0.0
v2.14.3-rc.1+build.5114f85

# Casos de teste negativos (Rejeitados: zero à esquerda no núcleo numérico da versão)
v01.2.0
1.02.3

# Python (raw string re.compile + sintaxe de grupo nomeado (?P<name>...))
SEMVER_RE = re.compile(r"^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?P<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$")

# Go (literal bruto com crases RE2 regexp.MustCompile + sintaxe (?P<name>...))
var semverRe = regexp.MustCompile(`^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?P<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$`)

Como o gerador evita retroreferências (backreferences) e lookarounds nas receitas padrão, a expressão exportada compila sem modificações tanto em motores RE2 de tempo linear (Go e Rust) quanto em motores baseados em backtracking (JavaScript e Python).

Portabilidade entre Motores Regex, Nuances de Validação RFC e Regras de Escape

Resposta Rápida: Os motores de expressões regulares dividem-se em NFAs com backtracking (JavaScript RegExp, Python re) e motores NFA de Thompson / DFA de tempo linear (Go regexp, Rust regex). Padrões portáveis evitam lookarounds e retroreferências, usam literais de raw string nativos e aplicam limites exatos de octetos e nibbles segundo as RFCs.

NFAs com Backtracking vs Autômatos de Tempo Linear (Go RE2 e Rust `regex`)

Os motores de expressões regulares em produção dividem-se em dois modelos de execução distintos:

  1. NFA com Backtracking (JavaScript RegExp, Python re): Explora ramificações de alternância recursivamente, permitindo retroreferências (\1, \k<name>) e asserções arbitrárias de lookahead/lookbehind ((?=...), (?!...), (?<=...), (?<!...)), ao custo de um potencial tempo de execução exponencial no pior caso em padrões ambíguos.
  2. NFA de Thompson / DFA Preguiçoso (Go regexp, Rust regex): Avança todos os estados ativos do autômato simultaneamente para cada byte ou ponto de código de entrada, garantindo complexidade de tempo O(m * n) no pior caso em função do tamanho do padrão m e do comprimento da entrada n. Para preservar limites finitos de estado, Go regexp e Rust regex excluem retroreferências e lookarounds por design.

A sintaxe de grupos de captura nomeados também varia conforme a biblioteca padrão: ECMAScript exige (?<name>...); Python re e Go regexp exigem (?P<name>...); Rust regex (1.9+) aceita tanto (?<name>...) quanto (?P<name>...).

Escape de Raw Strings na Linguagem Hospedeira

Incorporar um padrão dentro de uma string comum entre aspas duplas faz com que o compilador da linguagem hospedeira interprete os escapes de barra invertida primeiro, forçando \d+\.\d+ a ser duplicado como "\\d+\\.\\d+" e correndo o risco de corrupção silenciosa (por exemplo, "\b" transformando-se no caractere ASCII 0x08 de backspace em vez de uma fronteira de palavra). Os snippets exportados utilizam a forma literal de raw string nativa de cada linguagem:

  • JavaScript: Notação literal /padrão/flags (escapando apenas barras normais não escapadas como \/), ou new RegExp(String.raw..., flags) para construção dinâmica.
  • Python: Literais de raw string re.compile(r"...") (note que uma raw string em Python não pode terminar com um número ímpar de barras invertidas).
  • Go: regexp.MustCompile com literais brutos entre crases (backticks), substituindo \x60 caso um caractere de crase literal precise ser correspondido.
  • Rust: regex::Regex::new(r"...") ou literais brutos com cerquilhas r#"..."# quando o próprio padrão contém aspas duplas.

Limites de Precisão RFC em Receitas para Desenvolvedores

  • IPv4 e IPv6 (RFC 4291 / RFC 5952): Um padrão ingênuo como \d{1,3}(?:\.\d{1,3}){3} aceita octetos ilegais até 999. A validação estrita de IPv4 limita cada octeto decimal via (?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d), enquanto as receitas de IPv6 contemplam a compressão de zeros :: de ocorrência única e sufixos mapeados para IPv4 (::ffff:192.0.2.128).
  • UUIDs (RFC 9562, substituindo a RFC 4122): O formato hexadecimal canônico 8-4-4-4-12 ^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$ restringe o nibble de versão (1–8, cobrindo UUIDv7 e UUIDv8) e os bits de variante IETF (8, 9, a, b), com uma flexibilização opcional para os valores sentinela Nil (00000000-...) e Max (ffffffff-...).
  • Datas ISO-8601 / RFC 3339 e E-mails Práticos: Expressões léxicas impõem meses limitados (0[1-9]|1[0-2]), dias (0[1-9]|[12]\d|3[01]), horas ([01]\d|2[0-3]) e deslocamentos de fuso horário (Z|[+-](?:[01]\d|2[0-3]):[0-5]\d), deixando a aritmética de anos bissextos do calendário (como rejeitar 30 de fevereiro) e a verificação da caixa postal SMTP para a lógica de parsing posterior.

Gerador de Padrões Regex vs Testador e Depurador de Regex: Qual Você Precisa?

Resposta Rápida: Use o Gerador de Padrões Regex ao construir uma nova expressão regular visualmente a partir de blocos de tokens, personalizar uma predefinição RFC verificada ou exportar código escapado para JavaScript, Python, Go e Rust. Use o Testador e Depurador de Regex ao inspecionar deslocamentos de correspondência (offsets), dicionários de captura e substituições de strings ao vivo.

Escolher entre as duas ferramentas depende se você está criando uma expressão ou diagnosticando uma. O Gerador de Padrões Regex foca na síntese estruturada, personalização de receitas RFC e geração de código multilíngue. Assim que você tiver uma expressão e precisar inspecionar cada posição de correspondência em um payload de múltiplas linhas, alternar flags ECMAScript com estado ou visualizar substituições de strings com $<name>, abra o Testador e Depurador de Regex.

Capacidade Gerador de Padrões Regex Testador e Depurador de Regex
Tarefa Principal de Engenharia Construir novos padrões visualmente ou personalizar receitas RFC verificadas Depurar padrões existentes, posições de correspondência, flags e substituições
Montagem de Padrões Blocos de tokens componíveis (âncoras, classes, quantificadores, grupos nomeados) Edição direta e livre de expressões regulares
Biblioteca de Receitas Verificadas Predefinições integradas para E-mail, IPv4/IPv6, ISO-8601, SemVer, UUID, URL, Slug, Hex Focado em padrões arbitrários fornecidos pelo usuário e payloads de logs
Exportação de Código Multilíngue Snippets prontos para copiar em JavaScript, Python, Go e Rust Saída de literal regex para JavaScript / ECMAScript
Inspeção de Capturas e Posições Validação instantânea de casos de teste positivos e negativos Intervalos [start, end) por correspondência, capturas $1–$99 e dicionário (?<name>...)
Prévia de Substituição ao Vivo Não projetado para prévias de substituição de strings Prévia em tempo real de replace / replaceAll ($1, $<name>, $&, $$)

Fluxo de Trabalho Recomendado

Monte sua expressão base ou carregue uma predefinição RFC aqui no Gerador de Padrões Regex para obter uma estrutura de agrupamento limpa, limites de quantificadores em tempo linear e código base devidamente escapado para sua linguagem de backend ou frontend. Quando precisar testar como esse padrão interage com arquivos de log de múltiplas linhas, estado de lastIndex, pares substitutos Unicode ou templates de replaceAll, envie o padrão para o Testador e Depurador de Regex.

Perguntas frequentes

FAQ e Guia Técnico do Gerador de Padrões Regex

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

Por que a sintaxe da regex gerada difere entre JavaScript, Python, Go e Rust?

Embora as classes de caracteres principais e os quantificadores coincidam entre as linguagens, a sintaxe de captura nomeada e as restrições do autômato divergem. O JavaScript exige (?<name>...), enquanto o módulo re do Python e o pacote regexp do Go exigem (?P<name>...) (o crate regex do Rust suporta ambas as formas). Além disso, Go e Rust compilam padrões em máquinas de estados NFA de Thompson / DFA de tempo linear que omitem intencionalmente retroreferências (\1) e lookarounds ((?=...), (?<=...)), enquanto os motores de backtracking do JavaScript e do Python os suportam.

Devo validar endereços de e-mail com uma expressão regular da gramática completa da RFC 5322?

Não. Uma gramática literal completa da RFC 5322 ocupa vários kilobytes para permitir espaços em branco entre aspas obsoletos, comentários aninhados e domínios de literais IP que os servidores de e-mail modernos rejeitam, sem provar se uma caixa de entrada pode realmente receber mensagens. Serviços em produção combinam um padrão estrutural conciso (^[a-zA-Z0-9.!#$%&'*+/=?^_\x60{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$) com os limites de comprimento em bytes da RFC 5321 (64 octetos na parte local, 254 octetos no endereço total) e o envio de um e-mail de confirmação.

Como os literais de raw string evitam bugs de duplo escape de barra invertida entre linguagens?

Em strings comuns entre aspas, o compilador da linguagem hospedeira processa os escapes de barra invertida antes de passar a string para o compilador regex, exigindo que \d+\s+ seja duplicado como "\\d+\\s+" e transformando "\b" em um caractere ASCII de backspace em vez de uma fronteira de palavra. Literais brutos nativos ignoram o processamento de escape do compilador hospedeiro: use literais /\d+\s+/ em JavaScript, r"\d+\s+" em Python, literais entre crases em Go e r"\d+\s+" ou r#"..."# em Rust.

Qual é a diferença entre validação exata de string e extração de substring?

A validação exata envolve toda a expressão em âncoras de início e fim (^...$, ou \A...\z em Python, Go e Rust, onde $ no módulo re do Python também pode corresponder imediatamente antes de um \n final). Sem âncoras, uma expressão de data como \d{4}-\d{2}-\d{2} comporta-se como uma busca de substring e aprova entradas malformadas como foo-2026-11-01-bar. Mantenha a ancoragem exata ativada para validação de payloads de API e formulários, ou teste intervalos de extração sem âncoras no Testador e Depurador de Regex.

Como a receita de UUID da RFC 9562 distingue UUIDs válidos de strings hexadecimais arbitrárias de 36 caracteres?

A RFC 9562 (que substitui a RFC 4122) codifica o número de versão de 4 bits no nibble superior do terceiro grupo ([1-8] para UUIDv1 até UUIDv8) e a variante IETF no nibble superior do quarto grupo ([89abAB], representando o binário 10xx). Se o seu banco de dados também armazena o UUID Nil todo zerado (00000000-0000-0000-0000-000000000000) ou o UUID Max todo preenchido com f (ffffffff-ffff-ffff-ffff-ffffffffffff), ative a variante hexadecimal flexibilizada ou adicione ramificações explícitas de alternância.