Probador y Depurador de Regex

Prueba y depura expresiones regulares JavaScript en tu navegador.

Sin subidasSin registroResultados instantáneos
Banderas g · i · m · s · u · v · yGrupos de captura y con nombre + Reemplazo100% Local • Cero Subidas
Probar expresión regular
Motor local listoEspacio de trabajo 100% privado en el navegador • Sin subidas a la nube
100 % Privado • Sin cargas de archivos a servidores

¿Por qué usar Probador y Depurador de Regex gratis en Utiliome?

Diseñado para máxima privacidad, ejecución instantánea y sin fricción. Sin suscripciones ni registros.

Paridad Nativa con ECMA-262 RegExp

Se ejecuta directamente sobre el motor de expresiones regulares ECMAScript de tu navegador con activación instantánea de flags para los modos global (g), insensible a mayúsculas (i), multilínea (m), dotAll (s), Unicode (u) y sticky (y).

Inspector de Capturas Indexadas y con Nombre

Extrae rangos de unidades de código UTF-16 basados en cero [start, end), subcoincidencias numeradas ($1 a $99) y diccionarios de capturas con nombre ((?<name>...)) para cada coincidencia en textos multilínea.

Vista Previa de Sustitución y Retroreferencias en Vivo

Evalúa plantillas de String.prototype.replace y replaceAll en tiempo real usando $1, $<name>, $& (coincidencia completa), $' (sufijo posterior a la coincidencia) y tokens de escape de dólar literal $$.

Detección de ReDoS y Privacidad Sin Subidas

Resalta construcciones de cuantificadores anidados propensas a backtracking catastrófico mientras mantiene logs de producción sensibles, bearer tokens y datos personales (PII) estrictamente en la memoria local del navegador.

Utiliome vs Alternativas en la nube tradicionales

Compara nuestro motor local en WebAssembly frente a herramientas en la nube.

Característica Utiliome (Navegador local) Convertidores en la nube tradicionales
Paridad Nativa con ECMA-262 RegExp Se ejecuta directamente sobre el motor de expresiones regulares ECMAScript de tu navegador con activación instantánea de flags para los modos global (g), insensible a mayúsculas (i), multilínea (m), dotAll (s), Unicode (u) y sticky (y). Opciones limitadas sin personalización avanzada
Inspector de Capturas Indexadas y con Nombre Extrae rangos de unidades de código UTF-16 basados en cero [start, end), subcoincidencias numeradas ($1 a $99) y diccionarios de capturas con nombre ((?<name>...)) para cada coincidencia en textos multilínea. Requiere herramientas externas o ajustes manuales
Privacidad y Procesamiento 100% local en tu navegador (cero subidas al servidor) Sube los datos a servidores externos en la nube
Precio y Registro 100% gratis para siempre y sin crear cuenta Requiere registro de cuenta o suscripción de pago
Cómo funciona

Cómo usar Probador y Depurador de Regex en 3 sencillos pasos

Sin instalación de software. Todo funciona directamente dentro de tu navegador web.

1

Ingresa el Patrón y Activa los Flags del Motor

Escribe el cuerpo de tu expresión regular sin barras delimitadoras y habilita los flags exactos de ECMAScript (g, i, m, s, u, y) utilizados por tu entorno de ejecución de JavaScript o TypeScript.

2

Pega el Texto de Prueba e Inspecciona las Capturas

Pega cadenas de prueba o carga un archivo de log local para inspeccionar los límites de coincidencia resaltados, los rangos de índices de caracteres, las posiciones de captura numeradas y los mapeos de grupos (?<name>...).

3

Previsualiza Sustituciones y Copia la Expresión

Ingresa una cadena de reemplazo opcional con referencias $1, $<name> o $& para verificar el texto transformado en vivo y luego copia tu literal de regex validado.

Depuración de Logs Estructurados con Grupos de Captura con Nombre y Sustituciones en Vivo

Respuesta rápida: Combina grupos de captura con nombre ((?<name>...)) con los flags global (g) y multilínea (m) para analizar líneas de logs estructurados en diccionarios clave-valor, verificar offsets exactos de coincidencia en UTF-16 y previsualizar transformaciones de cadenas con $<name> antes de desplegar código en producción.

Al depurar expresiones regulares frente a telemetría multilínea o logs de acceso, los errores sutiles en anclas o cuantificadores suelen provocar fallos silenciosos de coincidencia o desplazamientos en los grupos numerados. Considera dos líneas de log de aplicación estructuradas que contienen marcas de tiempo ISO-8601, etiquetas de severidad, identificadores de servicio, IDs de traza hexadecimales de 16 caracteres, códigos de estado HTTP y latencias en coma flotante:

2026-11-01T14:22:08.419Z [ERROR] svc=checkout trace_id=4bf92f3577b34da6 status=502 latency_ms=184.7
2026-11-01T14:22:09.004Z [INFO] svc=inventory trace_id=00f067aa0ba902b7 status=200 latency_ms=12.3

Para analizar cada línea de forma determinista sin depender de un indexado posicional frágil de arrays, vincula cada campo mediante un grupo de captura con nombre de ECMAScript ((?<name>...)), envuelve el sufijo fraccionario opcional de milisegundos en un grupo sin captura ((?:...)) y habilita tanto g (iteración global) como m (anclas ^ y $ por línea):

^(?<ts>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[(?<level>ERROR|WARN|INFO)\]\s+svc=(?<service>[a-z0-9_-]+)\s+trace_id=(?<trace>[0-9a-f]{16})\s+status=(?<status>\d{3})\s+latency_ms=(?<ms>\d+(?:\.\d+)?)$

Sin el flag m, ^ y $ se anclan exclusivamente al índice 0 y al final de todo el búfer, haciendo que la expresión falle tan pronto como un salto de línea (\n) separe los registros. Con gm activo, el depurador de grupos de captura resuelve cada iteración de coincidencia tanto en subcoincidencias posicionales basadas en 1 como en un objeto estructurado groups:

{
  "matchIndex": 0,
  "span": [0, 99],
  "fullMatch": "2026-11-01T14:22:08.419Z [ERROR] svc=checkout trace_id=4bf92f3577b34da6 status=502 latency_ms=184.7",
  "captures": [
    "2026-11-01T14:22:08.419Z",
    "ERROR",
    "checkout",
    "4bf92f3577b34da6",
    "502",
    "184.7"
  ],
  "groups": {
    "ts": "2026-11-01T14:22:08.419Z",
    "level": "ERROR",
    "service": "checkout",
    "trace": "4bf92f3577b34da6",
    "status": "502",
    "ms": "184.7"
  }
}

Una vez verificados los límites de captura, puedes probar el formateo de String.prototype.replaceAll directamente en el panel de sustitución. Al proporcionar la plantilla [$<level>] $<service>: HTTP $<status> ($<ms>ms, trace=$<trace>), se obtiene una salida normalizada de inmediato:

[ERROR] checkout: HTTP 502 (184.7ms, trace=4bf92f3577b34da6)
[INFO] inventory: HTTP 200 (12.3ms, trace=00f067aa0ba902b7)

Semántica del Motor RegExp ECMA-262, Mecánica de Flags y Backtracking Catastrófico

Respuesta rápida: Las expresiones regulares de JavaScript se ejecutan en un NFA con backtracking definido por la Sección 22.2 de ECMA-262, operando sobre unidades de código UTF-16 de 16 bits a menos que el flag u habilite la coincidencia de valores escalares Unicode completos. Evitar cuantificadores anidados ambiguos previene bloqueos exponenciales O(2^n) por ReDoS.

Ejecución NFA con Backtracking y Estado en `lastIndex`

A diferencia de los motores puros de Autómatas Finitos Deterministas (DFA), los motores ECMAScript (V8 Irregexp, JavaScriptCore Yarr, SpiderMonkey) implementan un Autómata Finito No Determinista (NFA) con backtracking para admitir retroreferencias (\1, \k<name>) y aserciones lookaround arbitrarias ((?=...), (?!...), (?<=...), (?<!...)). Las alternativas separadas por | se evalúan de izquierda a derecha; los cuantificadores codiciosos o greedy (*, +, ?, {m,n}) consumen tantos caracteres como sea posible antes de retroceder paso a paso para satisfacer los tokens posteriores, mientras que los cuantificadores perezosos o reluctant (*?, +?, ??, {m,n}?) prueban primero la expansión más corta.

Cuando se establece g (global) o y (sticky), RegExp.prototype.exec() lee y muta la propiedad lastIndex de la instancia:

  • Global (g): Busca en o después de lastIndex, avanzando lastIndex hasta el offset final de cada coincidencia (o incrementándolo en un punto de código Unicode en coincidencias de longitud cero) y restableciéndolo a 0 cuando falla.
  • Sticky (y): Ancla la coincidencia estrictamente en lastIndex sin escanear hacia adelante. Si ninguna coincidencia comienza en lastIndex, la búsqueda falla de inmediato y restablece lastIndex a 0, lo que hace que y sea ideal para construir analizadores léxicos sin copias (zero-copy).

Terminadores de Línea, Sustitutos UTF-16 y el Flag `u`

ECMA-262 reconoce exactamente cuatro puntos de código terminadores de línea: \n (U+000A), \r (U+000D), Separador de Línea (U+2028) y Separador de Párrafo (U+2029). Habilitar m hace que ^ y $ coincidan con los límites adyacentes a esos cuatro puntos de código; habilitar s (dotAll) permite que . coincida con ellos.

Por defecto, las cadenas de JavaScript se indexan como secuencias de unidades de código UTF-16 de 16 bits. Los caracteres Unicode suplementarios por encima de U+FFFF (como emojis o símbolos matemáticos) ocupan un par sustituto de dos unidades (sustituto alto 0xD800–0xDBFF seguido de sustituto bajo 0xDC00–0xDFFF). Sin u, /^.$/.test("🚀") evalúa a false porque "🚀".length es 2. Habilitar u cambia la evaluación a valores escalares Unicode de 21 bits, desbloquea escapes de propiedades Unicode (\p{Letter}, \p{Script=Latin}, \P{Control}) y desactiva los escapes de identidad permisivos heredados del Anexo B para que los escapes inválidos fallen rápidamente en tiempo de compilación.

Gramática de Reemplazo `GetSubstitution` de ECMA-262

El reemplazo en vivo sigue la tabla estándar GetSubstitution:

  • $$: Inserta un único carácter literal $.
  • $&: Inserta la subcadena coincidente completa (match[0]).
  • $': Inserta la subcadena posterior al rango coincidente.
  • $n / $nn: Inserta la captura numerada n indexada desde 1 (1 a 99).
  • $<name>: Inserta la cadena capturada por (?<name>...), o una cadena vacía "" cuando el grupo con nombre no participó en la rama de coincidencia actual.

Prevención del Backtracking Catastrófico (ReDoS)

La Denegación de Servicio por Expresión Regular (ReDoS) surge cuando cuantificadores anidados o superpuestos —como (a+)+$, ([a-zA-Z0-9]+\s?)*$ o (.*a){12}— coinciden con subcadenas idénticas a través de un número exponencial de particiones (O(2^n) pasos) antes de fallar en un carácter final. Dado que ECMA-262 omite los cuantificadores posesivos (++) y los grupos atómicos ((?>...)), refuerza tus patrones mediante:

  1. Conjuntos de Caracteres Mutuamente Excluyentes: Reemplaza .* codiciosos entre delimitadores por clases negadas como [^,\r\n]* para que el motor no pueda cruzar los límites del delimitador.
  2. Desenrollado de Delimitadores: Reescribe ^(\w+-?)+$ (ambiguo cuando falta -) como ^\w+(?:-\w+)*$, reduciendo la complejidad en el peor caso a un tiempo estrictamente lineal O(n).
  3. Emulación Atómica con Lookahead: Cuando deba prohibirse el backtracking dentro de una subexpresión, captura dentro de un lookahead positivo y consume mediante una retroreferencia inmediata: (?=(\w+))\1.

Probador de Regex vs Generador de Regex: ¿Cuál Necesitas?

Respuesta rápida: Usa el Probador y Depurador de Regex cuando ya tengas un patrón y necesites inspeccionar offsets de coincidencia, depurar grupos de captura con nombre, alternar flags de ECMAScript o probar reemplazos de cadenas con $<name> frente a cargas reales. Usa el Generador de Regex cuando quieras ensamblar una nueva expresión visualmente o exportar código regex multilenguaje.

Aunque las pruebas y la síntesis pertenecen al mismo flujo de trabajo de expresiones regulares, resuelven problemas de ingeniería distintos. El Probador y Depurador de Regex es un banco de pruebas diagnóstico e interactivo para inspeccionar cómo se comporta un patrón ECMAScript existente frente a entradas complejas del mundo real. Si, por el contrario, necesitas componer una nueva expresión a partir de bloques visuales, partir de una plantilla alineada con estándares RFC o exportar código con escapes para Python, Go o Rust, cambia al Generador de Regex.

Capacidad Probador y Depurador de Regex Generador de Regex
Tarea Principal de Ingeniería Depurar coincidencias, rangos de captura, flags y reemplazos en patrones existentes Construir visualmente nuevos patrones desde bloques o plantillas RFC verificadas
Entrada Inicial Expresión regex en bruto, flags ECMAScript y texto de prueba o logs multilínea Bloques de tokens componibles o recetas para desarrolladores (UUID, SemVer, IPv4, ISO-8601)
Depuración de Grupos de Captura Rangos completos de offset [start, end), posiciones de array $1–$99 y diccionario (?<name>...) Validación pasa/falla con casos de prueba positivos y negativos
Sustitución de Cadenas en Vivo Vista previa en tiempo real de replace / replaceAll con $1, $<name>, $& y $$ No enfocado en plantillas de transformación de texto
Exportación de Código Multilenguaje Literal de regex y salida de patrón para ECMAScript / JavaScript Fragmentos idiomáticos para JavaScript, Python (re), Go (regexp) y Rust (regex)
Enfoque de Arquitectura de Motor Semántica nativa NFA con backtracking de ECMA-262 y detección de ReDoS Portabilidad entre motores para ECMA-262, Python re y RE2 de tiempo lineal

Flujo de Trabajo Recomendado

Comienza en el Generador de Regex al estructurar reglas de validación para identificadores como versiones semánticas, UUIDs RFC 9562 o slugs de URL en servicios políglotas. Una vez que el patrón esté desplegado en un frontend o pipeline de Node.js —o cada vez que una expresión omita inesperadamente un caso borde en logs de producción—, pega la expresión y la muestra de log sin procesar aquí en el Probador y Depurador de Regex para inspeccionar los rangos de caracteres por coincidencia, las interacciones de flags con lastIndex y las plantillas de sustitución.

Preguntas frecuentes

Preguntas frecuentes y guía técnica de Probador y Depurador de Regex

Todo lo que necesitas saber sobre el uso gratuito en línea de probador de regex online en Utiliome.

¿Por qué una regex global devuelve resultados true y false alternados con RegExp.prototype.test() en JavaScript?

Cuando el flag global (g) o sticky (y) está activo en un objeto RegExp de JavaScript, llamar a .test() o .exec() muta la propiedad lastIndex de la instancia para apuntar inmediatamente después de la subcadena coincidente. La siguiente llamada a .test() reanuda el escaneo desde lastIndex en lugar del índice 0; una vez que llega al final de la cadena sin encontrar otra coincidencia, devuelve false y restablece lastIndex a 0. Para una validación booleana sin estado, omite el flag g o restablece regex.lastIndex = 0 explícitamente.

¿Cuál es la diferencia entre grupos de captura indexados, grupos sin captura y grupos de captura con nombre?

Los paréntesis estándar (...) almacenan las subcadenas coincidentes en posiciones de captura secuenciales basadas en 1 ($1, $2) y en el array devuelto por exec(). Los grupos sin captura (?:...) agrupan tokens para cuantificadores o alternancia sin registrar una subcoincidencia ni desplazar los índices $n posteriores. Los grupos de captura con nombre (?<name>...) pueblan tanto su posición numerada secuencial como match.groups.name (accesible como $<name> en cadenas de reemplazo), evitando roturas de índices cuando los patrones evolucionan.

¿Cuándo debo habilitar el flag Unicode (u) en expresiones regulares de ECMAScript?

Habilita u siempre que evalúes texto de usuario no ASCII, emojis, ideogramas suplementarios CJK o categorías de caracteres Unicode. Sin u, JavaScript evalúa las cadenas como unidades de código UTF-16 de 16 bits, haciendo que . o clases negadas como [^x] dividan los pares sustitutos de 4 bytes por encima de U+FFFF en medios sustitutos corruptos. Activar u cambia la coincidencia a puntos de código Unicode completos de 21 bits, habilita escapes de propiedad \p{...} como \p{Letter} y \p{Number}, y aplica validación estricta de sintaxis sobre escapes no reconocidos.

¿Cómo funcionan los tokens de reemplazo como $&, $1 y $<name> en las vistas previas de sustitución en vivo?

Las vistas previas de sustitución implementan el algoritmo GetSubstitution de ECMA-262 utilizado por String.prototype.replace() y replaceAll(). $& inserta la subcadena coincidente completa, $1 a $99 insertan el grupo de captura numerado correspondiente, $<name> inserta el texto capturado por (?<name>...), $' inserta todo lo que sigue a la coincidencia, el signo de dólar seguido de acento grave inserta todo lo anterior a la coincidencia y $$ genera un carácter $ literal.

¿Qué causa el backtracking catastrófico (ReDoS) y cómo puedo reescribir patrones vulnerables?

El backtracking catastrófico ocurre en motores NFA con backtracking cuando cuantificadores anidados o superpuestos —como (a+)+b o ^([a-zA-Z0-9]+\s?)*$— pueden particionar la misma secuencia de entrada de O(2^n) formas antes de fallar ante un carácter final inesperado. Elimina la ambigüedad reemplazando rangos codiciosos .* por clases de caracteres negadas ([^,\r\n]*), desenrollando separadores opcionales en ^[a-zA-Z0-9]+(?:\s[a-zA-Z0-9]+)*$ y acotando cuantificadores abiertos con límites explícitos ({1,64}). Para construir patrones compatibles con RE2 de tiempo lineal desde cero, utiliza el Generador de Regex.