Métrico Imperial
🌐 ES
English Español

🔣 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.

Patrones comunes

GUÍA

Más información

01

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.

02

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.

03

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.

04

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.

05

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.

06

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.