Como você depura uma regex? [fechadas]

Expressões regulares podem se tornar bastante complexas. A falta de espaço em branco os torna difíceis de ler. Não consigo passar por 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 depuração embutido . Se você trabalha com regexes mais de duas vezes por ano, você ganhará esse dinheiro de volta no tempo economizado em pouco tempo. O RegexBuddy também ajudará você a criar expressões regulares simples e complexas e até a gerar o código para você em uma variedade de idiomas.

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

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

$ perl -Mre = depuração -e '"foobar" = ~ / (.) \ 1 /'
Compilando REx "(.) \ 1"
Programa final:
   1: ABRIR1 (3)
   3: REG_ANY (4)
   4: FECHAR1 (6)
   6: REF1 (8)
   8: FIM (0)
minlen 1
Correspondência de REx "(.) \ 1" contra "foobar"
   0 <> <foobar> | 1: ABRIR1 (3)
   0 <> <foobar> | 3: REG_ANY (4)
   1 <f> <oobar> | 4: FECHAR1 (6)
   1 <f> <oobar> | 6: REF1 (8)
                                  falhou ...
   1 <f> <oobar> | 1: ABRIR1 (3)
   1 <f> <oobar> | 3: REG_ANY (4)
   2 <fo> <obar> | 4: FECHAR1 (6)
   2 <fo> <obar> | 6: REF1 (8)
   3 <foo> <bar> | 8: FIM (0)
Combine com sucesso!
Liberando REx: "(.) \ 1"

Além disso, você pode adicionar espaços em branco e comentários às expressões regulares para torná-las mais legíveis. No Perl, isso é feito com o /xmodificador. Com pcre, há a PCRE_EXTENDEDbandeira.

"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 não esquecer: debuggex

É bom porque é muito visual:

Quando fico preso em uma regex, costumo recorrer a isso: https://regexr.com/

É perfeito para testar rapidamente onde algo está errado.

Eu uso o Kodos - o depurador de expressões regulares do Python:

Kodos é um utilitário da 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 expressões regulares de forma eficiente e sem esforço 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 aderem ao padrão PCRE (Perl, PHP, etc ...).

(...)

Executa no Linux, Unix, Windows, Mac.

Eu acho que eles não. Se o seu regexp for muito complicado e problemático a ponto de você precisar de um depurador, crie um analisador específico ou use 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 Windows; seu autor, Dr. Edmund Weitz, parou de manter a versão Linux porque poucas pessoas fizeram o download, mas há uma versão mais antiga para Linux na página de download.

Acabei de ver uma apresentação do Regexp :: Debugger por seu criador: Damian Conway. Coisas impressionantes: execute no local ou usando uma ferramenta de linha de comando (rxrx), interativamente ou em um arquivo de execução "registrado" (armazenado em JSON), avance e retroceda a qualquer momento, pare em pontos de interrupção ou eventos, saída colorida (configurável pelo usuário) ), mapas de calor em regexp e string para otimização, etc ...

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

Eu uso essa ferramenta online para depurar meu regex:

https://www.regextester.com/

Mas sim, não pode vencer o RegexBuddy.

Eu depuro minhas expressões regulares com meus próprios olhos. É por isso que uso /xmodificador, escrevo comentários para eles e os divido em partes. Leia Mastering Regular Expressions, de Jeffrey Friedl, para aprender a desenvolver expressões regulares rápidas e legíveis. Várias ferramentas de depuração regex apenas provocam a programação vodu.

Quanto a mim, eu geralmente uso o utilitário pcretest, que pode despejar o código de bytes 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  /i c
 12     [DEde]
 45  45 Ket
 48     End
------------------------------------------------------------------

Eu uso:

http://regexlib.com/RETester.aspx

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

http://regexhero.net/tester/

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

Se você é um usuário de Mac, encontrei este:

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

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

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

Escrever registros 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 manter muito rapidamente.

As razões para não usar um depurador são as mesmas de não usar um depurador com uma linguagem de programação: você pode corrigir erros locais, mas eles não ajudarão a resolver os problemas de design 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 à sua notação de regexp de esquema fornece uma excelente visão geral dos problemas enfrentados no design dessas representações de dados.

Costumo usar pcretest - dificilmente um "depurador", mas funciona em uma conexão SSH somente em texto e analisa exatamente o dialeto regex de que preciso: meu código (C ++) vincula-se ao libpcre, portanto não há dificuldade com diferenças sutis no que é mágico e o que não é etc.

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

Costumo usar o testador de regexp baseado em Ruby Rubular

e também no Emacs use M-x re-builder

Firefox também tem uma extensão útil

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

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

Para mim, depois de observar o regex (como eu sou bastante fluente e quase sempre uso / x ou equivalente), eu poderia depurar em vez de testar se não tenho certeza se conseguiria alguma correspondência degenerada (ou seja, algo que recua demais) para ver se eu poderia resolver esses problemas, modificando a ganância de um operador, por exemplo.

Para fazer isso, eu usaria um dos métodos mencionados acima: pcretest, RegexBuddy (se meu local de trabalho atual o licenciou) ou similar, e às vezes o tempo no Linqpad se estiver trabalhando em regexes C #.

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