Guía Completa de Expresiones Regulares (Regex)

Las expresiones regulares son una de las herramientas más poderosas disponibles para cualquier programador. Permiten definir patrones de texto complejos en una sintaxis compacta que, una vez aprendida, se aplica en prácticamente cualquier lenguaje de programación y editor de código.

Caracteres Especiales (Metacaracteres)

Los metacaracteres son el vocabulario básico de las regex. Cada uno tiene un significado especial que amplía las capacidades de búsqueda más allá de texto literal:

Cuantificadores

Los cuantificadores controlan cuántas veces debe aparecer el elemento anterior para que haya coincidencia:

Grupos y Alternación

Los grupos permiten capturar porciones del texto que coincide, y la alternación permite definir opciones:

• (abc) — Grupo de captura: captura "abc" como un grupo accesible después del match
• (?:abc) — Grupo sin captura: agrupa sin capturar, útil para aplicar cuantificadores
• (?<nombre>abc) — Grupo nombrado: captura con un nombre accesible por clave
• a|b — Alternación: coincide con "a" O "b"
• (?=abc) — Lookahead positivo: verifica que "abc" sigue, sin consumir
• (?!abc) — Lookahead negativo: verifica que "abc" NO sigue
• (?<=abc) — Lookbehind positivo: verifica que "abc" precede
• (?<!abc) — Lookbehind negativo: verifica que "abc" NO precede

Clases de Caracteres

Las clases de caracteres definen conjuntos de caracteres que pueden coincidir en una posición:

• [abc] — Coincide con a, b o c
• [^abc] — Coincide con cualquier carácter EXCEPTO a, b o c
• [a-z] — Rango: cualquier letra minúscula de la a a la z
• [A-Za-z0-9] — Cualquier letra o dígito (equivalente a \w sin guion bajo)
• [áéíóú] — Caracteres Unicode específicos (vocales con acento)

Patrones Regex Más Útiles para Desarrolladores

Aquí tienes una colección de expresiones regulares probadas y listas para usar en tus proyectos:

Validación de Email

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ — Valida la estructura básica de un email. Para validación completa según RFC 5322, se recomienda usar librerías especializadas, ya que el estándar permite caracteres inusuales que complican enormemente la regex.

Validación de URL

https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*) — Detecta URLs HTTP y HTTPS válidas incluyendo paths, query strings y fragments.

Validación de Contraseña Fuerte

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$ — Al menos 8 caracteres con minúscula, mayúscula, número y carácter especial.

Extraer Números de un Texto

-?\d+\.?\d* — Captura números enteros y decimales, positivos y negativos. Útil para parsear datos numéricos de texto no estructurado.

Validar Dirección IP (IPv4)

^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$ — Valida direcciones IPv4 verificando que cada octeto esté entre 0 y 255.

Errores Comunes con Expresiones Regulares

• No escapar metacaracteres: Si quieres buscar un punto literal, debes escribir \. en lugar de . (que coincide con cualquier carácter).
• Regex demasiado codicioso: .* es "greedy" (codicioso) y consume todo lo posible. Usa .*? para coincidencia mínima.
• No usar anclas: Sin ^ y $, tu regex puede coincidir con una subcadena cuando esperabas validar la cadena completa.
• Olvidar el flag global: Sin el flag g, la regex solo encuentra la primera coincidencia.
• Catastrófica complejidad: Patrones como (a+)+$ pueden causar "catastrophic backtracking". Evita cuantificadores anidados.
• Usar regex para todo: A veces un simple string.includes() o string.split() es más legible y eficiente que una regex.

Rendimiento de las Expresiones Regulares

Las regex pueden ser extremadamente rápidas o extremadamente lentas dependiendo de cómo se escriban. Algunas buenas prácticas para optimizar rendimiento:

• Sé específico: [0-9] es más rápido que . con condiciones
• Usa anclas: ^patrón$ le dice al motor exactamente dónde buscar
• Evita backtracking: Prefiere cuantificadores posesivos o atómicos cuando sea posible
• Compila una vez: Almacena el new RegExp() en una variable y reutilízalo
• Prueba con datos reales: Una regex que funciona con textos cortos puede ser lentísima con miles de líneas