Herramientas mencionadas en este artículo
Abre la herramienta en el navegador mientras lees y prueba el flujo al instante.
¿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.

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
- Evita los cuantificadores anidados: no escribas nunca
(a+)+,(a*)*,(a+|b+)+, etc. - Usa grupos atómicos o cuantificadores posesivos cuando tu motor de regex los admita.
- Establece tiempos de espera al ejecutar regex sobre entradas no confiables.
- Prueba con entradas largas: prueba los patrones con cadenas de longitud 20, 30 y 50 en las que no se espere coincidencia.
- Usa herramientas de análisis estático: bibliotecas como
safe-regex(npm) ovulturepueden 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.
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.
