¿Cómo depurar una expresión regular?

Las expresiones regulares pueden volverse bastante complejas. La falta de espacio en blanco hace que sea difícil de leer. No puedo pasar 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 integrada de depuración . Si trabaja con expresiones regulares más de dos veces al año, recuperará este dinero a tiempo en un santiamén. 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.

texto alternativo

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

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

 $ perl -Mre = debug -e '"foobar" = ~ / (.) \ 1 /'
 Comstackndo REx "(.) \ 1"
 Progtwig final:
    1: OPEN1 (3)
    3: REG_ANY (4)
    4: CLOSE1 (6)
    6: REF1 (8)
    8: FIN (0)
 minlen 1
 Matching REx "(.) \ 1" contra "foobar"
    0 <>  |  1: OPEN1 (3)
    0 <>  |  3: REG_ANY (4)
    1   |  4: CLOSE1 (6)
    1   |  6: REF1 (8)
                                   ha fallado...
    1   |  1: OPEN1 (3)
    1   |  3: REG_ANY (4)
    2   |  4: CLOSE1 (6)
    2   |  6: REF1 (8)
    3   |  8: FIN (0)
 ¡Match exitoso!
 Freeing REx: "(.) \ 1"

Además, puede agregar espacios en blanco y comentarios a expresiones regulares para que sean más legibles. En Perl, esto se hace con el modificador /x . Con pcre , está el indicador 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", ...); 

Agregaré otro para que no lo olvide: depuragex

Es bueno porque es muy visual: Foto de Debuggex regex helper

Cuando me quedo atascado en una expresión regular, suelo recurrir a esto: https://regexr.com/

Es perfecto para probar rápidamente donde algo anda mal.

Yo uso Kodos – The Python Regular Expression Debugger:

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

(…)

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

Se ejecuta en Linux, Unix, Windows, Mac.

Creo que no. 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 legible y mantenible.

Hay una excelente herramienta gratuita, el entrenador Regex . 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 poca gente la descargó, 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 comandos (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 coloreada (configurable por el usuario ), mapas de calor en expresiones regulares y cadenas para optimización, etc.

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

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

http://www.regextester.com/

Pero sí, no puede vencer a RegexBuddy.

Depuro mis expresiones regulares con mis propios ojos. Es por eso que uso /x modificador, escribo comentarios para ellos y los divido en partes. Lea Mastering Regular Expressions de Jeffrey Friedl para aprender a desarrollar expresiones regulares rápidas y legibles. Varias herramientas de corrección de expresiones regulares solo provocan la progtwigción del vudú.

En cuanto a mí, generalmente utilizo la utilidad pcretest que puede volcar el código de bytes de cualquier expresión regular y, por lo general, 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 /ic 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 atascado, me gusta retroceder y generar la expresión regular directamente desde un texto de muestra usando txt2re (aunque por lo general 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í hacerme cargo de los RegEx 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 el autómata de estado finito correspondiente en tu cabeza, pero puede ser difícil de mantener muy rápidamente.

Las razones para no usar un depurador son las mismas que para no usar un depurador con un lenguaje de progtwigción: puedes corregir errores locales, pero no te ayudarán a resolver los problemas de diseño que te llevaron a cometer los errores locales en el primer lugar.

La forma más reflexiva es usar representaciones de datos para generar expresiones regulares en su lenguaje de progtwigción, y tener las 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, difícilmente un “depurador” pero funciona sobre una conexión SSH solo de texto y analiza exactamente el dialecto regex que necesito: mi código (C ++) se vincula a libpcre, así que no hay dificultad con diferencias sutiles en lo que es magia y qué no es, etc.

En general, estoy de acuerdo con el chico de arriba para quien la necesidad de 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, sino las múltiples capas de citas necesarias para que funcionen.

A menudo uso Ruby probador de expresiones regulares Rubular

y también en Emacs usa el re-constructor de Mx

Firefox también tiene una extensión útil

Uso el Rx Toolkit incluido con ActiveState Komodo .

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 evaluar si no estoy seguro de si alcanzaría alguna coincidencia degenerada (es decir, algo que retrocede excesivamente) para ver si podía resolver esos problemas modificando la codicia de un operador, por ejemplo.

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

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