🔣 Probador de expresiones regulares

Prueba patrones de expresiones regulares en tiempo real y visualiza los resultados de coincidencia. Ofrece configuración de indicadores, captura de grupos y una biblioteca de patrones comunes.

Patrón regex

Indicadores

g (búsqueda global) i (sin distinguir mayúsculas/minúsculas) m (multilínea) s (el punto coincide con saltos de línea) u (unicode) y (posición fija)

Cadena de prueba

Patrones comunes

GUÍA

Más información

1. Fundamentos de las expresiones regulares

Las expresiones regulares (Regex) son herramientas potentes para definir, buscar, extraer y reemplazar patrones de cadenas de texto. Pueden coincidir literalmente (\d para dígitos, \w para caracteres de palabra) o usar caracteres especiales para expresar patrones complejos. Ejemplo: ^[a-z]+$ significa una cadena que contiene solo letras minúsculas. ^ indica el inicio, $ el final, [a-z] va de a a z, y + significa uno o más. Son compatibles con casi todos los lenguajes de programación y editores de texto, y son esenciales para la validación de entradas, el análisis de datos y el reemplazo de texto.

2. Colección de patrones comunes

Patrones regex utilizados frecuentemente en la práctica. Email: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$, Teléfono (España): ^(\+34|0034|34)?[6789]\d{8}$, URL: ^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b, Fecha (AAAA-MM-DD): ^\d{4}-\d{2}-\d{2}$, Contraseña (mínimo 8 caracteres, mayúscula+minúscula+dígito+carácter especial): ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$. Usa estos patrones como base y modifícalos según tu proyecto.

3. Explicación de los indicadores regex

Los indicadores regex controlan el comportamiento de la búsqueda. g(global): encuentra todas las coincidencias, no solo la primera. i(ignoreCase): coincidencia sin distinguir mayúsculas/minúsculas (/hello/i coincide con Hello, HELLO). m(multiline): ^ y $ coinciden con el inicio/fin de cada línea. s(dotAll): el punto (.) también coincide con los saltos de línea (\n). u(unicode): maneja correctamente todo el Unicode (emojis, etc.). y(sticky): comienza la búsqueda solo en la posición lastIndex. Ejemplo: /hello/gi encuentra todos los "hello" ignorando mayúsculas/minúsculas.

4. Grupos de captura y referencias inversas

Los paréntesis () crean grupos que capturan las partes coincidentes para su uso posterior. Ejemplo: /(\d{4})-(\d{2})-(\d{2})/ donde $1 es el año, $2 el mes y $3 el día. El array de resultados de match() en JavaScript incluye los grupos de captura. Las referencias inversas \1, \2 coinciden con el mismo texto que los grupos anteriores. Ejemplo: /(\w+)\s+\1/ coincide con "hello hello". Los grupos sin captura (?:) agrupan sin capturar, lo que mejora el rendimiento.

5. Anticipación (lookahead) y retrospección (lookbehind)

La anticipación (lookahead) y la retrospección (lookbehind) comprueban un patrón antes/después sin incluirlo en la coincidencia. Anticipación positiva (?=): /\d(?=px)/ solo coincide con dígitos antes de "px" ("100" en "100px"). Anticipación negativa (?!): /\d(?!px)/ coincide con dígitos que no preceden a "px". Retrospección positiva (?<=): /(?<=\$)\d+/ solo coincide con dígitos después de "$" ("100" en "$100"). Retrospección negativa (?<!): lo contrario. Se usan con frecuencia en la validación de contraseñas para comprobar la inclusión de caracteres específicos.

6. Optimización del rendimiento de las regex

Las expresiones regulares complejas pueden causar problemas de rendimiento. Sé lo más específico posible ([a-z]+ en lugar de .*). Sustituye los grupos de captura innecesarios por grupos sin captura (?:). Para reducir el retroceso (backtracking), usa cuantificadores perezosos (*?, +?) en lugar de codiciosos (*, +). En textos grandes, los métodos de cadena (indexOf, startsWith) pueden ser más rápidos que las regex. Precompila las regex para reutilizarlas (evita crear new RegExp repetidamente). Ten cuidado con los ataques ReDoS (Regular Expression Denial of Service): nunca uses la entrada del usuario directamente como patrón regex.

Preguntas frecuentes

¿Qué diferencia hay entre los indicadores g, i y m?

g (global) busca todas las coincidencias en vez de solo la primera, i (ignoreCase) ignora mayúsculas y minúsculas, y m (multiline) hace que ^ y $ coincidan con el inicio y fin de cada línea en vez de todo el texto.

¿Cómo funcionan los grupos de captura con paréntesis?

Los paréntesis () capturan la parte del patrón que coincide para poder reutilizarla; por ejemplo, en /(\d{4})-(\d{2})-(\d{2})/ el primer grupo captura el año, el segundo el mes y el tercero el día.

¿Qué es un ataque ReDoS y cómo lo evito?

Un ataque ReDoS ocurre cuando un patrón regex mal construido provoca un tiempo de ejecución exponencial ante ciertas entradas maliciosas. Para evitarlo, evita patrones ambiguos con cuantificadores anidados y nunca uses la entrada del usuario directamente como patrón regex.

¿Cuál es la diferencia entre cuantificadores codiciosos y perezosos?

Los codiciosos (*, +) intentan capturar la mayor cantidad de texto posible, mientras que los perezosos (*?, +?) capturan la menor cantidad posible, lo que reduce el retroceso (backtracking) y mejora el rendimiento en patrones complejos.

¿Por qué mi patrón no encuentra ninguna coincidencia?

Revisa que los caracteres especiales estén escapados correctamente (por ejemplo, un punto literal debe escribirse \.), que los indicadores necesarios (como g o i) estén activados, y que la cadena de prueba realmente contenga el patrón esperado.