Verificador de portabilidade de expressões regulares
Cole uma expressão regular — sem delimitadores ou no formato JS `/pattern/flags` — e veja quais partes falhariam ou se comportariam silenciosamente de outro modo se o mesmo padrão fosse usado no módulo `re` do Python ou em um mecanismo da família PCRE (PHP, Perl), e por quê.
O processamento é feito localmente no seu navegador. Seu arquivo nunca é enviado.
Como usar esta ferramenta ferramenta
- Cole um padrão regex sem delimitadores (por exemplo, `\d{4}-\d{2}`) ou delimitado (`/\d{4}-\d{2}/g`); os dados não saem do navegador.
- Selecione ‘Analisar padrão’.
- Confira cada construção sinalizada: se é erro de sintaxe em outro ambiente, mudança silenciosa de comportamento ou nota de compatibilidade em uma direção.
- Use a reescrita sugerida quando houver. Algumas construções (quantificadores possessivos, grupos atômicos, recursão) não têm equivalente mecânico simples em JavaScript e são explicadas em vez de adivinhadas.
Premissas
- É uma varredura estática do texto do padrão, não um mecanismo regex: nunca executa o padrão contra texto de exemplo nem analisa a gramática regex completa (classes de caracteres, grupos aninhados e casos de escape além das regras específicas).
- As comparações se limitam a três ecossistemas: RegExp de JavaScript (ECMAScript) como contexto de origem, módulo `re` de Python e família PCRE, seguida de perto por `preg_*` do PHP e regex do Perl.
- Somente divergências documentadas no nível da especificação são sinalizadas; peculiaridades obscuras específicas de mecanismos e erros de versões estão fora do escopo.
Fontes e dados de referência
Metodologia
O corpo do padrão (com delimitadores opcionais `/pattern/flags` removidos) é examinado em busca de oito construções que causam problemas de portabilidade entre linguagens: sintaxe de grupos nomeados e referências inversas exclusiva do Python, quantificadores possessivos, grupos atômicos, âncoras `\A`/`\Z`/`\z`, referências a padrões recursivos PCRE, flags inline no meio do padrão e padrões padrão ASCII versus Unicode para `\d`/`\w`/`\s`. Cada regra usa uma correspondência específica e restrita, não um parser regex de uso geral. Reescrita só é oferecida quando é mecanicamente segura e inequívoca.
Exemplo resolvido
Âncoras `\A` e `\Z`
Dados de entrada: /\Afoo.*bar\Z/
Resultado: JavaScript não tem âncoras `\A` nem `\Z`: interpreta silenciosamente `\A` como ‘A’ literal e `\Z` como ‘Z’, então o padrão corresponde a algo completamente diferente em vez de falhar ao compilar. É sinalizado como erro justamente por falhar silenciosamente.
Grupo nomeado no estilo Python
Dados de entrada: (?P<year>\d{4})
Resultado: `(?P<year>...)` gera SyntaxError em JavaScript, que exige `(?<year>...)` sem P. A reescrita segura remove o P; PCRE e .NET também aceitam a forma simples.
Quantificador possessivo e grupo atômico
Dados de entrada: (?>a++)b
Resultado: Tanto `(?>...)` (grupo atômico) como `a++` (quantificador possessivo) são construções de PCRE/Java sem sintaxe equivalente em JavaScript. Ambos são sinalizados como erros sem reescrita automática, pois reproduzir o efeito em JS exige reestruturar o padrão com lookahead capturador, não substituir texto.
Âncora de início no estilo Python
Dados de entrada: /\Afoo/
Resultado: Python e alguns outros mecanismos usam `\A` para o início absoluto da string. JavaScript não tem essa âncora: em um padrão JS, o escape não ancora o início e pode ser tratado como escape de identidade que corresponde a A. O verificador detecta a construção no texto; não a executa contra strings de exemplo.
Orientações práticas
- Não dependa de `\A` nem `\Z`/`\z` se o padrão puder ser executado em JavaScript. Use `^`/`$` com a flag `m` deliberadamente desativada e confira o comportamento necessário para uma nova linha final.
- JavaScript usa `(?<name>...)` para grupos nomeados; Python `re` usa `(?P<name>...)`. Não há sintaxe única compatível com ambos: adapte o padrão para cada linguagem.
- Trate quantificadores possessivos, grupos atômicos e padrões recursivos como sinal de que o padrão precisa ser reestruturado (ou de que é preciso usar um parser real) antes de ser executado em JavaScript: não há sintaxe equivalente de substituição direta.
Erros comuns
- Presumir que um padrão que compila em JS se comporta como a versão de Python/PCRE de origem. `\A`/`\Z` e padrões Unicode de `\d`/`\w`/`\s` compilam, mas podem corresponder a valores diferentes.
- Tratar `(?<name>...)` como universalmente portátil: é válido em JS, PCRE e .NET, mas o módulo `re` do Python o rejeita sem P.
Perguntas frequentes
Por que `\A`/`\Z` são mais perigosas que quantificadores possessivos ou grupos atômicos?
Quantificadores possessivos e grupos atômicos geram SyntaxError (ou equivalente) em JavaScript: a falha é imediata e evidente. `\A` e `\Z` compilam e correspondem silenciosamente às letras A/Z em vez de ancorar; o erro pode passar despercebido até o padrão falhar com dados reais.
Por que a ferramenta sugere `(?<name>...)` para JS, mas sinaliza como aviso para Python?
A forma ‘correta’ depende do mecanismo: JS/PCRE/.NET usam a forma sem P; Python a exige. Como a ferramenta não sabe qual ambiente importa para você, informa as duas direções e só reescreve forçadamente o caso inequivocamente inválido para JS (sintaxe Python `(?P<name>...)`).
A ferramenta pode corrigir automaticamente quantificador possessivo ou grupo atômico?
Não. Reproduzir o efeito em JavaScript geralmente exige emular grupo atômico com lookahead capturador (`(?=(pattern))\\1`), alterando a estrutura do padrão, não apenas o texto. Essa decisão cabe a quem mantém o padrão.
Última revisão:
Scanner de texto restrito, construção por construção, não parser nem mecanismo regex: reconhece oito problemas de portabilidade específicos e documentados, não extensões incomuns de mecanismos, casos extremos de grupos aninhados nem comportamento real de correspondência. Nunca executa o padrão em dados de exemplo.
As preferências de tema e de ferramentas, além das listas de itens salvos e usados recentemente, são armazenadas somente neste navegador.