Probador de Regex

Cómo usar el probador de regex

1. Introduce tu patrón sin las barras que lo rodean, por ejemplo \d{3}-\d{4}.
2. Activa los flags que necesites (g, i, m, s, u, y).
3. Pega el texto de prueba. Las coincidencias se resaltan en directo y se muestra cada grupo de captura.
4. Si quieres, introduce una cadena de reemplazo, con $1 o $<name> para los grupos, y verás una vista previa del resultado.

El probador usa el propio motor de expresiones regulares JavaScript de tu navegador. Tus patrones y tus datos de prueba se quedan en tu dispositivo y no se suben ni se guardan.

Sintaxis de las expresiones regulares en JavaScript de un vistazo

Las variantes de expresiones regulares cambian de un lenguaje a otro. Esta herramienta usa la variante de JavaScript (ECMAScript), así que los resultados coinciden con lo que hacen RegExp, String.prototype.match y replace en los navegadores y en Node.js. La mayor parte de la sintaxis sirve también en Python, PCRE y Java, pero detalles como la sintaxis de los grupos con nombre o el soporte de lookbehind varían.

Flags

Elementos básicos

• Clases de caracteres: [abc], rangos [a-z], negación [^0-9], abreviaturas \d (dígito), \w (carácter de palabra), \s (espacio en blanco) y sus negaciones \D, \W, \S. Sin el flag u, \w y \d solo cubren ASCII.
• Cuantificadores: * (0 o más), + (1 o más), ? (0 o 1), {n}, {n,}, {n,m}. Añade ? para hacerlos perezosos: .*?.
• Grupos: (...) captura, (?:...) agrupa sin capturar, (?<year>\d{4}) crea un grupo con nombre, y \1 o \k<year> hacen referencia a él.
• Anclas: ^, $ y el límite de palabra \b.
• Lookarounds: (?=...) lookahead positivo, (?!...) lookahead negativo, (?<=...) lookbehind positivo, (?<!...) lookbehind negativo. Comprueban el contexto sin consumir caracteres.

// Importes precedidos de un signo de dólar, sin el signo
/(?<=\$)\d+(?:\.\d{2})?/g     "Total: $42.50"  →  "42.50"

// Cambiar el formato de fechas con grupos con nombre
"2024-03-15".replace(/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/, "$<d>.$<m>.$<y>")
// "15.03.2024"

Patrones habituales

Para direcciones IP en concreto, el conversor de direcciones IP analiza y convierte tanto IPv4 como IPv6.

Errores frecuentes

Backtracking catastrófico

Los cuantificadores anidados o solapados pueden hacer que un motor con backtracking, como el de JavaScript, pruebe un número exponencial de caminos cuando no hay coincidencia. Unas pocas decenas de caracteres pueden bloquear una pestaña del navegador o, en un servidor, permitir un ataque de denegación de servicio (ReDoS):

/^(a+)+$/.test("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!")   // puede bloquearse

/^a+$/.test("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!")       // instantáneo

Evita patrones como (a+)+, (a|a)* o (.*)*, haz que las alternativas se excluyan entre sí y sé específico: [^"]* es más seguro que .* entre comillas.

Otras trampas

• Una regex con el flag g recuerda lastIndex, así que llamar a test() varias veces sobre el mismo objeto alterna entre true y false.
• Al construir un patrón a partir de una cadena, hay que duplicar las barras invertidas: new RegExp("\\d+").
• Si olvidas ^ y $, un validador acepta cualquier entrada que simplemente contenga una coincidencia.

Preguntas frecuentes

¿Por qué mi regex funciona aquí pero no en Python o PHP?

Las variantes son distintas. Python escribe los grupos con nombre como (?P<name>...) y solo admite lookbehind de ancho fijo; el PCRE de PHP envuelve los patrones entre delimitadores. Las reglas de escape de los literales de cadena también cambian de un lenguaje a otro.

¿Qué diferencia hay entre cuantificadores codiciosos y perezosos?

Los cuantificadores codiciosos (.*) abarcan todo lo posible y luego retroceden; los perezosos (.*?) abarcan lo mínimo posible. Sobre <b>x</b>, <.*> coincide con toda la cadena, mientras que <.*?> solo coincide con <b>.

¿JavaScript admite lookbehind?

Sí, desde ES2018, y a diferencia de muchos motores admite lookbehind de longitud variable. Todos los navegadores principales actuales lo admiten.

¿Cómo busco un punto o un corchete literal?

Escápalo con una barra invertida: \., \[, \(. Dentro de una clase de caracteres la mayoría de los caracteres son literales, así que [.] también coincide con un punto.

Actualizado 2026-10-17