Regex Tester
Test regular expressions with highlighting
Probador de Expresiones Regulares Online - Regex Tester
¿Qué son las expresiones regulares (regex) y para qué sirven?
Las expresiones regulares, conocidas como regex o regexp, son patrones de texto que describen conjuntos de cadenas de caracteres. Son una herramienta extremadamente poderosa para: buscar texto que coincida con patrones complejos, validar formatos de entrada (emails, teléfonos, URLs, códigos postales), extraer información específica de textos grandes, buscar y reemplazar con patrones en editores y código, parsing de logs y archivos de configuración, y procesamiento de texto en cualquier lenguaje de programación. Aunque la sintaxis puede parecer críptica inicialmente, dominar regex es una habilidad fundamental para cualquier desarrollador.
¿Cuál es la sintaxis fundamental de expresiones regulares?
Los metacaracteres básicos son: . (cualquier carácter excepto newline), * (cero o más del anterior), + (uno o más), ? (cero o uno), ^ (inicio de línea), $ (final de línea), [] (clase de caracteres, cualquiera dentro), () (grupos de captura), | (alternativa OR), {} (cuantificadores exactos como {3} o rangos {1,5}), y \ (escape de metacaracteres). Las clases predefinidas simplifican patrones comunes: \d (dígitos 0-9), \w (word characters: letras, números, guión bajo), \s (espacios, tabs, newlines), y sus inversos en mayúscula (\D, \W, \S).
¿Cómo usar expresiones regulares en JavaScript?
JavaScript soporta regex nativamente con sintaxis literal /patrón/flags o constructor new RegExp("patrón", "flags"). Los métodos principales son: regex.test(string) retorna true/false para validación, string.match(regex) retorna array de coincidencias o null, string.replace(regex, replacement) sustituye matches, y string.split(regex) divide por patrón. Los flags modifican comportamiento: g (global, todas las coincidencias), i (case insensitive), m (multiline, ^ y $ por línea), s (dotall, . incluye newlines), y u (unicode). Esta herramienta te permite probar patrones interactivamente antes de implementarlos.
Preguntas frecuentes
¿Por qué mi expresión regular es lenta o bloquea el navegador?
Probablemente sufres de "catastrophic backtracking", que ocurre con patrones ambiguos que tienen múltiples formas de coincidir. Ejemplos problemáticos: (a+)+ con input "aaaaaaaaaaaaaaaaaaaaab", (.*)* o patrones con cuantificadores anidados. El motor de regex intenta exponencialmente muchas combinaciones antes de fallar. Soluciones: evita cuantificadores anidados (a*)*, usa cuantificadores posesivos o atómicos si tu motor los soporta, simplifica alternativas, y considera si regex es la herramienta correcta para parsing complejo (a veces un parser dedicado es mejor).
¿Cómo capturo grupos con nombres legibles en regex?
Usa grupos nombrados con sintaxis (?<nombre>patrón) disponible en JavaScript ES2018+, Python 3.x, PHP 7+, y otros lenguajes modernos. Ejemplo: /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/ para parsear fechas. Accede al resultado con match.groups.year en JavaScript. Los grupos nombrados son mucho más legibles que índices numéricos (match[1], match[2]) especialmente en patrones complejos con múltiples capturas, y hacen el código más mantenible.
¿Cuál es la diferencia entre .* (greedy) y .*? (lazy)?
.* es "codicioso" (greedy): intenta capturar la mayor cantidad posible de caracteres que permitan que el resto del patrón coincida. .*? es "perezoso" o "reluctant" (lazy): captura la menor cantidad necesaria. Ejemplo práctico: en el string "abc123def456", el patrón /.+\d/ (greedy) captura "abc123def456" tomando todo hasta el último dígito, mientras que /.+?\d/ (lazy) captura solo "abc1" deteniéndose en el primer dígito. La elección depende de qué comportamiento necesitas para tu caso de uso específico.