¿Cuál es una buena manera de depurar una expresión regular?

Debuggex muestra las vías del tren hacia dónde puede ir su cadena , representando visualmente su expresión regular y permitiéndole simularla en los datos de prueba.

Me parece bastante útil el Regex Buddy (Aprender, Crear, Comprender, Probar, Usar y Guardar Expresión Regular). Muestra el significado de todos y cada uno de los caracteres de su expresión regular y cómo afecta a la salida. Sin embargo, es un software pago.

RegViz es una herramienta de depuración para expresiones regulares de JavaScript. Al igual que Debuggex y RegexBuddy, es bastante visual pero integra todo en una interfaz de usuario sencilla y fácil de entender. RegViz destaca la estructura de las expresiones regulares, indica visualmente coincidencias de grupos e integra un enfoque de prueba ligero.

Utilizo el comando pcretest para finalizar / depurar la expresión regular.

pcretest (prueba de expresión regular compatible con Perl) está disponible en la mayoría de los sistemas UNIX, viene como paquete pcre.

Ejemplo de sesión con el comando pcretest

[ [correo electrónico protegido] ~] $ pcretest
PCRE versión 6.6 06-feb-2006

re> / abc + / g
datos> esto es abcc y abc
0: abcc
0: abc
datos> cabcdda
0: abc
datos>
re> /\d+\.\d+\.\d+\.\d+/
datos> 10.1.1.2
0: 10.1.1.2
datos> 10.2.3.4
0: 10.2.3.4
datos>

use ^ D para cerrar la sesión.

Regexp :: Debugger – Depuración visual de expresiones regulares en el lugar – metacpan.org – El lenguaje de programación Perl es una herramienta excelente para eso. Puedes ver una breve demostración aquí:

Perl número primo regex bajo Regexp :: Debugger

Simplemente no los uses.

Pueden ser cosas interesantes en su seminario de teoría de autómatas. Pueden hacer de grep y awk y perl y PHP las superestrellas que creen que son. Pero realmente, piensa. ¿Alguna vez has pasado un momento feliz con una expresión regular? ¿Alguno de ellos ha funcionado bien, completamente bien, la primera vez? O la quinta vez? ¿Recuerdas usar el modo de signo de interrogación codicioso o no codicioso cada vez? ¿Recuerdas las diferencias exactas entre el uso de ^ $ en modo de una o varias líneas? ¿Alguna vez puede estar seguro de que la expresión regular coincide con lo que está buscando, y se da cuenta de que una expresión regular nunca puede manejar adecuadamente los comentarios o parens equilibrados o la barra oblicua a los comentarios EOl e incluso si se le ocurre un patrón como / ^ ^ &% $ 6754 [% -%]. + \ -. + \ D + $ / que parece funcionar, ¿sigue siendo una abominación?

En su lugar, intente algo sensato, como escribir algunas funciones como:

SkipSpaces (), GrabWord () o lo que necesites. Pueden llamar a GetNextNoncommentChar () o lo que sea que haga cosas que ninguna expresión regular puede hacer.

Serás más feliz y la próxima persona que tenga que trabajar en el código será aún más feliz.

Aquí hay algunas herramientas para aprender y depurar expresiones regulares:

Regex101

RegExr

Regexper

Regexpal

Pythex

PyRegex

Rubular

Puede consultar más herramientas de expresiones regulares en CybrHome.

La depuración es mucho más fácil si la escribe claramente en primer lugar. La mejor manera de hacerlo, IME, es usar la opción ingeniosa / x, que le dice al motor que ignore los espacios en blanco y los comentarios en su expresión. Eso le permite escribir expresiones regulares complejas de una manera muy legible, dividida en varias líneas, con sangría lógica y comentarios.

La legibilidad no es simplemente útil más adelante cuando se vuelve a leer su código, es útil de inmediato para ayudarlo a descubrir por qué no está haciendo lo que pensaba que debería. Solía ​​bromear que las expresiones regulares son de solo escritura, pero usando la opción / x, no es necesario que lo sean.

En la misma línea, puede ser útil dividir una expresión compleja en piezas del tamaño de un bocado que pueden probarse individualmente y luego combinarse en expresiones que habrían sido extremadamente difíciles de escribir en una sola pieza.

Por ejemplo, aquí hay una expresión que escribí que analiza un archivo DFM de Delphi para encontrar la lista de valores de propiedad para un objeto dado:

  / ^ \ s * ((?: \ w | \.) +?) \ s * = \ s * (# Nombre de propiedad: capturado como $ 1
						 # Valores de propiedad: capturados como $ 2
						 # Cada tipo de datos se maneja por separado a continuación
						 # Valores de cadena
						 (?:
							 \ (? \ s *				  
							 (?: '(?: [^'] | '' | '\ # \ d +') * '(?: \ s * \ # \ d +) * \ s * \ +? \ s *) +							
							 \ s * \)?
						 )
					
						 # Valores binarios (hexadecimales)
						 | (?: \ {\ s * (?: (?: [AF] | [0-9]) + \ s *) * \})
					
						 # Valores numéricos o identificadores
						 | (?: [\ w .-] + \ s *)
					
						 #Conjuntos 
						 | (?: \ [(?: [\ w .-] +,? \ s *) * \])
						
						 # Colecciones
						 | (?: <\ s *
						        ^ \ s * item \ s * $
						        (? R) +
						        ^ \ s * fin \ b
						      > 						       
                          )
					 ) \ s * $ / migx 

Complejo, pero bastante legible, y si no puede hacer que funcione, es bastante fácil sacar trozos hasta que funcione, sin romper todo.

Aquí hay otro ejemplo, que muestra el tipo de cosas que puedes hacer fragmentando la expresión. Este ejemplo analiza una instrucción if / else de C ++ (para convertirla en una sintaxis Pascal):

	
 $ llaves = qr / (?  \ {([^ \ {\}] | (? & llaves)) *? \}) / x;
 $ paréntesis = qr / (?  \ (([^ \ (\)] | (? & paréntesis)) *? \)) / x;

 $ code = ~ s / (?  $ corchetes) (?  \ s *) (?! \ s * then \ b)
							   (?  ($ llaves | (?: [^ {};] +;))) (?  \ h * \ n *)
							   (?  (\ s * else \ s * if \ s * (?  $ corchetes) \ s * ($ llaves | (?: [^ {};] +;))) *)
							   (?  (?  \ h *) else (?  \ s *) (?! if \ b)
								 (?  ($ llaves | (?: [^ {};] +;))))?
				   / convertIf ($ + {"cond"}, $ + {"if_code"}, $ + {"if_indent"}, $ + {"if_indent2"}, $ + {elseif}, $ + {"else_code"}, $ + {"else_indent"}, $ + {"else_indent2"}) / gxe;	

La expresión anterior podría mejorarse con una mejor sangría y comentarios, pero aún así, es MUCHO más legible y depurable (e incluso escribible) de lo que hubiera sido si no se hubiera dividido.

Hay una herramienta de escritorio llamada KiKi disponible en los repositorios de Linux. Eso sirve para el mismo propósito que se mencionó anteriormente y tampoco necesita el acceso a Internet para que pueda probar su expresión regular mientras viaja también 🙂

Si está utilizando una versión más reciente de Perl:

use re ‘depuración’;

Esto volcará los estados internos que atraviesa el motor de expresiones regulares cuando coinciden. Es léxico, por lo que puede usarlo dentro de un bloque para depurar una expresión regular en particular.

La salida no es la más fácil de entender del mundo, pero ya está presente en cualquier Perl moderno.

Emacs, por supuesto, viene con una herramienta para esto llamada re-constructor. Mx re-builder . Obviamente, solo es útil si su expresión regular es compatible con Emacs, pero de todos modos es genial.

Usando Emacs Regular Expression Builder

Es agradable ver todas las diferentes herramientas, incluidas las opciones basadas en la web, pero
Me sorprende que nadie haya mencionado Expresso.
Herramienta de expresión regular Expresso

Es gratis y lo he estado usando durante años, todavía no me ha decepcionado.

RegExr

También puede probar su expresión regular en Regex Tester

Yo uso Regexper

– proporciona una solución esquemática y bastante ordenada

¡Con muchas pruebas unitarias!

Probador de expresiones regulares. Uno de los mejores probadores en línea disponibles.