Regex para validar email, URL y fechas: patrones útiles, límites y alternativas (sin humo)

Regex para validar email, URL y fechas: patrones útiles, límites y alternativas (sin humo)

Buscar en Google “regex para validar email” devuelve miles de patrones, muchos de ellos imposibles de mantener. La realidad es simple: una regex puede servir para prefiltrar (descartar lo obviamente incorrecto), pero validar al 100% (RFCs completos, URLs con reglas infinitas, fechas reales con calendarios) suele requerir lógica adicional o librerías. En este artículo te dejo patrones prácticos, su explicación y cómo integrarlos en flujos reales de desarrollo.

1) Antes de validar, decide el nivel de exigencia

Hay tres niveles típicos:

1. Ligero: “tiene buena pinta” (ideal para UX).
2. Medio: “cumple estructura” (ideal para backend antes de procesar).
3. Estricto: “cumple estándar” (normalmente con librerías o parsers).

En la mayoría de productos, el nivel medio funciona: reduces ruido sin romper casos válidos raros.

2) Email: patrón práctico (90–95% de casos)

Un patrón práctico para emails (no RFC perfecto) es:

/\b[\w.%+-]+@[\w.-]+\.[A-Za-z]{2,}\b/

¿Por qué funciona bien?

• Permite letras, números y algunos símbolos comunes antes de la arroba.
• Permite subdominios y guiones en el dominio.
• Exige un TLD de al menos 2 letras.

Para usarlo en JS y extraer todos los emails:

const re = /\b[\w.%+-]+@[\w.-]+\.[A-Za-z]{2,}\b/g;
const emails = texto.match(re) || [];

¿Y si quieres validación completa? A menudo es mejor mandar un email de confirmación. El “email válido” de verdad es el que puede recibir correo.

3) URL: patrón práctico y consejo de oro

Validar URLs con regex se complica rápido. Mi consejo: si estás en JS moderno, usa el constructor URL para validar de forma robusta, y deja la regex para detectar “parece una URL”.

Opción A: Validación robusta (recomendada)

function isValidUrl(s){
  try { new URL(s); return true; }
  catch { return false; }
}

Opción B: Regex “parece URL” (prefiltro)

/\bhttps?:\/\/[\w.-]+(?:\:[0-9]+)?(?:\/[\S]*)?\b/i

Esta regex detecta URLs http/https con dominio y ruta opcional. No contempla todo, pero sirve para un prefiltrado en textos (por ejemplo, convertir URLs en links en un editor).

4) Fechas: estructura vs fecha real

Para fechas, separa dos problemas:

• Estructura: “tiene formato YYYY-MM-DD”.
• Fecha real: “2026-02-30” no existe.

Regex para formato YYYY-MM-DD

/^\d{4}-\d{2}-\d{2}$/

Luego valida con lógica:

function isRealDate(s){
  if(!/^\d{4}-\d{2}-\d{2}$/.test(s)) return false;
  const [y,m,d] = s.split("-").map(Number);
  const dt = new Date(Date.UTC(y, m-1, d));
  return dt.getUTCFullYear()===y && (dt.getUTCMonth()+1)===m && dt.getUTCDate()===d;
}

Esta técnica evita falsas fechas y es mucho más mantenible que una regex “inteligente”.

5) Depuración rápida: prueba, mira coincidencias y grupos

La diferencia entre “me funciona” y “está bien hecho” suele estar en ver coincidencias reales. Para ello, usa un validador que muestre matches y posiciones: Validador de Regex (Expresiones Regulares). Pega casos reales: textos con URLs, emails raros, saltos de línea… y ajusta.

6) Alternativas y herramientas de apoyo

En flujos reales, regex convive con otros formatos. Por eso, estas herramientas son el complemento perfecto:

• Conversor Base64 si te llegan tokens o blobs codificados.
• Validador JSON para payloads y respuestas API.
• Validador XML si trabajas con sitemaps o SOAP.
• Analizador de JWT para auth y claims.
• Generador de contraseñas para pruebas rápidas y entornos.

7) Patrones recomendados (copiar y adaptar)

Extraer números (enteros) de un texto

/\b\d+\b/g

Detectar etiquetas HTML simples (ojo: no es un parser)

/<\/?[a-z][\s\S]*?>/gi

Buscar palabras repetidas (con backreference)

/\b(\w+)\s+\1\b/gi

Nota: para HTML serio, usa un parser. Regex en HTML funciona para cosas pequeñas, pero se rompe con casos reales.

Conclusión: regex útil, pero con límites

Si te quedas con una idea de este artículo, que sea esta: usa regex para prefiltrar y extraer, y usa lógica o librerías para validación estricta. Con esa filosofía, tendrás menos bugs, menos falsos positivos y patrones mucho más mantenibles.

Y cuando algo falle, vuelve al método: casos mínimos + casos límite + herramienta visual de coincidencias.