regulares - javascript regex test
¿Cómo depurar una expresión regular? (21)
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?
A menudo uso Ruby probador de expresiones regulares Rubular
y también en Emacs usa el re-builder Mx
Firefox también tiene una extensión útil
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.
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
Agregaré otro para que no lo olvide: debuggex
Es bueno porque es muy visual:
Con Perl 5.10, use re ''debug''; . (O debugcolor , pero no puedo formatear correctamente la salida en .)
$ perl -Mre=debug -e''"foobar"=~/(.)/1/'' Compiling REx "(.)/1" Final program: 1: OPEN1 (3) 3: REG_ANY (4) 4: CLOSE1 (6) 6: REF1 (8) 8: END (0) minlen 1 Matching REx "(.)/1" against "foobar" 0 <> <foobar> | 1:OPEN1(3) 0 <> <foobar> | 3:REG_ANY(4) 1 <f> <oobar> | 4:CLOSE1(6) 1 <f> <oobar> | 6:REF1(8) failed... 1 <f> <oobar> | 1:OPEN1(3) 1 <f> <oobar> | 3:REG_ANY(4) 2 <fo> <obar> | 4:CLOSE1(6) 2 <fo> <obar> | 6:REF1(8) 3 <foo> <bar> | 8:END(0) Match successful! 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", ...);
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.
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.
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 programación del vudú.
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 .
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 /i c
12 [DEde]
45 45 Ket
48 End
------------------------------------------------------------------
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 programació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 programació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.
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.
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).
Puede probar este http://www.pagecolumn.com/tool/regtest.htm
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.
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).
Uso el Rx Toolkit incluido con ActiveState Komodo .
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.
Además, según el desarrollador, esta herramienta se ejecuta casi sin problemas en Linux cuando se utiliza con WINE .
Utilizo esta herramienta en línea para depurar mi expresión regular:
Pero sí, no puede vencer a RegexBuddy.
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 programació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 programació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.