Las expresiones regulares (regex) son una de las herramientas más potentes y temidas del desarrollo de software. En JavaScript están integradas de forma nativa, son extremadamente rápidas y, una vez que entiendes la sintaxis, se vuelven indispensables.
Esta guía cubre todo lo que necesitas saber, desde lo más básico hasta patrones avanzados, con ejemplos que puedes probar directamente.
Qué es una expresión regular
Una expresión regular es un patrón que describe un conjunto de cadenas de texto. Sirve para buscar, validar, extraer y reemplazar texto según reglas precisas.
En JavaScript se crean de dos formas:
// Literal (recomendado para patrones fijos)
const re = /patron/flags;
// Constructor (útil cuando el patrón viene de una variable)
const re = new RegExp("patron", "flags");
Sintaxis fundamental
Caracteres especiales
| Símbolo | Significado |
|---|---|
. |
Cualquier carácter excepto salto de línea |
\d |
Dígito (0-9) |
\w |
Palabra (a-z, A-Z, 0-9, _) |
\s |
Espacio en blanco (espacio, tab, salto de línea) |
\D |
No dígito |
\W |
No carácter de palabra |
\S |
No espacio en blanco |
Cuantificadores
| Símbolo | Significado |
|---|---|
* |
0 o más veces |
+ |
1 o más veces |
? |
0 o 1 vez (opcional) |
{n} |
Exactamente n veces |
{n,} |
n o más veces |
{n,m} |
Entre n y m veces |
Anclas
| Símbolo | Significado |
|---|---|
^ |
Inicio de string (o línea con flag m) |
$ |
Fin de string (o línea con flag m) |
\b |
Límite de palabra |
\B |
No límite de palabra |
Clases de caracteres
/[aeiou]/ // cualquiera de estas vocales
/[a-z]/ // cualquier minúscula
/[A-Z]/ // cualquier mayúscula
/[0-9]/ // cualquier dígito (equivale a \d)
/[^aeiou]/ // cualquier carácter que NO sea vocal
/[a-zA-Z0-9]/ // alfanumérico
Flags (modificadores)
Los flags se añaden después del segundo /:
| Flag | Significado |
|---|---|
g |
Global — encuentra todas las coincidencias, no solo la primera |
i |
Case-insensitive — ignora mayúsculas/minúsculas |
m |
Multiline — ^ y $ coinciden con inicio/fin de cada línea |
s |
Dotall — . coincide también con saltos de línea |
u |
Unicode — soporte completo de caracteres Unicode |
"Hola HOLA hola".match(/hola/gi); // ["Hola", "HOLA", "hola"]
Métodos de JavaScript
test() — ¿Hay coincidencia?
/^\d{5}$/.test("28001"); // true (código postal válido)
/^\d{5}$/.test("2800X"); // false
match() — Obtener coincidencias
const texto = "Precios: 12€, 45€ y 99€";
// Sin flag g: devuelve primera coincidencia + grupos
texto.match(/\d+€/); // ["12€", index: 9, ...]
// Con flag g: devuelve todas las coincidencias
texto.match(/\d+€/g); // ["12€", "45€", "99€"]
replace() — Sustituir
"hola mundo".replace(/mundo/, "JavaScript"); // "hola JavaScript"
"a1b2c3".replace(/\d/g, "X"); // "aXbXcX"
replaceAll() — Sustituir todas (alternativa moderna)
"foo foo foo".replaceAll("foo", "bar"); // "bar bar bar"
split() — Dividir por patrón
"uno dos tres".split(/\s+/); // ["uno", "dos", "tres"]
matchAll() — Iterador de todas las coincidencias con grupos
const re = /(\d+)-(\d+)/g;
const texto = "2024-01 y 2025-05";
for (const match of texto.matchAll(re)) {
console.log(match[1], match[2]); // "2024" "01" → "2025" "05"
}
Grupos de captura
Los paréntesis crean grupos que puedes extraer por separado:
const fecha = "2025-05-04";
const [, año, mes, dia] = fecha.match(/(\d{4})-(\d{2})-(\d{2})/);
// año = "2025", mes = "05", dia = "04"
Grupos nombrados
Los grupos con nombre hacen el código mucho más legible:
const { groups } = "2025-05-04".match(
/(?<año>\d{4})-(?<mes>\d{2})-(?<dia>\d{2})/
);
// groups.año = "2025", groups.mes = "05", groups.dia = "04"
Grupos no capturantes
Si quieres agrupar sin capturar, usa (?:...):
/(?:https?|ftp):\/\//.test("https://ejemplo.com"); // true
// El grupo (?:https?|ftp) agrupa la alternativa sin crear una captura
Lookaheads y lookbehinds
Permiten hacer coincidencias condicionales sin incluir el contexto en el resultado.
// Lookahead positivo: precio seguido de €
"100€ 200$".match(/\d+(?=€)/g); // ["100"]
// Lookahead negativo: número NO seguido de €
"100€ 200$".match(/\d+(?!€)\b/g); // ["200"]
// Lookbehind positivo: número precedido de €
"€100 $200".match(/(?<=€)\d+/g); // ["100"]
Los 10 patrones más útiles
// Email básico
/^[^\s@]+@[^\s@]+\.[^\s@]+$/
// URL (http/https)
/^https?:\/\/[\w\-]+(\.[\w\-]+)+[^\s]*$/
// Número de teléfono español
/^(\+34|0034|34)?[6789]\d{8}$/
// Código postal español
/^\d{5}$/
// DNI/NIE español
/^[0-9XYZ]\d{7}[TRWAGMYFPDXBNJZSQVHLCKE]$/i
// Contraseña segura (mín. 8 chars, 1 mayúscula, 1 número, 1 símbolo)
/^(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*]).{8,}$/
// Nombre de variable JavaScript válido
/^[a-zA-Z_$][a-zA-Z0-9_$]*$/
// IPv4
/^(\d{1,3}\.){3}\d{1,3}$/
// Fecha ISO 8601
/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d+)?Z?)?$/
// Slug de URL (solo minúsculas, guiones y números)
/^[a-z0-9]+(?:-[a-z0-9]+)*$/
Rendimiento: cuándo NO usar regex
Regex es una herramienta potente pero puede volverse costosa en patrones complejos con backtracking. Evítalas cuando:
- Parseas HTML o XML — usa un parser DOM
- Parseas JSON — usa
JSON.parse() - Haces operaciones simples de string —
includes(),startsWith(),endsWith()son más rápidos y legibles
Para patrones complejos, usa herramientas como nuestro tester para verificar el comportamiento antes de desplegarlo en producción.
Pruébalo en tiempo real
El mejor modo de aprender regex es probando. Nuestro Regex Tester online resalta las coincidencias en tiempo real, muestra los grupos de captura y incluye una referencia rápida de la sintaxis. Sin instalaciones, directo en el navegador.