Flujo de Evaluación Paso a Paso
Definir expresión y modificadores
Introduzca el patrón de expresión regular entre delimitadores /.../ y configure modificadores como global (g), insensible a mayúsculas (i), multilínea (m), dotAll (s), Unicode (u) o índices (d).
Suministrar texto de prueba
Pegue, escriba o arrastre y suelte cargas de log, fragmentos de código o archivos estructurados en el panel de texto para iniciar la evaluación instantánea.
Inspeccionar coincidencias y grupos
Examine los resaltados en línea junto con los desplazamientos de caracteres exactos, valores de grupos posicionales y diccionarios de grupos nombrados en el inspector.
Evaluar reemplazos y exportar código
Verifique las sustituciones de texto empleando tokens de referencia ($1, $&, $<nombre>) y exporte fragmentos listos para producción en JavaScript, Python, Go, PHP o Java.
Patrones Arquitectónicos de Producción
Expresiones optimizadas con grupos de captura nombrados para análisis léxico, validación y extracción de datos:
1. Extracción de Correo Electrónico (RFC 5322)
Modificadores: /gAísla el buzón del destinatario en <user> y el host en <domain>, con soporte para subdominios y etiquetas (+v2).
/(?<user>[a-zA-Z0-9._%+-]+)@(?<domain>[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/gOperaciones: ops@codekivo.com, triaje: bug-report+v2@sub.cluster.internal2. Desconstrucción de URI y Endpoints (RFC 3986)
Modificadores: /gDescompone direcciones web en componentes nombrados discretos: autoridad del host, puerto opcional, ruta del recurso y cadena de consulta sin procesar.
/https?:\/\/(?<host>[a-zA-Z0-9.-]+)(?::(?<port>\d+))?(?<path>\/[^\s?#]*)?(?:\?(?<query>[^\s#]*))?/gEndpoint: https://api.service.internal:8443/v2/metrics?filter=active&limit=503. Marca Temporal ISO 8601 con Desfase Horario
Modificadores: /gCoincide con notaciones UTC Zulu (Z) y desfases horarios explícitos (+02:00) en flujos de telemetría y logs de alto rendimiento.
/(?<timestamp>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:?\d{2}))/g2026-09-16T17:55:00.124Z [INFO] Confirmación de latido del service worker en 2026-09-16T18:00:00+02:004. Especificación de Versión SemVer 2.0.0
AncladoAsegura versiones numéricas enteras positivas sin ceros a la izquierda mientras extrae canales de prelanzamiento opcionales y metadatos de compilación.
/^v?(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>[0-9A-Za-z.-]+))?(?:\+(?<build>[0-9A-Za-z.-]+))?$/v2.14.0-rc.3+build.892Referencia de Modificadores (Flags) en JavaScript (ECMAScript)
Los modificadores alteran la manera en que el motor de expresiones regulares recorre la memoria del búfer de entrada y establece límites de coincidencia:
| Modificador | Identificador | Comportamiento del Motor y Características de Ejecución |
|---|---|---|
| g | Global | Itera sobre la cadena completa. El motor muta la propiedad lastIndex en la instancia RegExp tras cada coincidencia en lugar de detenerse en el índice 0. |
| i | Ignorar mayúsculas | Aplica comparación plegada entre mayúsculas y minúsculas (case-folding). Coincide con caracteres ASCII y Unicode sin requerir duplicar rangos como [a-zA-Z]. |
| m | Multilínea | Modifica las anclas de límite de línea: ^ coincide con inicios de línea (\n o \r) y $ con fines de línea. |
| s | DotAll | Amplía la semántica del punto (.) para coincidir con saltos de línea (\n, \r, \u2028, \u2029). |
| u | Unicode | Procesa el patrón como una secuencia de puntos de código Unicode de 32 bits. Gestiona adecuadamente pares subrogados UTF-16 (emojis y símbolos matemáticos) y activa secuencias \p{Propiedad}. |
| y | Pegajoso (Sticky) | Restringe la búsqueda para comenzar con exactitud en el índice indicado por lastIndex. No escanea caracteres posteriores si la coincidencia falla en dicho índice exacto. |
| d | Índices | Genera matrices de tuplas de desplazamiento inicial y final (match.indices) para la coincidencia total y para cada grupo de captura (especificación ES2022). |
| v | Conjuntos Unicode | Extiende el modificador u con operaciones de conjuntos sobre clases de caracteres (intersección &&, diferencia --) y propiedades de cadenas (ES2024). |
Arquitectura del Motor: Paradigmas de Coincidencia NFA Tradicional vs. DFA
Los motores JavaScript del navegador ejecutan expresiones regulares utilizando un Autómata Finito No Determinista Tradicional (NFA). Comprender su modelo de cómputo explica sus prestaciones avanzadas y los riesgos de rendimiento asociados:
Recorrido Dirigido por la Expresión
Los motores NFA procesan los tokens del patrón secuencialmente, intentando hacer coincidir cada uno frente al carácter actual del texto. Si una rama falla, el motor retrocede al último punto de control guardado y prueba rutas alternativas.
Pila de Estados de Retroceso (Backtracking)
Al encontrar cuantificadores codiciosos (*, +) o alternancias (|), el motor almacena posiciones de retroceso en una pila interna. Este mecanismo permite aserciones lookaround y referencias inversas.
Determinismo Lineal en Motores DFA
En contraste, los motores DFA guiados por el texto (como RE2 en Go) escanean cada carácter una única vez en paralelo para todos los estados posibles. Aunque garantizan un tiempo de ejecución estrictamente lineal O(n), no admiten lookaround ni referencias hacia atrás.
Anatomía del Retroceso Catastrófico (ReDoS) y Refactorización Segura
La Denegación de Servicio por Expresiones Regulares (ReDoS) se suscita cuando un motor NFA procesa cuantificadores ambiguos anidados frente a un sufijo que no coincide al final de una cadena extensa:
Patrón Patológico Vulnerable
// Complejidad exponencial: O(2^n)
const badRegex = /^(a+)+$/;
badRegex.test("aaaaaaaaaaaaaaaaaaaaX");Para una cadena de 20 caracteres que termina en un fallo (X), el motor explora 2^20 ≈ 1.048.576 permutaciones dividiendo subcadenas entre cuantificadores internos y externos, bloqueando el hilo de ejecución principal.
Refactorización Lineal Determinista
// Complejidad lineal garantizada: O(n)
const safeRegex = /^a+$/;
safeRegex.test("aaaaaaaaaaaaaaaaaaaaX");Al aplanar cuantificadores anidados redundantes o hacer que los tokens contiguos sean mutuamente excluyentes (p. ej., consumiendo secuencias sin delimitador [^:\s]+ en lugar de comodines .*), el motor suprime las bifurcaciones ambiguas.
La Trampa del Estado: Mutación del Puntero lastIndex con el Modificador Global (/g)
Uno de los fallos lógicos más habituales en aplicaciones JavaScript radica en la mutación del cursor interno en instancias de RegExp configuradas con los modificadores /g o /y:
El Defecto de Mutación con Estado
Reutilizar una instancia de RegExp compilada con el modificador /g muta su puntero interno lastIndex tras cada coincidencia exitosa:
const ID_REGEX = /^[A-Z]{3}-\d{4}$/g;
function validateId(input) {
return ID_REGEX.test(input);
}
validateId("ABC-1234"); // true (lastIndex muta a 8)
validateId("ABC-1234"); // false (¡busca a partir del índice 8!)
validateId("ABC-1234"); // true (se reinicia a 0 tras fallar)Dado que .test() reanuda el escaneo a partir del final de la coincidencia previa, entradas idénticas alternan sistemáticamente entre aprobadas y rechazadas.
Soluciones de Ingeniería Defensiva
Adopte una de estas tres estrategias probadas para garantizar una evaluación idempotente:
01Omitir el modificador /g en validaciones booleanas
Al comprobar validez con .test(), prescinda del modificador g por completo para que lastIndex permanezca invariable en 0.
02Reinicio explícito del puntero antes de la ejecución
Si la iteración global resulta estrictamente necesaria entre ámbitos funcionales, reinicie el cursor: ID_REGEX.lastIndex = 0; antes de cada invocación.
03Preferir String.prototype.matchAll()
ECMAScript moderno recomienda emplear str.matchAll(regex), que devuelve un iterador inmutable de coincidencias sin alterar el estado externo.
Aserciones de Contexto de Ancho Cero (Lookaround): Coincidencia sin Consumo de Búfer
Las aserciones de contexto comprueban que el texto existe (o no existe) adyacente a la posición actual sin consumir caracteres ni integrarlos en el resultado de coincidencia general ($&):
(?=patrón)
Verifica que el subpatrón coincide inmediatamente tras la posición actual. Se emplea comúnmente para validar criterios concurrentes (p. ej., al menos una mayúscula) sin desplazar el cursor.
(?!patrón)
Verifica que el subpatrón NO coincide a continuación. Fundamental para exclusiones de palabras clave (p. ej., descartar nombres que finalicen en .min.js).
(?<=patrón)
Verifica que el subpatrón coincide inmediatamente antes del índice actual. Permite aislar valores situados tras prefijos (p. ej., cantidades monetarias tras (?<=\$)\d+).
(?<!patrón)
Verifica que el subpatrón NO coincide antes del índice. Frecuente para localizar comillas o barras invertidas sin escapar: (?<!\\)".
Matriz de Compatibilidad Entre Motores y Entornos
Al trasladar patrones evaluados en esta herramienta a servicios de backend, verifique las fronteras de compatibilidad de cada runtime:
| Lenguaje / Entorno | Familia de Motor | Grupos Nombrados | Soporte Lookaround | Grupos Atómicos / Cuantificadores Posesivos |
|---|---|---|---|---|
| JavaScript (ECMAScript) | NFA Tradicional | (?<nombre>...) | Total (incluye lookbehind de longitud variable) | Emulado mediante aserciones lookaround |
Python (módulo re) | NFA Tradicional | (?P<nombre>...) | Únicamente lookbehind de longitud fija | Compatible en Python 3.11+ |
Go (paquete regexp) | DFA / RE2 | (?P<nombre>...) | No admitido (restricción lineal de DFA) | No admitido |
PHP (preg_* / PCRE2) | NFA PCRE2 | (?<nombre>...) / (?P<nombre>...) | Total (lookbehind variable delimitado) | (?>...) y ++, *+ |
Java (java.util.regex) | NFA Tradicional | (?<nombre>...) | Lookbehind con longitud máxima determinada | (?>...) y ++, *+ |
Arquitectura de Tokens de Sustitución en Modo de Reemplazo
Al efectuar sustituciones de cadenas en el panel de reemplazo, la cadena resultante interpreta los identificadores precedidos por el signo de dólar como tokens de expansión dinámica:
| Token | Valor de Expansión | Aplicación Práctica y Ejemplo |
|---|---|---|
| $& | Subcadena Coincidente | Envuelve o decora coincidencias: <mark>$&</mark> resalta palabras in situ. |
| $1, $2..$99 | Grupo Numerado | Reordena componentes: ([0-9]{4})-([0-9]{2}) sustituido por $2/$1 reformatea pares de año y mes. |
| $<nombre> | Grupo Nombrado | Refactoriza datos con claridad semántica: $<user>@internal.net reemplaza el dominio conservando la variable de usuario. |
| $` | Fragmento Precedente | Inserta toda la subcadena de la entrada situada antes del índice de inicio de la coincidencia actual. |
| $' | Fragmento Posterior | Inserta toda la subcadena de la entrada situada tras el índice final de la coincidencia actual. |
| $$ | Signo Dólar Literal | Escapa el prefijo de token para insertar un carácter $ literal en la salida sin activar la sustitución. |
Frequently Asked Questions
¿Por qué mi expresión regular coincide con demasiado texto (coincidencia codiciosa vs. perezosa)?
Por defecto, los cuantificadores estándar (*, +, {m,n}) son codiciosos (greedy): consumen tantos caracteres como sea posible antes de retroceder (backtrack) para satisfacer el resto del patrón. Al anexar un signo de interrogación se vuelven perezosos (*?, +?, {m,n}?), coincidiendo con la menor cantidad de caracteres necesaria. Por ejemplo, <.*> coincide desde el primer < hasta el último > a lo largo de toda una línea, mientras que <.*?> se detiene en el primer > de cierre.
¿Por qué RegExp.prototype.test() alterna entre true y false con entradas idénticas?
Cuando una expresión regular incluye el modificador global (g) o pegajoso (y), JavaScript convierte la instancia de RegExp en un objeto con estado interno al registrar la propiedad lastIndex. Cada ejecución exitosa de .test() actualiza lastIndex al final de dicha coincidencia. La siguiente llamada busca estrictamente a partir de lastIndex hasta fallar, lo que reinicia lastIndex a 0. Para validaciones booleanas, omita el modificador g o restablezca manualmente regex.lastIndex = 0 antes de invocar .test().
¿Cómo prevenir el retroceso catastrófico (Catastrophic Backtracking / ReDoS) al evaluar patrones complejos?
El retroceso catastrófico se produce cuando cuantificadores ambiguos anidados o adyacentes (como (a+)+$ o (.*a)+) encuentran un sufijo no coincidente, forzando al motor NFA a un espacio de búsqueda exponencial O(2^n). Para evitarlo, elimine cuantificadores anidados, asegúrese de que las alternancias no se solapen, utilice exclusiones de clases de caracteres específicas como [^"\n]+ en lugar de .* y posicione anclas de límite lo antes posible.
¿Cómo evaluar expresiones regulares frente a cadenas multilínea y saltos de línea?
Active el modificador multilínea (m) para que ^ y $ coincidan con el inicio y fin de cada línea individual (\n o \r) en lugar del búfer completo. Si además necesita que el comodín punto (.) coincida a través de saltos de línea sin detenerse en \n, active el modificador DotAll (s). Ambos modificadores pueden combinarse simultáneamente como /patrón/ms.
¿Cómo funcionan los grupos de captura nombrados en la búsqueda y reemplazo de cadenas?
Encierre el subpatrón entre (?<nombreGrupo>...). En JavaScript, los valores capturados se exponen en match.groups.nombreGrupo. En el modo de reemplazo, haga referencia al valor capturado mediante $<nombreGrupo>. Los grupos nombrados dotan de robustez al código, ya que añadir, eliminar o reordenar grupos nunca invalidará referencias posicionales numéricas ($1, $2).
¿Cuál es la diferencia operativa entre aserciones de contexto (lookaround) positivas/negativas hacia adelante y hacia atrás?
Las aserciones de contexto (lookarounds) son comprobaciones de ancho cero (zero-width): verifican si el texto adyacente cumple un subpatrón sin consumir caracteres ni incluirlos en la coincidencia final ($&). Las aserciones hacia adelante (?=...) y (?!...) verifican lo que sigue al índice actual, mientras que las aserciones hacia atrás (?<=...) y (?<!...) verifican lo que lo precede. En motores ECMAScript/V8 modernos, se admiten plenamente aserciones hacia atrás de longitud variable.
¿Por qué una expresión regular válida en este probador puede fallar al migrar a Go (Golang)?
Este evaluador opera sobre ECMAScript moderno (V8), un motor NFA tradicional que admite aserciones lookaround y referencias inversas. La biblioteca estándar de Go (paquete regexp) utiliza Google RE2, un motor basado en DFA que garantiza un tiempo de ejecución lineal O(n). RE2 prohíbe explícitamente aserciones lookaround (?=...) y referencias inversas (\1). Al migrar a Go, reestructure los patrones empleando delimitadores explícitos o lógica de subcadenas en pasos secuenciales.
¿Qué función desempeñan los modificadores de índices (d) y Unicode (u) en JavaScript?
El modificador d (hasIndices) instruye al motor para poblar match.indices, una matriz con tuplas de desplazamiento exacto de inicio y fin para la coincidencia completa y cada grupo de captura (especificación ES2022). El modificador u (Unicode) trata las cadenas como secuencias de puntos de código Unicode de 32 bits en lugar de unidades de código de 16 bits, permitiendo el manejo correcto de emojis, caracteres astrales y secuencias de escape de propiedades \p{...}.