¿Qué es una expresión regular?

Una expresión regular (regex o regexp) es una secuencia de caracteres que define un patrón de búsqueda. Se usa para encontrar, comprobar, extraer o reemplazar texto que sigue una estructura concreta. Las regex están disponibles en prácticamente todos los lenguajes de programación (JavaScript, Python, Java, Ruby, Go, Rust) y en herramientas de línea de comandos como grep y sed.

Expresiones regulares para ingenieros: metacaracteres, grupos, anticipaciones y ReDoS

Una regex puede responder a preguntas como:

  • ¿Contiene esta cadena una dirección de correo válida?
  • Extrae todas las URL de este documento HTML.
  • Sustituye todas las cadenas de fecha ISO por otro formato.
  • Comprueba que este número de teléfono sigue un patrón concreto.

La sintaxis parece críptica al principio, pero sigue reglas coherentes. Cuando interiorizas los bloques básicos, puedes leer y escribir regex con seguridad.


Metacaracteres: los bloques básicos

Los metacaracteres son caracteres con un significado especial dentro de un patrón de regex.

Caracteres de coincidencia

Símbolo Significado Ejemplo Coincide con
. Cualquier carácter excepto el salto de línea a.c “abc”, “aXc”, “a1c”
\d Cualquier dígito (0–9) \d\d “42”, “00”, “99”
\D Cualquier carácter que no sea un dígito \D+ “abc”, “foo”
\w Carácter de palabra: [a-zA-Z0-9_] \w+ “hello”, “user_1”
\W Carácter que no es de palabra \W ” ”, ”!”, ”.”
\s Espacio en blanco (espacio, tabulador, salto de línea) a\sb “a b”, “a\tb”
\S Carácter que no es espacio en blanco \S+ “hello”, “123”

Anclas

Símbolo Significado
^ Inicio de línea o de cadena
$ Fin de línea o de cadena
\b Límite de palabra
\B Límite que no es de palabra
/^hello/.test('hello world')  // true  — empieza por "hello"
/^hello/.test('say hello')    // false — "hello" no está al principio
/world$/.test('hello world')  // true  — termina en "world"
/\bcat\b/.test('cat')         // true
/\bcat\b/.test('catch')       // false — "cat" no está en un límite de palabra

Cuantificadores

Símbolo Significado ¿Voraz?
* 0 o más Sí
+ 1 o más Sí
? 0 o 1 Sí
{n} Exactamente n veces —
{n,} n o más veces Sí
{n,m} Entre n y m veces Sí
*? +? ?? Versiones no voraces No

Voraz frente a no voraz:

const html = '<b>bold</b> and <i>italic</i>';

// Voraz: coincide con lo máximo posible
html.match(/<.+>/)[0]   // '<b>bold</b> and <i>italic</i>'

// No voraz: coincide con lo mínimo posible
html.match(/<.+?>/)[0]  // '<b>'

Clases de caracteres

Una clase de caracteres [...] coincide con cualquier carácter individual del conjunto.

[aeiou]       — cualquier vocal
[a-z]         — cualquier letra minúscula
[A-Z0-9]      — cualquier letra mayúscula o dígito
[^aeiou]      — cualquier carácter que NO sea una vocal (negación)
[a-z&&[^aei]] — intersección (sintaxis de Java): consonantes minúsculas

El acento circunflejo ^ dentro de una clase de caracteres la niega. Fuera de [...], ancla al inicio de la cadena.


Grupos y capturas

Grupos de captura (...)

Los paréntesis crean un grupo de captura. El texto que coincide se guarda y se puede recuperar después.

const date = '2026-01-14';
const match = date.match(/(\d{4})-(\d{2})-(\d{2})/);
console.log(match[1]); // '2026' — año
console.log(match[2]); // '01'   — mes
console.log(match[3]); // '14'   — día

Grupos de captura con nombre (?<name>...)

Los nombres hacen que las capturas se expliquen solas:

const match = '2026-01-14'.match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/);
console.log(match.groups.year);  // '2026'
console.log(match.groups.month); // '01'

Grupos sin captura (?:...)

Cuando necesitas agrupar para una alternancia o un cuantificador, pero no necesitas capturar el resultado:

// Coincide con 'color' o 'colour', sin necesidad de capturar 'ou?'
/colo(?:u?)r/  // coincide con 'color' y con 'colour'

Alternancia |

La barra vertical | actúa como un O entre alternativas:

/cat|dog/.test('I have a cat') // true
/cat|dog/.test('I have a dog') // true
/(jpg|jpeg|png|gif)$/.test('photo.jpeg') // true

Anticipaciones y retrospecciones

Las aserciones de contexto (lookarounds) permiten que un patrón coincida solo si está (o no está) precedido o seguido por otro patrón, sin incluir el texto de la aserción en la coincidencia.

Sintaxis Nombre Significado
(?=...) Anticipación positiva Seguido de…
(?!...) Anticipación negativa NO seguido de…
(?<=...) Retrospección positiva Precedido de…
(?<!...) Retrospección negativa NO precedido de…
// Anticipación positiva: coincide con "100" solo si le sigue " USD"
'100 USD'.match(/\d+(?= USD)/)[0]    // '100'
'100 EUR'.match(/\d+(?= USD)/)       // null

// Anticipación negativa: coincide con "file" si no le sigue ".bak"
'file.txt'.match(/file(?!\.bak)/)[0] // 'file'
'file.bak'.match(/file(?!\.bak)/)    // null

// Retrospección positiva: coincide con dígitos precedidos por "$"
'Price: $42'.match(/(?<=\$)\d+/)[0]  // '42'

Patrones prácticos

Dirección de correo (simplificada)

^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$

Nota: una regex de correo totalmente conforme con el RFC 5321 es extremadamente compleja. Para la mayoría de las validaciones de formularios basta con un patrón simplificado como el anterior. Confirma siempre la validez de un correo enviando un mensaje de confirmación, no solo con una coincidencia de regex.

URL (http/https)

^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$

Fecha ISO 8601 (AAAA-MM-DD)

^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$

Dirección IPv4

^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$

Código de color hexadecimal

^#([0-9a-fA-F]{3}){1,2}$

Banderas (modificadores)

Las banderas cambian cómo se interpreta el patrón.

Bandera Significado
g Global: encuentra todas las coincidencias, no solo la primera
i Sin distinguir mayúsculas de minúsculas
m Multilínea: ^ y $ coinciden con el inicio y el fin de cada línea
s Dotall: . también coincide con los saltos de línea
u Unicode: trata el patrón y la cadena como Unicode
'Hello WORLD'.match(/hello/i)[0] // 'Hello' — sin distinguir mayúsculas
'a\nb\nc'.match(/^\w/gm)         // ['a', 'b', 'c'] — multilínea

ReDoS: retroceso catastrófico

ReDoS (Regular Expression Denial of Service) es una vulnerabilidad que se produce cuando una entrada creada con mala intención hace que una regex tarde exponencialmente más de lo esperado.

El patrón vulnerable clásico son los cuantificadores anidados:

^(a+)+$     — con "aaaaaaaaaaaaaaab" se produce un retroceso catastrófico

El motor de regex prueba todas las formas posibles de agrupar las a antes de concluir que no hay coincidencia. Para una cadena de longitud n, esto puede tardar un tiempo O(2ⁿ).

Por qué importa

Si tu aplicación acepta entradas de usuario y las pasa a una regex (o, peor aún, deja que los usuarios aporten sus propios patrones), un usuario malicioso puede bloquear tu servidor o consumir una cantidad excesiva de CPU con una sola cadena cuidadosamente preparada.

Cómo prevenir ReDoS

  1. Evita los cuantificadores anidados: no escribas nunca (a+)+, (a*)*, (a+|b+)+, etc.
  2. Usa grupos atómicos o cuantificadores posesivos cuando tu motor de regex los admita.
  3. Establece tiempos de espera al ejecutar regex sobre entradas no confiables.
  4. Prueba con entradas largas: prueba los patrones con cadenas de longitud 20, 30 y 50 en las que no se espere coincidencia.
  5. Usa herramientas de análisis estático: bibliotecas como safe-regex (npm) o vulture pueden detectar patrones peligrosos.
// Vulnerable
/^(a+)+$/.test('aaaaaaaaaaaaaaab'); // puede colgarse

// Alternativa segura: sin cuantificadores anidados
/^a+$/.test('aaaaaaaaaaaaaaab');    // rápida

Diferencias entre lenguajes

Aunque la sintaxis de las regex es en general parecida entre lenguajes, hay diferencias notables:

Característica JavaScript Python Go Java
Grupos con nombre (?<name>...) (?P<name>...) (?P<name>...) (?<name>...)
Retrospección Admitida (ES2018+) Admitida No admitida Admitida
\d coincide con dígitos Unicode Depende de la bandera u Depende de re.UNICODE Solo ASCII Depende de la bandera
Multilínea por defecto No No No No

Novedades de noviembre de 2026

  • Casos de prueba: escribe un caso por línea — una línea que empieza por - no debe coincidir, + (o sin prefijo) debe coincidir — y ve correcto/fallo de cada caso. También puedes exigir que coincida toda la línea.

Pruébalo en la herramienta

Preguntas frecuentes

¿Qué diferencia hay entre match y exec en JavaScript?

String.prototype.match() devuelve un array de resultados. Con la bandera g devuelve todas las coincidencias. Sin g se comporta como RegExp.prototype.exec(), que también devuelve los grupos de captura. exec() es útil en bucles con la bandera g porque recuerda la posición de la última coincidencia mediante lastIndex.

¿Cómo escapo los caracteres especiales en una regex?

Los caracteres especiales ., *, +, ?, (, ), [, ], {, }, ^, $, | y \ deben escaparse con una barra invertida para que coincidan de forma literal.

// Escapa un punto para que coincida con un punto literal, no con "cualquier carácter"
/\./.test('a.b') // true
/\./.test('axb') // false

Una función auxiliar para escapar cadenas arbitrarias:

function escapeRegex(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

¿Es una regex la herramienta adecuada para analizar HTML o JSON?

En general, no. HTML y JSON tienen estructuras recursivas que una regex no puede manejar bien. Usa un analizador específico: DOMParser para HTML y JSON.parse() para JSON. Las regex son adecuadas para extraer patrones sencillos dentro de campos de texto ya analizados.

¿Qué hace la bandera y (sticky) en JavaScript?

La bandera y hace que la regex solo coincida a partir de la posición indicada por lastIndex. A diferencia de g, no avanza por la cadena buscando coincidencias: o coincide en la posición actual o falla.