Probador de expresiones regulares

Un probador de expresiones regulares te muestra al instante dónde coincide el patrón

Una expresión regular (o regex) es una regla que describe la forma del texto que quieres encontrar. \d{4} significa «cuatro dígitos» y [A-Z][a-z]+ significa «una mayúscula seguida de minúsculas». La regla es corta, pero cambiar un solo símbolo puede alterar mucho lo que encuentra, así que conviene probar el patrón con texto real antes de llevarlo al código.

Esta herramienta ejecuta tu patrón con el motor de expresiones regulares de JavaScript del navegador que estás usando. Las coincidencias se resaltan en el texto, los grupos de captura se distinguen por color y se convierten en columnas de la tabla de coincidencias, y el patrón se desglosa en partes con una explicación sencilla de cada una. Por eso también sirve para entender una regex escrita por otra persona.

Por qué probar una regex antes de llevarla al código

Una regex puede fallar de dos maneras. Puede dejar pasar algo que debería encontrar (una comprobación de teléfono rechaza 612345678 porque espera espacios) o puede aceptar algo que no debería (un patrón de fecha admite 2026-13-45). Ninguno de los dos casos es un error de sintaxis, así que el navegador no avisa de nada. La comprobación más fiable es probar a la vez ejemplos que deben coincidir y ejemplos que no.

El tercer problema es la velocidad. El 2 de julio de 2019, Cloudflare desplegó una regex nueva en una regla de su cortafuegos de aplicaciones web (WAF). El retroceso (backtracking) se disparó, la CPU dedicada a servir HTTP se acercó al 100 % y el servicio estuvo caído 27 minutos. Según el informe que publicó la empresa, la causa fue un fragmento pequeño de un patrón largo: .*(?:.*=.*). Dos patrones que encuentran el mismo texto pueden diferir en cientos de veces en número de pasos, así que prueba con textos de longitud realista.

Probar una regex antes de usarla ayuda en situaciones como estas.

• Validar entradas: al decidir las reglas de teléfono, correo o contraseña de un formulario de registro, escribe en líneas distintas los ejemplos que deben pasar y los que deben bloquearse.
• Extraer valores: al sacar fechas, números de pedido o direcciones IP de registros, archivos CSV o una tabla copiada, comprueba que los valores de los grupos se separan bien. La tabla de coincidencias se puede pegar directamente en una hoja de cálculo.
• Reemplazos masivos: antes de ejecutar buscar y reemplazar en un editor o en el código, mira qué partes cambian y cómo queda el resultado.
• Leer la regex de otra persona: descubre qué busca un patrón de código antiguo, parte por parte, y comprueba si tiene alguna forma que pueda volverse lenta.

Cómo se usa

1. Escribe la regex en el campo Patrón, sin las barras de los extremos. Si pegas un literal completo como /abc/gi, la herramienta lo separa en patrón e indicadores.
2. Activa los indicadores con los botones de letra de al lado. Activa g para encontrar todas las coincidencias.
3. Pega tu texto en Texto de prueba. Las coincidencias se resaltan al momento y la línea de estado de arriba indica cuántas hay.
4. Para un patrón de validación (^…$), activa Probar cada línea y escribe un ejemplo por línea. Las líneas que pasan llevan ✓ y las que no, ✗.
5. En la tabla de coincidencias verás los valores de los grupos; al pulsar el número de una fila, esa coincidencia parpadea en el texto. En la pestaña Reemplazar escribes el texto de reemplazo y ves el resultado. La pestaña Código te da JavaScript para llevarte.

Cómo leer el desglose del patrón

El desglose divide el patrón en las unidades que lee el motor. Cada celda muestra arriba los símbolos originales y abajo su significado. Un cuantificador (+, {4}, etc.) se une a la celda anterior para leerlos juntos, como en «dígito 0–9, 4 veces». La barra de color bajo una celda indica el grupo de captura al que pertenece, y ese mismo color se usa en el subrayado del grupo en el texto y en el encabezado de columna de la tabla de coincidencias. Las celdas con borde discontinuo son grupos sin captura, anticipaciones, retrospectivas y «o».

Una celda con borde naranja marca una forma que puede hacer la búsqueda muy lenta: una repetición dentro de otra repetición, como (a+)+, o la misma repetición dos veces seguidas, como .*.*. Una celda roja señala el lugar de un error de sintaxis cuando el navegador rechaza el patrón.

Sintaxis habitual

La columna «Encuentra» de la tabla se obtuvo ejecutando cada texto de ejemplo con el mismo motor de JavaScript que usa esta herramienta.

Qué cambian los 8 indicadores

Un indicador es un ajuste que afecta a todo el patrón. El mismo patrón sobre el mismo texto puede dar resultados distintos según los indicadores.

u y v no pueden estar activados a la vez. Al activar uno, la herramienta desactiva el otro y lo indica en la línea de estado. La sintaxis más reciente, como el indicador v o los modificadores del tipo (?i:…), puede dar un error de sintaxis en un navegador antiguo.

Grupos de captura, grupos con nombre y referencias hacia atrás

Todo lo que va entre paréntesis ( ) se convierte en un grupo de captura, que se guarda por separado dentro de la coincidencia. Los grupos se numeran 1, 2, 3 según el orden de sus paréntesis de apertura, y un grupo como (?<y>…) tiene número y nombre. Si solo necesitas agrupar sin guardar, usa (?:…). Un grupo sin captura no ocupa número, así que los números de los grupos posteriores no cambian.

Para buscar de nuevo el texto que capturó un grupo anterior, usa una referencia hacia atrás: \1 o \k<nombre>. (\w)\1 encuentra el mismo carácter dos veces seguidas. Ten en cuenta también que, si un grupo se repite ((\d)+), solo se conserva el valor de la última repetición. En la tabla de coincidencias, un «—» indica que el grupo no participó en esa coincidencia (el grupo 1 de (a)|(b) cuando coincide b), y «vacío» indica que el grupo coincidió con una cadena vacía.

Símbolos que puedes usar en el texto de reemplazo

La pestaña Reemplazar sigue las mismas reglas que String.prototype.replace de JavaScript. La tabla usa el texto «Pedido 2026-10-22 enviado» con el patrón (\d{4})-(\d{2})-(\d{2}).

Un número mayor que la cantidad de grupos ($7) se queda como texto literal, y $0 también, porque no es un grupo. Para meter un salto de línea, pulsa Intro en el campo del texto de reemplazo. En el código, usa "\n" dentro de la cadena.

Tildes, la eñe y otras letras

En JavaScript, \w y \b consideran «caracteres de palabra» solo las letras A–Z y a–z, los dígitos y el guion bajo. Eso sigue siendo así con el indicador u activado. Por eso \w+ parte «café» en caf y deja fuera la última letra, y \bcafé\b no encuentra la palabra, porque entre é y un espacio no hay límite de palabra. [A-Za-z] tiene la misma limitación. Para el español hay dos soluciones: enumerar las letras ([a-záéíóúüñ], junto con el indicador i para las mayúsculas) o usar la propiedad Unicode \p{L}, que abarca las letras de cualquier escritura y necesita el indicador u.

El rango À-ÿ va de U+00C0 a U+00FF, así que también contiene el signo de multiplicación × y el de división ÷. Conviene saber además que una letra puede guardarse de dos formas: como un solo carácter (é) o como e más un acento combinado. \p{L}+ se detiene en el acento combinado porque esa marca no es una letra; usa [\p{L}\p{M}]+ si tu texto puede contener la segunda forma. La eñe y las vocales con diéresis (ü) funcionan igual que las demás letras de esa lista. Los signos de apertura ¿ y ¡ no son letras: ninguno de los patrones de la tabla los incluye.

Probar cada línea frente al indicador m

El indicador m comprueba todo el texto de una vez y hace que ^ y $ coincidan al principio y al final de cada línea. Por eso una coincidencia puede cruzar líneas (\s también acepta el salto de línea) y el resultado es solo un recuento de coincidencias. Probar cada línea corta el texto en líneas y comprueba cada una como un texto independiente. Ninguna coincidencia cruza una línea, cada línea recibe un pase (✓) o un fallo (✗), y la línea de estado dice algo como «Pasan 3 de 6 líneas». Cuando pruebas un patrón que debe validar un valor de entrada completo, como en un formulario de registro, probar cada línea equivale a lo que ocurre en el uso real. Reemplazar también trabaja línea por línea y vuelve a unirlas después.

Patrones lentos y el límite de 1 segundo

El motor de expresiones regulares de JavaScript busca una forma de que el patrón coincida y, cuando una elección falla, retrocede y prueba otro camino (backtracking). Un patrón en el que varias repeticiones pueden repartirse los mismos caracteres prueba todos los repartos cuando el texto no coincide. El informe de Cloudflare, al describir la parte problemática del patrón de forma simplificada como .*.*=.*, explicó que x=x coincide en 23 pasos, que un texto con 20 x detrás de x= necesita 555 pasos para coincidir y que 20 x sin = necesitan 4.067 pasos para fallar. Con un solo ; al final, .*.*=.*;, el texto con 20 x detrás de x= falla después de 5.353 pasos. Con una repetición dentro de otra, como (a+)+$, el número de intentos se duplica aproximadamente con cada carácter más.

Esta herramienta ejecuta el patrón en un proceso aparte (un Web Worker) y, si no ha terminado en 1 segundo, finaliza la tarea y te avisa. La página no se congela. Lo más probable es que la causa sean las celdas naranjas del desglose. Hay normalmente tres formas de arreglarlo.

• Quita la repetición dentro de la repetición. En lugar de (\w+\s?)+$, escribe \w+(?:\s\w+)*$, de modo que cada repetición tenga que incluir un carácter distinto (aquí, un espacio).
• Usa un conjunto que excluya el carácter de parada en lugar de .*. Si cambias .*.*=.* por [^=]*=.*, encuentra el mismo texto casi sin nada a lo que retroceder.
• Une las alternativas que pueden dividir el mismo texto de varias maneras. (\d|\d\d)+$ prueba todas las formas de cortar una serie de dígitos en trozos de una y dos cifras, mientras que \d+$ termina de una sola pasada.

Diferencias entre lenguajes

La sintaxis de las expresiones regulares varía un poco de un lenguaje a otro. Los resultados de esta herramienta siguen a JavaScript, así que revisa las diferencias siguientes cuando lleves un patrón a otro sitio. La tabla se obtuvo ejecutando los ejemplos en Node.js 26, Python 3.14 y PHP 8.5 (PCRE2 10.44); Java se comprobó con la documentación oficial de Java 21.

También cambia la longitud permitida dentro de una retrospectiva ((?<=…)). JavaScript acepta un patrón de longitud indefinida como (?<=a+). Python solo acepta una longitud fija. PHP, a partir de PCRE2 10.43, acepta patrones con un límite de longitud ((?<=a{1,3}), máximo por defecto de 255 caracteres). El \d de Python considera también dígitos los números de ancho completo «１２», mientras que el \d de JavaScript solo reconoce el 0–9.

Errores frecuentes

• Una sola barra invertida al crear el patrón desde una cadena: la cadena de JavaScript "\d+" se convierte en d+. Hay que escribirla dos veces, como en new RegExp("\\d+"). La línea «Creado desde una cadena» de la pestaña Código muestra el patrón con eso ya resuelto.
• Un punto sin escapar: 1.5 también coincide con «125». Escribe el punto literal como 1\.5.
• Llamar varias veces a test() con una regex con el indicador g: la regex recuerda su última posición (lastIndex), así que los resultados sobre el mismo texto alternan true, false, true. Si solo necesitas un sí o un no, es más seguro dejar g desactivado.
• El .* voraz: <.+> toma todo «<b>x</b>» de una vez. Para tomar las etiquetas una a una, usa <.+?> o <[^>]+>.
• Un patrón de validación sobre un texto de varias líneas: sin el indicador m, ^…$ trata todo el texto como una sola pieza, así que con varias líneas da 0 coincidencias. Para probar varios ejemplos, activa Probar cada línea.
• Querer validar un correo a la perfección con una sola regex: las direcciones que admite el estándar son tan variadas que un patrón sencillo deja fuera algunas o acepta de más. El patrón de correo de los ejemplos es un filtro aproximado; enviar un correo de confirmación es la forma habitual de estar seguro.

Límites

• Los resultados siguen el motor de expresiones regulares de JavaScript del navegador que usas. Los patrones de Python, Java, PHP y de los editores pueden diferir en sintaxis y resultados, como muestra la tabla anterior.
• Los límites son 1.000 caracteres para el patrón, 50.000 para el texto de prueba, 2.000 para el texto de reemplazo y 200.000 para el resultado. La tabla de coincidencias y el resaltado muestran las primeras 1.000 coincidencias; el recuento y el resultado del reemplazo incluyen todas.
• La ejecución se detiene al pasar 1 segundo. En un dispositivo lento, el mismo patrón puede tardar más.
• La marca «puede ser lento» del desglose solo busca formas habituales. Que un patrón no tenga la marca no garantiza que sea rápido con cualquier texto.
• «Línea:col.» de la tabla de coincidencias cuenta posiciones de cadena de JavaScript (UTF-16), por lo que un emoji ocupa dos columnas.
• El patrón y el texto que escribes se procesan solo dentro de tu navegador y no se envían a ningún servidor. Tampoco se guardan en la dirección ni en el almacenamiento, así que al recargar vuelve el primer ejemplo.

Base: la sintaxis y las reglas de reemplazo se comprobaron con la especificación ECMAScript y MDN, y los demás lenguajes con la documentación oficial de Python, Java y PHP y el registro de cambios de PCRE2, el 22 de octubre de 2026. Los ejemplos de las tablas se ejecutaron en Node.js 26 (V8), Python 3.14 y PHP 8.5 con los mismos resultados.

Fuentes

• 01ECMAScript: RegExp (Regular Expression) ObjectsSintaxis y reglas de ejecución de las regex de JavaScript
• 02ECMAScript: GetSubstitutionCómo se tratan $1, $<nombre>, $&, $`, $' y $$
• 03MDN: Regular expressionsIndicadores, modificadores (?i:…), indicador v, grupos con nombre
• 04MDN: String.prototype.replace()Símbolos especiales del texto de reemplazo
• 05MDN: Character class escapeLos caracteres que aceptan \d, \w y \s
• 06Cloudflare: Details of the Cloudflare outage on July 2, 2019Caída de 27 minutos por el backtracking de una regex del WAF, pasos de .*.*=.*
• 07Python: re — Regular expression operations(?P<nombre>…), \g<nombre>, retrospectiva de longitud fija, cuantificadores posesivos en 3.11
• 08Java 21: Pattern\w = [a-zA-Z_0-9] sin UNICODE_CHARACTER_CLASS, cuantificadores posesivos
• 09PHP: preg_replace$n, \n y ${n} en el texto de reemplazo
• 10PCRE2 ChangeLog10.43: retrospectiva de longitud variable con límite (255 por defecto)
• 11Unicode: Latin-1 Supplement (0080–00FF)Letras latinas con tilde del rango À–ÿ

Preguntas frecuentes

Herramientas relacionadas