Como você depurar um regex?

Expressões regulares podem se tornar bastante complexas. A falta de espaço em branco dificulta a leitura. Eu não posso pisar embora uma expressão regular com um depurador. Então, como os especialistas depuram expressões regulares complexas?

Você compra o RegexBuddy e usa seu recurso de debugging integrado. Se você trabalha com regexes mais do que duas vezes por ano, você recuperará esse dinheiro a tempo, em pouquíssimo tempo. O RegexBuddy também ajudará você a criar expressões regulares simples e complexas e até mesmo gerar o código para você em vários idiomas.

texto alternativo

Além disso, de acordo com o desenvolvedor, essa ferramenta é executada quase perfeitamente no Linux quando usada com o WINE .

Com o Perl 5.10, use re 'debug'; . (Ou debugcolor , mas não consigo formatar a saída corretamente no Stack Overflow.)

 $ perl -Mre = debug -e '"foobar" = ~ / (.) \ 1 /'
 Compilando REx "(.) \ 1"
 Programa final:
    1: OPEN1 (3)
    3: REG_ANY (4)
    4: CLOSE1 (6)
    6: REF1 (8)
    8: END (0)
 minlen 1
 Correspondência de REx "(.) \ 1" contra "foobar"
    0 <>  |  1: OPEN1 (3)
    0 <>  |  3: REG_ANY (4)
    1   |  4: CLOSE1 (6)
    1   |  6: REF1 (8)
                                   falhou ...
    1   |  1: OPEN1 (3)
    1   |  3: REG_ANY (4)
    2   |  4: CLOSE1 (6)
    2   |  6: REF1 (8)
    3   |  8: END (0)
 Combine com sucesso!
 Liberando REx: "(.) \ 1"

Além disso, você pode adicionar espaços em branco e comentários aos regexes para torná-los mais legíveis. Em Perl, isso é feito com o modificador /x . Com pcre , existe o flag PCRE_EXTENDED .

 "foobar" =~ / (.) # any character, followed by a \1 # repeat of previously matched character /x; pcre *pat = pcre_compile("(.) # any character, followed by a\n" "\\1 # repeat of previously matched character\n", PCRE_EXTENDED, ...); pcre_exec(pat, NULL, "foobar", ...); 

Vou adicionar outro para que eu não esqueça: debuggex

É bom porque é muito visual: Foto do auxiliar de regex Debuggex

Quando eu fico preso em um regex, normalmente eu ligo para isso: https://regexr.com/

É perfeito para testar rapidamente onde algo está errado.

Eu uso Kodos – O Depurador de Expressões Regulares do Python:

O Kodos é um utilitário GUI do Python para criar, testar e depurar expressões regulares para a linguagem de programação Python. O Kodos deve ajudar qualquer desenvolvedor a desenvolver com eficiência e sem esforço expressões regulares no Python. Como a implementação de expressões regulares do Python é baseada no padrão PCRE , o Kodos deve beneficiar desenvolvedores em outras linguagens de programação que também adiram ao padrão PCRE (Perl, PHP, etc …).

(…)

texto alternativo http://kodos.sourceforge.net/images/match.gif

Funciona em Linux, Unix, Windows, Mac.

Eu acho que eles não. Se seu regexp é muito complicado e problemático ao ponto de precisar de um depurador, você deve criar um analisador específico ou usar outro método. Será muito mais legível e sustentável.

Existe uma excelente ferramenta gratuita, o Regex Coach . A versão mais recente está disponível apenas para o Windows; seu autor Dr. Edmund Weitz parou de manter a versão do Linux porque poucas pessoas fizeram o download, mas existe uma versão mais antiga para o Linux na página de download.

Acabei de ver uma apresentação do Regexp :: Debugger pelo seu criador: Damian Conway. Coisas muito impressionantes: executar no local ou usando uma ferramenta de linha de comando (rxrx), interativamente ou em um arquivo de execução “logado” (armazenado em JSON), avançar e voltar em qualquer ponto, parar em pontos de interrupção ou events, saída colorida ), mapas de calor em regexp e string para otimização, etc …

Disponível gratuitamente no CPAN: http://search.cpan.org/~dconway/Regexp-Debugger/lib/Regexp/Debugger.pm

Eu uso essa ferramenta on-line para depurar meu regex:

http://www.regextester.com/

Mas sim, não pode bater RegexBuddy.

Eu depuro meus regexes com meus próprios olhos. É por isso que eu uso o modificador /x , escrevo comentários para eles e os separo em partes. Leia as Expressões Regulares Dominantes de Jeffrey Friedl para aprender como desenvolver expressões regulares rápidas e legíveis. Várias ferramentas de debugging regex apenas provocam programação vodu.

Quanto a mim, costumo usar o utilitário pcretest, que pode despejar o código de byte de qualquer regex, e geralmente é muito mais fácil de ler (pelo menos para mim). Exemplo:

 PCRE version 8.30-PT1 2012-01-01 re> /ab|c[de]/iB ------------------------------------------------------------------ 0 7 Bra 3 /i ab 7 38 Alt 10 /ic 12 [DEde] 45 45 Ket 48 End ------------------------------------------------------------------ 

Eu uso:

http://regexlib.com/RETester.aspx

Você também pode tentar o Regex Hero (usa o Silverlight):

http://regexhero.net/tester/

Se estou me sentindo preso, eu gosto de voltar atrás e gerar o regex diretamente de um texto de exemplo usando txt2re (embora eu geralmente acabe aprimorando a regex resultante manualmente).

Se você é usuário de Mac, acabei de encontrar este:

http://atastypixel.com/blog/reginald-regex-explorer/

É grátis e simples de usar, e tem sido uma grande ajuda para eu me familiarizar com RegExs em geral.

Dê uma olhada nas ferramentas (não-livres) em regular-expressions.info . RegexBuddy em particular. Aqui está o post de Jeff Atwood sobre o assunto .

Escrever reg exes usando uma notação como PCREs é como escrever assembler: tudo bem se você puder ver apenas os autômatos de estados finitos correspondentes em sua cabeça, mas pode ser difícil mantê-los muito rapidamente.

As razões para não usar um depurador são as mesmas que para não usar um depurador com uma linguagem de programação: você pode corrigir erros locais, mas eles não o ajudarão a resolver os problemas de projeto que o levaram a cometer erros locais no primeiro. Lugar, colocar.

A maneira mais reflexiva é usar representações de dados para gerar regexps em sua linguagem de programação e ter abstrações apropriadas para construí-las. A introdução de Olin Shiver ao seu esquema de notação regexp dá uma excelente visão geral dos problemas enfrentados no projeto dessas representações de dados.

Costumo usar o pcretest – dificilmente um “debugger”, mas funciona em uma conexão SSH somente de texto e analisa exatamente o dialeto regex que eu preciso: meus links de código (C ++) para libpcre, então não há dificuldade com diferenças sutis no que é mágico e não é, etc.

Em geral, eu concordo com o cara acima de quem precisar de um depurador de regex é um cheiro de código. Para mim, o mais difícil de usar regexes geralmente não é a regex em si, mas as múltiplas camadas de citação necessárias para fazê-las funcionar.

Costumo usar o testador de regexp baseado em Ruby Rubular

e também no Emacs usar o Mx re-builder

O Firefox também tem uma extensão útil

Eu uso o Rx Toolkit incluído no ActiveState Komodo .

Você poderia tentar este aqui http://www.pagecolumn.com/tool/regtest.htm

Para mim, depois de ter visto o regex (como eu sou bastante fluente e quase sempre uso / x ou equivalente), eu poderia depurar ao invés de testar se não tenho certeza se eu iria acertar alguma correspondência degenerada (ou seja, algo que recua excessivamente) para ver se eu poderia resolver esses problemas, modificando a ganância de um operador, por exemplo.

Para fazer isso, eu usaria um dos methods mencionados acima: pcretest, RegexBuddy (se meu local de trabalho atual tiver licenciado) ou similar, e às vezes eu o tempo em Linqpad se eu estou trabalhando em regexes C #.

(O truque perl é um novo para mim, então provavelmente irá adicionar isso ao meu kit de ferramentas regex também.)