Probador Regex

Probador regex online gratis con coincidencias en vivo, grupos con nombre, lookahead/lookbehind y modo de reemplazo con tokens $1 y $.

¿Tienes comentarios? Reporta errores, sugiere funciones o comparte tus ideas — leemos todos

Probador Regex - Probar y Depurar Expresiones Regulares Online

Un potente probador de expresiones regulares online que le ayuda a probar, depurar y aprender patrones regex. Presenta coincidencias en tiempo real con resaltado de sintaxis, visualización de grupos de captura, soporte de todos los flags regex de JavaScript e información detallada de coincidencias. Perfecto para desarrolladores y cualquiera trabajando con coincidencia de patrones.

¿Qué es una expresión regular y para qué sirve?

Una expresión regular (regex o regexp) es una secuencia de caracteres que define un patrón de búsqueda, utilizada para coincidencia de cadenas, validación, extracción y sustitución. El concepto fue formalizado por Stephen Kleene en los años 50 y popularizado por el comando grep de Ken Thompson en 1968. Los motores modernos potencian la validación de entradas (correos, teléfonos, códigos postales), el análisis de logs, buscar y reemplazar en editores, el enrutamiento de URLs y el análisis léxico de compiladores. Todo lenguaje importante incluye un motor: RegExp en JavaScript, re en Python, Pattern en Java, Regex en .NET y PCRE en PHP. Aunque la sintaxis varía entre sabores (POSIX BRE, ERE, PCRE, RE2, ECMAScript), los bloques básicos — clases de caracteres, cuantificadores, anclajes, grupos y alternancia — son universales.

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

Por defecto, los cuantificadores como *, +, ? y {n,m} son codiciosos: coinciden con lo máximo posible mientras el patrón global tenga éxito. El patrón <.+> sobre <b>negrita</b> captura toda la cadena, no solo <b>, porque + consume hasta el último >. Los cuantificadores perezosos (no codiciosos) agregan ? — <.+?> captura solo <b>, tomando la subcadena más pequeña que funcione. Los posesivos agregan + (++, *+, ?+) y nunca retroceden tras coincidir, lo que mejora el rendimiento y previene el retroceso catastrófico, pero pueden fallar donde el codicioso tendría éxito. PCRE, Java y Ruby soportan posesivos; JavaScript y Python no (use grupos atómicos (?>...) cuando estén disponibles).

¿Qué son los anclajes, lookahead y lookbehind?

Los anclajes coinciden con posiciones, no con caracteres. ^ marca el inicio (o de línea en modo multilínea), $ el final, \b un límite de palabra, y \A / \Z el inicio / fin absoluto. El lookahead (?=...) y el negativo (?!...) afirman lo que sigue sin consumirlo: q(?=u) coincide con q solo si le sigue u. El lookbehind (?<=...) y (?<!...) afirman lo precedente: (?<=\$)\d+ captura un número precedido de signo dólar. JavaScript ganó lookbehind en ES2018; los navegadores antiguos y RE2 (usado por Go y Cloudflare) no lo soportan. Los lookarounds son de ancho cero: afectan la coincidencia pero no aportan caracteres al resultado final.

¿En qué se diferencian los grupos de captura, no captura y nombrados?

Los paréntesis (abc) crean un grupo de captura que agrupa para cuantificadores y guarda la subcadena para retroreferencias (\1) o extracción. Los grupos sin captura (?:abc) agrupan sin guardar, son más rápidos y no saturan el arreglo de coincidencias — úselos siempre que solo necesite agrupar. Los grupos nombrados (?<nombre>abc) (PCRE/Python/.NET/ES2018+) guardan bajo un nombre legible accesible vía match.groups.nombre, haciendo los patrones autodocumentados. Un regex como (?<anio>\d{4})-(?<mes>\d{2})-(?<dia>\d{2}) descompone una fecha ISO en campos etiquetados. Las retroreferencias \k<nombre> o \1 permiten volver a coincidir el mismo texto — útiles para hallar palabras duplicadas como \b(\w+)\s+\1\b.

¿Cómo pruebo un reemplazo / sustitución regex con $1 y grupos con nombre?

Active el modo Reemplazo / Sustitución y escriba una cadena de reemplazo que referencie el texto capturado con tokens. En String.replace de JavaScript (que usa esta herramienta), $1, $2, $3 insertan grupos de captura posicionales, $<nombre> inserta un grupo con nombre, $& inserta toda la coincidencia, $` inserta todo lo anterior a la coincidencia y $' inserta todo lo posterior. Por ejemplo, el patrón (?<anio>\d{4})-(?<mes>\d{2})-(?<dia>\d{2}) con el reemplazo $<dia>/$<mes>/$<anio> reescribe 2026-05-29 como 29/05/2026 — el clásico reformateo de fecha ISO a DMA. Sin el flag global g, solo se reemplaza la PRIMERA coincidencia (comportamiento nativo); agregue g para reemplazar todas. Esto refleja sed s/viejo/nuevo/g, el buscar y reemplazar de los editores y los flujos de reescritura de logs, así que puede crear y verificar la sustitución aquí antes de pegarla en su código.

Probador Regex — Probador regex online gratis con coincidencias en vivo, grupos con nombre, lookahead/lookbehind y modo de reemplazo con — **Probador Regex**

¿Qué son los flags comunes (g, i, m, s, u, y) y qué hacen?

Los flags modifican el comportamiento global del regex. g (global) devuelve todas las coincidencias, necesario para replaceAll en JavaScript. i (insensible a mayúsculas) hace que [A-Z] coincida con a-z. m (multilínea) cambia ^ y $ para marcar inicios y finales de línea, no de cadena. s (dotall, ES2018+) permite que . coincida con saltos de línea. u (unicode) activa el modo Unicode completo con pares suplentes y escapes \p{Script=Latin}. y (sticky) ancla la coincidencia en lastIndex, útil para tokenizadores. Python usa constantes re.IGNORECASE, re.MULTILINE, re.DOTALL en lugar de letras. Combine los flags: /patron/gim o (?gim) en línea.

¿Por qué algunos regex congelan el navegador? (retroceso catastrófico)

El retroceso catastrófico ocurre cuando un regex prueba exponencialmente muchas formas de coincidir antes de rendirse. El ejemplo clásico es (a+)+b contra aaaaaaaaaaaaaaaaaa (sin b): el motor prueba cada partición de las a entre el + interior y exterior, lo que da 2^n intentos. Los ataques ReDoS (Denegación de Servicio por Expresión Regular) lo aprovechan — una sola entrada maliciosa puede congelar un servidor por minutos. La guía de OWASP recomienda: evitar cuantificadores anidados ((a+)+, (a*)*), evitar alternancias solapadas ((a|a)+), preferir grupos atómicos (?>a+)+ o cuantificadores posesivos a++, y usar motores de tiempo lineal como RE2 (Go, Cloudflare) o el crate regex de Rust para entradas no confiables. Pruebe patrones con el depurador de regex101 o el linter regexploit.

¿Cuáles son las diferencias entre POSIX BRE, ERE, PCRE y RE2?

POSIX BRE (Básico, usado por sed y grep) requiere barras invertidas ante metacaracteres: $grupo$, \{2,3\}, \+ es literal. POSIX ERE (Extendido, usado por egrep y awk) trata esos caracteres como especiales por defecto — más cercano a la sintaxis moderna. PCRE (Perl Compatible, usado por PHP, NGINX y muchas herramientas) es el estándar moderno de facto: soporta lookaround, grupos nombrados, retroreferencias, recursión y condicionales. RE2 (Google, usado por Go, Cloudflare, Sourcegraph) omite deliberadamente retroreferencias y lookaround para garantizar tiempo lineal, eliminando ReDoS. El regex de ECMAScript (JavaScript) se parece a PCRE pero carece de algunas funciones (recursión, condicionales) y añade el flag y. Siempre consulte la documentación del motor — un patrón PCRE funcional puede fallar en RE2 o grep.

¿Cómo escapo caracteres especiales y manejo Unicode correctamente?

Doce metacaracteres requieren escape con barra invertida: . ^ $ * + ? ( ) [ ] { } | \. Para coincidir con un punto literal, use \.. Dentro de clases [...], solo ] \ ^ - necesitan escape, y ^ solo en la posición 1. Para patrones dinámicos con entrada de usuario, use una función de escape de la biblioteca (propuesta RegExp.escape, re.escape en Python, preg_quote en PHP) — nunca concatene entrada cruda. Para Unicode, habilite el flag u y use escapes de propiedad: \p{L} (cualquier letra), \p{N} (número), \p{Script=Han} (caracteres chinos), \p{Emoji}. El obsoleto \w solo coincide con caracteres ASCII por defecto — para nombres internacionales use [\p{L}\p{N}_]. Los pares suplentes (emojis, CJK raros) solo funcionan correctamente con el flag u en JavaScript.