Hoja de Referencia de Patrones Regex: Expresiones Comunes Explicadas

31 de marzo, 2026 · 12 min de lectura

Las expresiones regulares (regex) son una de las herramientas más poderosas en el arsenal de un desarrollador. Ya sea que estés validando direcciones de correo electrónico, analizando archivos de registro, extrayendo datos de texto o construyendo operaciones complejas de búsqueda y reemplazo, regex proporciona una forma concisa y flexible de trabajar con patrones de texto.

Esta guía completa cubre todo, desde la sintaxis básica hasta técnicas avanzadas, con ejemplos prácticos que puedes usar inmediatamente en tus proyectos. Exploraremos regex en diferentes lenguajes de programación, compartiremos consejos de optimización de rendimiento y te ayudaremos a evitar errores comunes que confunden incluso a desarrolladores experimentados.

Fundamentos de Regex

En esencia, una expresión regular es una secuencia de caracteres que define un patrón de búsqueda. Cuando ejecutas este patrón contra una cadena, el motor de regex intenta encontrar coincidencias según las reglas que has especificado.

Un patrón regex consiste en dos tipos de caracteres: caracteres literales que coinciden exactamente consigo mismos, y metacaracteres que tienen significados especiales. Por ejemplo, el patrón /hello/ coincide con el texto literal "hello" en cualquier lugar de una cadena. Pero /h.llo/ usa el metacarácter punto para coincidir con "hello", "hallo", "hxllo", o cualquier otra secuencia de cinco caracteres que comience con "h" y termine con "llo".

Metacaracteres Esenciales

Aquí hay una tabla de referencia de los metacaracteres regex más fundamentales que usarás a diario:

Escapar Caracteres Especiales

Cuando necesitas coincidir con un metacarácter literal (como un punto o asterisco), debes escaparlo con una barra invertida. Por ejemplo, \. coincide con un punto literal, y \* coincide con un asterisco literal.

Los caracteres que necesitan escaparse incluyen: . * + ? ^ $ { } [ ] ( ) | \

Clases de Caracteres y Cuantificadores

Las clases de caracteres te permiten definir conjuntos de caracteres para coincidir, mientras que los cuantificadores especifican cuántas veces debe repetirse un patrón. Juntos, forman la columna vertebral de la mayoría de los patrones regex.

Clases de Caracteres

Los corchetes crean una clase de caracteres que coincide con cualquier carácter individual dentro de los corchetes:

Cuantificadores

Los cuantificadores especifican cuántas veces debe coincidir el elemento precedente. Son esenciales para coincidir con patrones de longitudes variables:

• * — Cero o más veces (codicioso)
• + — Una o más veces (codicioso)
• ? — Cero o una vez (opcional)
• {3} — Exactamente 3 veces
• {3,} — 3 o más veces
• {3,6} — Entre 3 y 6 veces
• *? — Cero o más veces (perezoso/no-codicioso)
• +? — Una o más veces (perezoso/no-codicioso)
• ?? — Cero o una vez (perezoso)

Coincidencia Codiciosa vs. Perezosa

Entender la diferencia entre cuantificadores codiciosos y perezosos es crucial para escribir patrones regex eficientes. Por defecto, los cuantificadores son codiciosos — coinciden con tanto texto como sea posible mientras permiten que el patrón general coincida.

Considera este ejemplo con la cadena "<div>content</div><div>more</div>":

• Codicioso: <div>.*</div> coincide con toda la cadena desde el primer <div> hasta el último </div>
• Perezoso: <div>.*?</div> coincide con cada par <div>...</div> por separado

La versión perezosa agrega un ? después del cuantificador, indicando al motor de regex que coincida con lo menos posible mientras satisface el patrón.

Patrones Regex Comunes

Aquí hay patrones regex probados en batalla para tareas comunes de validación y extracción. Estos patrones se usan en aplicaciones de producción en todo el mundo.

Validación de Correo Electrónico

Un patrón práctico de validación de correo electrónico que cubre la mayoría de los casos del mundo real:

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Este patrón asegura que el correo electrónico tenga una parte local (antes de @), un nombre de dominio y un dominio de nivel superior válido. Ten en cuenta que la validación perfecta de correo electrónico es imposible solo con regex — el estándar oficial RFC 5322 es increíblemente complejo. Para uso en producción, considera usar una biblioteca dedicada de validación de correo electrónico.

Números de Teléfono

Número de teléfono de EE. UU. con código de país opcional y varios formatos:

^(\+1[-.\s]?)?(\(?\d{3}\)?[-.\s]?)?\d{3}[-.\s]?\d{4}$

Esto coincide con formatos como:

• 555-123-4567
• (555) 123-4567
• +1 555 123 4567
• 5551234567

URLs

Coincide con URLs HTTP y HTTPS con prefijo www opcional:

^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$

Direcciones IP

Validación de dirección 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]?)$

Esto asegura que cada octeto esté entre 0 y 255.

Fechas

Formato de fecha ISO 8601 (AAAA-MM-DD):

^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$

Formato de fecha de EE. UU. (MM/DD/AAAA):

^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/\d{4}$

Números de Tarjeta de Crédito

Validación básica de tarjeta de crédito (elimina espacios y guiones):

^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12})$

Este patrón valida tarjetas Visa, MasterCard, American Express y Discover. Siempre usa el algoritmo de Luhn para validación real.

Contraseñas

Contraseña fuerte que requiere al menos 8 caracteres, una mayúscula, una minúscula, un dígito y un carácter especial:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$

Esto usa aserciones lookahead (cubiertas en la siguiente sección) para asegurar que se cumplan todos los requisitos.

Anclas, Grupos y Lookaheads

Estas características avanzadas te dan control preciso sobre dónde ocurren las coincidencias y cómo se capturan los patrones.

Anclas

Las anclas no coinciden con caracteres — coinciden con posiciones en la cadena:

• ^ — Inicio de cadena (o línea en modo multilínea)
• $ — Fin de cadena (o línea en modo multilínea)
• \b — Límite de palabra (entre \w y \W)
• \B — No-límite de palabra
• \A — Inicio de cadena (siempre, incluso en modo multilínea)
• \Z — Fin de cadena (siempre, incluso en modo multilínea)

Ejemplo: \bcat\b coincide con "cat" como palabra completa pero no con el "cat" en "category" o "concatenate".

Grupos de Captura

Los paréntesis crean grupos de captura que extraen subcadenas coincidentes:

^(\d{3})-(\d{3})-(\d{4})$

Este patrón coincide con un número de teléfono y captura el código de área, prefijo y número de línea por separado. Puedes referenciar estas capturas en cadenas de reemplazo o extraerlas programáticamente.

Grupos No-Capturadores

Usa (?:...) cuando necesites agrupación pero no quieras capturar la coincidencia:

(?:https?|ftp)://[^\s]+

Esto coincide con URLs que comienzan con http, https o ftp sin crear un grupo de captura para el protocolo.

Grupos de Captura Nombrados

Los grupos nombrados hacen tu regex más legible y mantenible:

(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})

Puedes referenciar estos por nombre en lugar de por número, haciendo tu código más claro.

Aserciones Lookahead

Los lookaheads verifican si existe un patrón adelante sin consumir caracteres:

• (?=...) — Lookahead positivo (debe ser seguido por)
• (?!...) — Lookahead negativo (no debe ser seguido por)

Ejemplo: \d+(?= dollars) coincide con números seguidos de " dollars" pero no incluye " dollars" en la coincidencia.

Aserciones Lookbehind

Los lookbehinds verifican qué viene antes de la posición actual:

• (?<=...) — Lookbehind positivo (debe ser precedido por)
• (?<!...) — Lookbehind negativo (no debe ser precedido por)

Ejemplo: (?<=\$)\d+ coincide con números precedidos por un signo de dólar pero no incluye el $ en la coincidencia.

Ten en cuenta que JavaScript solo obtuvo soporte de lookbehind en ES2018, así que verifica la compatibilidad si estás soportando navegadores más antiguos.

Regex en JavaScript

JavaScript proporciona soporte robusto de regex a través del objeto RegExp y métodos de cadena. Aquí está cómo usar regex efectivamente en aplicaciones JavaScript.

Crear Patrones Regex

Puedes crear patrones regex de dos maneras:

// Notación literal (preferida para patrones estáticos)
const pattern1 = /\d{3}-\d{3}-\d{4}/;

// Constructor (útil para patrones dinámicos)
const pattern2 = new RegExp('\\d{3}-\\d{3}-\\d{4}');

Nota las barras invertidas dobles en el constructor — necesitas escapar las barras invertidas en cadenas.

Banderas de Regex

JavaScript soporta varias banderas que modifican el comportamiento de regex: