Probador de expresiones regulares

Por qué regex vale la pena aprender (y cuándo no usarlo)

Las expresiones regulares son la herramienta universal de análisis de texto — todos los lenguajes modernos las tienen, la sintaxis se transfiere principalmente, y son la respuesta correcta para ~80% de trabajos "encuentra este patrón". Los 20% restantes:

• Parsear HTML o XML con regex — no lo hagas. Usa un analizador real (DOMParser en el navegador, cheerio en Node).
• Parsear JSON con regex — no lo hagas. Usa JSON.parse.
• Validación de correo con regex — generalmente incorrecto; usa una biblioteca o el sistema integrado de tu proveedor de autenticación.
• Delimitadores profundamente anidados o balanceados — regex no puede (formalmente) coincidir con estos. Usa un analizador.

Para todo lo demás: extrayendo URL, dividiendo texto tipo CSV, validando formatos de teléfono, coincidiendo líneas de log, encontrando comentarios TODO — regex es la herramienta correcta.

Los cinco conceptos que vale la pena memorizar

Puedes escribir 90% de regex útil con estos cinco primitivos:

1. Clases de caracteres: \d (dígito), \w (carácter de palabra), \s (espacio en blanco), y sus negaciones en mayúsculas. Más clases personalizadas: [a-z], [^xyz].
2. Cuantificadores: * (0+), + (1+), ? (0 o 1), {n,m} (entre n y m). Agrega ? para hacerlos perezosos: *?, +?.
3. Anclajes: ^ (inicio), $ (fin), \b (límite de palabra).
4. Grupos: (…) captura, (?:…) no captura (más barato), (?<name>…) captura con nombre.
5. Alternancia: a|b — a o b.

Combina estos y puedes coincidir con la mayoría de cosas. El resto de la sintaxis de regex (lookahead, referencias inversas, clases unicode, etc.) es ocasionalmente útil pero evitable para el trabajo diario.

Las peculiaridades específicas de JavaScript

JS regex (según ECMAScript) es casi PCRE pero no exactamente:

• Sin (?#comment) — JS regex no tiene sintaxis de comentario. Comenta tu código en su lugar.
• . NO coincide con saltos de línea a menos que establezcas la bandera s (dotAll). Fuente frecuente de "¿por qué esto no coincide?".
• \b usa límites de palabra ASCII por defecto. Establecer la bandera u cambia esto. Agrega u siempre que manejes texto no-ASCII.
• Los grupos nombrados usan (?<name>…) — estilo Python. JS adoptó esto en 2018; asume navegadores modernos/Node.
• Las referencias inversas en replace usan $1, $2, $<name> — no \1 como Perl.

Otros lenguajes hacen las cosas ligeramente diferentes. PCRE es un superconjunto casi de JS regex; Python re es similar pero usa (?P<name>…) para grupos nombrados; el paquete regexp de Go es RE2 (sin referencias inversas, sin lookahead, pero tiempo lineal garantizado). No pegues una regex de Python en JS sin verificar.

Backtracking catastrófico — la única trampa de rendimiento

Un patrón como (a+)+b coincidiendo contra aaaaaaaaaaaaaaaaaaaaa (sin b final) toma tiempo exponencial conforme crece la entrada. El motor de regex intenta cada forma posible de particionar las as entre los dos cuantificadores, se rinde, luego intenta la siguiente combinación. Con 20 as y sin b, eso son millones de intentos.

Esta herramienta establece un límite de ejecución de 1 segundo precisamente porque los patrones patológicos pueden colgar una pestaña del navegador indefinidamente.

Reglas de evitación:

• No anides cuantificadores sin pensar. (a+)+, (a*)*, (a|aa)+ son banderas rojas.
• Usa grupos atómicos o cuantificadores posesivos si tu motor los soporta (JS no — usa trucos de lookahead).
• Sé específico. [^"]*" coincide hasta la siguiente comilla; mejor que .*" que puede retroceder.
• Prueba con entrada adversaria. Un patrón que maneja tu caso feliz puede explotar en entrada terminando en pocos caracteres sin coincidencia.

Si un patrón está tomando demasiado tiempo, la respuesta raramente es "agrega más +" — normalmente es "reescribe para ser lineal", o "usa un analizador real".

Cómo ayuda esta herramienta

• Pega un patrón y texto; las coincidencias se destacan en vivo.
• Las banderas se pueden alternar; las ves en la vista previa del patrón (/foo/gi).
• Los grupos de captura y grupos nombrados aparecen debajo de cada coincidencia.
• El modo de reemplazo previsualizaiza el resultado de text.replace(pattern, replacement).
• El límite de ejecución de 1 segundo atrapa backtracking catastrófico antes de que tu pestaña se congele.

Una hoja de trucos de patrones que funcionan

No a prueba de balas — el de correo acepta muchas direcciones inválidas — pero lo suficientemente bueno para filtrado y extracción.

Privacidad

Toda coincidencia de regex se ejecuta en el navegador vía el motor nativo RegExp. No enviamos tus patrones o texto a ningún lugar.

Herramientas relacionadas

• Conversor de mayúsculas y minúsculas — cambia la mayúscula/minúscula del texto coincidido.
• Slugify — convierte texto arbitrario en slugs seguros para URL (una transformación regex de nivel superior).
• Formateador JSON — cuando tus coincidencias terminan necesitando formato JSON.

¿Qué es el backtracking catastrófico?

Una patología de rendimiento de regex donde el motor explora exponencialmente muchas formas de particionar la entrada en cuantificadores anidados. Patrones como (a+)+b contra aaaaaaaa… (sin b) se cuelgan indefinidamente. Esta herramienta limita la ejecución a 1 segundo e informa el problema.

¿Cuantificador codicioso vs perezoso?

* y + son codiciosos — coinciden tanto como sea posible. Agrega ? (*?, +?) para hacerlos perezosos — coincide lo menos posible. Para <.*> en <a><b> obtienes la cadena completa; <.*?> da solo <a>.

¿Por qué es difícil hacer coincidir HTML?

HTML no es un lenguaje regular — tiene anidamiento arbitrario que regex no puede (formalmente) manejar. Puedes hacer coincidir casos simples muy específicos, pero el HTML del mundo real tiene comentarios, CDATA, etiquetas malformadas y espacios en blanco raros. Usa DOMParser en el navegador o cheerio en Node en su lugar.

¿Cómo coincido caracteres Unicode?

Agrega la bandera u. Luego \w cubre más caracteres, y puedes usar escapes de propiedades Unicode de estilo \p{Letter} / \p{Script=Vietnamese} (Node 10+/todos los navegadores modernos).

¿Diferencia entre (?:…) y (…)?

(…) crea un grupo de captura numerado, accesible como $1 etc. (?:…) agrupa para el cuantificador sin capturar. Usa sin capturar cuando no necesites el valor — es ligeramente más rápido y mantiene tus índices de captura limpios.

¿Qué es lookahead y lookbehind?

Afirmaciones de ancho cero: (?=…) coincide si … sigue pero no lo consume; (?!…) coincide si … NO sigue; (?<=…) y (?<!…) son lo mismo para lo que precede. Útil para "coincide X pero solo cuando no seguido de Y" sin consumir Y.

JS regex vs PCRE — ¿qué es diferente?

JS es principalmente un subconjunto de PCRE con algunas diferencias. Sin comentarios en línea (?#…), sin cuantificadores posesivos, grupos nombrados usan (?<name>…) no (?P<name>…) (que es Python). No pegues regex aleatorio de internet en JS sin verificar.

¿Por qué mi patrón no coincide con saltos de línea?

. no coincide con \n por defecto. Agrega la bandera s (dotAll) para hacer que . coincida con cualquier carácter incluyendo salto de línea. Alternativa: usa [\s\S] que siempre coincide con cualquier cosa.