Expresión regular

Una expresión regular (también llamada regex o regexp) es un patrón de texto que define un conjunto de cadenas posibles. Permite buscar, validar y extraer información de texto de forma precisa con unas pocas líneas, sin necesidad de recorrer carácter a carácter.

¿Cómo se construye una expresión regular?

Las regex combinan caracteres literales con metacaracteres que tienen significado especial. Los más habituales son:

Elemento	Significado	Ejemplo
`.`	Cualquier carácter (excepto salto de línea)	`a.c` → “abc”, “a1c”
`*`	Cero o más repeticiones del anterior	`ab*` → “a”, “ab”, “abb”
`+`	Una o más repeticiones	`ab+` → “ab”, “abb” (no “a”)
`?`	Cero o una repetición	`colou?r` → “color”, “colour”
`^`	Inicio de cadena	`^Hola` comienza con “Hola”
`$`	Fin de cadena	`fin$` termina en “fin”
`[abc]`	Cualquier carácter del grupo	`[aeiou]` → vocal
`\d`	Dígito (0–9)	`\d{4}` → cuatro dígitos
`\s`	Espacio en blanco	`\s+` → uno o más espacios
`\b`	Límite de palabra	`\bpato\b` no coincide con “patos”

Patrones de uso frecuente

Teléfono español (9 dígitos, puede empezar por 6, 7 o 9):

/^[679]\d{8}$/

NIF/DNI (8 dígitos + letra):

/^\d{8}[A-Z]$/i

Código postal español (5 dígitos):

/^\d{5}$/

Email (validación básica de formato):

/^[^\s@]+@[^\s@]+\.[^\s@]+$/

URL con protocolo:

/^https?:\/\/([\w-]+\.)+[\w-]+(\/[\w\-._~:/?#[\]@!$&'()*+,;=%]*)?$/

Flags: cómo modificar el comportamiento

Los flags se añaden después del cierre de la expresión y cambian cómo se aplica:

i (insensitive): ignora mayúsculas/minúsculas → /hola/i encuentra “Hola”, “HOLA” y “hola”.
g (global): devuelve todas las coincidencias, no solo la primera.
m (multiline): ^ y $ aplican a cada línea, no a toda la cadena.

Ejemplo en JavaScript para encontrar todas las palabras en mayúsculas:

const palabras = texto.match(/\b[A-Z]{2,}\b/g);

Grupos y capturas

Con paréntesis puedes capturar partes del texto para extraerlas:

const match = "2026-07-14".match(/^(\d{4})-(\d{2})-(\d{2})$/);
// match[1] → "2026", match[2] → "07", match[3] → "14"

Los grupos no capturadores ((?:...)) agrupan sin guardar el resultado, lo que mejora el rendimiento cuando no necesitas el valor.

Errores comunes

Escapar caracteres especiales: un punto . dentro de la regex coincide con cualquier carácter. Para buscar un punto literal usa \..
Sobregeneralizar con .*: el cuantificador codicioso puede capturar más de lo esperado. Usa .*? (no codicioso) cuando necesites la coincidencia más corta.
No anclar la expresión: sin ^ y $, una regex válida para “12345” también aceptará “abc12345xyz”. Ancla siempre que valides un campo completo.
Rendimiento en cadenas largas: las expresiones con demasiados grupos anidados o cuantificadores codicioso y no codicioso alternados pueden causar backtracking catastrófico. Prueba con textos largos antes de usar en producción.

Preguntas frecuentes

¿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 en texto. Se usa para validar formatos, buscar cadenas o extraer datos de texto de forma muy precisa.

¿En qué lenguajes se usan las expresiones regulares?

En casi todos: JavaScript, Python, PHP, Java, Go, Ruby, Swift… La sintaxis es muy similar entre ellos. Las diferencias principales están en flags y en algunas secuencias de escape.

¿Cómo valido un correo electrónico con regex?

Un patrón básico es /^[^\s@]+@[^\s@]+\.[^\s@]+$/. Valida el formato mínimo, aunque para producción conviene además verificar el dominio en el servidor, ya que la especificación de emails es compleja.