¿Cómo se depura una expresión regular? [cerrado]

Las expresiones regulares pueden volverse bastante complejas. La falta de espacio en blanco los hace difíciles de leer. No puedo pasar por una expresión regular con un depurador. Entonces, ¿cómo depuran los expertos las expresiones regulares complejas?

Usted compra RegexBuddy y utiliza su función de depuración integrada . Si trabaja con expresiones regulares más de dos veces al año, recuperará este dinero en el tiempo ahorrado en poco tiempo. RegexBuddy también lo ayudará a crear expresiones regulares simples y complejas, e incluso generar el código para usted en una variedad de idiomas.

Además, según el desarrollador, esta herramienta se ejecuta casi sin problemas en Linux cuando se usa con WINE .

Con Perl 5.10, use re 'debug';. (O bien debugcolor, pero no puedo formatear la salida correctamente en Stack Overflow).

$ perl -Mre = debug -e '"foobar" = ~ / (.) \ 1 /'
Compilando REx "(.) \ 1"
Programa final:
   1: ABIERTO1 (3)
   3: REG_ANY (4)
   4: CERRAR1 (6)
   6: REF1 (8)
   8: FIN (0)
minlen 1
Hacer coincidir REx "(.) \ 1" contra "foobar"
   0 <> <foobar> | 1: ABIERTO1 (3)
   0 <> <foobar> | 3: REG_ANY (4)
   1 <f> <oobar> | 4: CERRAR1 (6)
   1 <f> <oobar> | 6: REF1 (8)
                                  ha fallado...
   1 <f> <oobar> | 1: ABIERTO1 (3)
   1 <f> <oobar> | 3: REG_ANY (4)
   2 <fo> <obar> | 4: CERRAR1 (6)
   2 <fo> <obar> | 6: REF1 (8)
   3 <foo> <bar> | 8: FIN (0)
¡Partido exitoso!
Liberando REx: "(.) \ 1"

Además, puede agregar espacios en blanco y comentarios a las expresiones regulares para que sean más legibles. En Perl, esto se hace con el /xmodificador. Con pcre, ahí está la PCRE_EXTENDEDbandera.

"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", ...);

Agregaré otro para no olvidarlo: debuggex

Es bueno porque es muy visual:

Cuando me atoro en una expresión regular, generalmente me vuelvo a esto: https://regexr.com/

Es perfecto para probar rápidamente dónde algo va mal.

Yo uso Kodos - El depurador de expresiones regulares de Python:

Kodos es una utilidad de la GUI de Python para crear, probar y depurar expresiones regulares para el lenguaje de programación Python. Kodos debería ayudar a cualquier desarrollador a desarrollar expresiones regulares y sin esfuerzo en Python. Dado que la implementación de expresiones regulares de Python se basa en el estándar PCRE , Kodos debería beneficiar a los desarrolladores en otros lenguajes de programación que también cumplan con el estándar PCRE (Perl, PHP, etc.).

(...)

Se ejecuta en Linux, Unix, Windows, Mac.

Creo que no lo hacen. Si su expresión regular es demasiado complicada y problemática hasta el punto de que necesita un depurador, debe crear un analizador específico o utilizar otro método. Será mucho más fácil de leer y mantener.

Existe una excelente herramienta gratuita, el Regex Coach . La última versión solo está disponible para Windows; su autor, el Dr. Edmund Weitz, dejó de mantener la versión de Linux porque muy pocas personas la descargaron, pero hay una versión anterior para Linux en la página de descarga.

Acabo de ver una presentación de Regexp :: Debugger por su creador: Damian Conway. Cosas muy impresionantes: ejecutar in situ o usar una herramienta de línea de comando (rxrx), interactivamente o en un archivo de ejecución "registrado" (almacenado en JSON), avanzar y retroceder en cualquier punto, detenerse en puntos de interrupción o eventos, salida en color (configurable por el usuario ), mapas de calor en expresiones regulares y cadenas para la optimización, etc.

Disponible en CPAN de forma gratuita: http://search.cpan.org/~dconway/Regexp-Debugger/lib/Regexp/Debugger.pm

Utilizo esta herramienta en línea para depurar mi expresión regular:

https://www.regextester.com/

Pero sí, no puede vencer a RegexBuddy.

Depuro mis expresiones regulares con mis propios ojos. Es por eso que uso /xmodificador, escribo comentarios para ellos y los divido en partes. Lea las expresiones regulares de dominio de Jeffrey Friedl para aprender a desarrollar expresiones regulares rápidas y legibles. Varias herramientas de depuración de expresiones regulares solo provocan la programación de vudú.

En cuanto a mí, generalmente uso la utilidad pcretest que puede volcar el código de byte de cualquier expresión regular, y generalmente es mucho más fácil de leer (al menos para mí). Ejemplo:

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
------------------------------------------------------------------

Yo suelo:

http://regexlib.com/RETester.aspx

También puedes probar Regex Hero (usa Silverlight):

http://regexhero.net/tester/

Si me siento atrapado, me gusta ir hacia atrás y generar la expresión regular directamente de un texto de muestra usando txt2re (aunque generalmente termino ajustando la expresión regular resultante a mano).

Si eres un usuario de Mac, acabo de encontrar este:

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

Es gratis y fácil de usar, y ha sido de gran ayuda para mí familiarizarme con RegExs en general.

Eche un vistazo a las herramientas (no gratuitas) en regular-expressions.info . RegexBuddy en particular. Aquí está la publicación de Jeff Atwood sobre el tema .

Escribir registros usando una notación como PCRE es como escribir ensamblador: está bien si solo puedes ver los autómatas de estado finito correspondientes en tu cabeza, pero puede ser difícil de mantener muy rápidamente.

Las razones para no usar un depurador son muy similares a las de no usar un depurador con un lenguaje de programación: puede corregir errores locales, pero no lo ayudarán a resolver los problemas de diseño que lo llevaron a cometer los errores locales en un primer momento. sitio.

La forma más reflexiva es usar representaciones de datos para generar expresiones regulares en su lenguaje de programación, y tener abstracciones apropiadas para construirlas. La introducción de Olin Shiver a su notación regexp de esquema ofrece una excelente visión general de los problemas que se enfrentan al diseñar estas representaciones de datos.

A menudo uso pcretest, apenas un "depurador", pero funciona a través de una conexión SSH de solo texto y analiza exactamente el dialecto regex que necesito: mi código (C ++) se vincula a libpcre, por lo que no hay dificultad con diferencias sutiles en lo que es mágico y qué no es, etc.

En general, estoy de acuerdo con el tipo de arriba para quien necesitar un depurador de expresiones regulares es un olor a código. Para mí, lo más difícil de usar expresiones regulares generalmente no es la expresión regular en sí misma, sino las múltiples capas de citas necesarias para que funcionen.

A menudo uso Ruby tester regexp tester Rubular

y también en Emacs use M-x re-builder

Firefox también tiene una extensión útil

Uso el kit de herramientas Rx incluido con ActiveState Komodo .

Puedes probar este http://www.pagecolumn.com/tool/regtest.htm

Para mí, después de haber analizado la expresión regular (ya que soy bastante fluido, y casi siempre uso / x o equivalente), podría depurar en lugar de probar si no estoy seguro de si llegaría a una coincidencia degenerada (es decir, algo que retrocede excesivamente) para ver si podía resolver tales problemas modificando la codicia de un operador, por ejemplo.

Para hacer eso, usaría uno de los métodos mencionados anteriormente: pcretest, RegexBuddy (si mi lugar de trabajo actual lo ha autorizado) o similar, y a veces lo cronometraré en Linqpad si estoy trabajando en expresiones regulares de C #.

(El truco perl es nuevo para mí, por lo que probablemente también lo agregue a mi kit de herramientas de expresiones regulares).