Guía Completa de Regex: Referencia Rápida de Expresiones Regulares

¿Qué es Regex?

Las expresiones regulares (regex o regexp) son secuencias de caracteres que definen patrones de búsqueda. Son una de las herramientas más poderosas para procesamiento de texto, coincidencia de patrones y extracción de datos.

¿Por Qué Usar Expresiones Regulares?

Regex es esencial para:

• Validación de formularios (email, teléfonos, contraseñas)
• Extracción de datos (análisis de logs, scraping de páginas web)
• Procesamiento de texto (buscar y reemplazar, formateo)
• Refactorización de código (renombrar variables, actualizar sintaxis)
• Sanitización de entradas (seguridad, prevención de ataques de inyección)

Cómo Leer Esta Guía

Esta guía está organizada en secciones progresivas:

1. Fundamentos - Sintaxis básica y patrones
2. Características Avanzadas - Lookarounds, grupos nombrados, Unicode
3. Específico por Lenguaje - Ejemplos en Python, JavaScript, PHP, C#, Java, Go, Ruby
4. Regex en VS Code - Transformaciones find/replace con más de 20 ejemplos
5. Patrones Comunes - Patrones listos para copiar: emails, URLs, fechas, etc.
6. Casos de Uso Prácticos - Aplicaciones del mundo real
7. Solución de Problemas - Errores comunes y consejos de rendimiento

Cada sección incluye:

• Explicaciones claras
• Ejemplos visuales
• Fragmentos de código para copiar
• Consejos profesionales y trampas

Caracteres Literales

El regex más simple es una secuencia literal de caracteres:

abc

Coincide con: "abc" en "The abc sequence"

Sensibilidad a Mayúsculas/Minúsculas

Por defecto, regex es sensible a mayúsculas:

• Hello coincide con "Hello" pero NO con "hello"
• Use la flag i para coincidencia insensible: /hello/i

---

Caracteres Especiales (Metacaracteres)

Estos 12 caracteres tienen significado especial en regex y deben ser escapados con \ para coincidir literalmente:

. ^ $ * + ? { } [ ] \ | ( )

Ejemplos:

• \. coincide con un punto literal
• \$ coincide con un signo de dólar
• \( coincide con un paréntesis literal

Carácter	Escape	Ejemplo	Coincide
. (punto)	\.	3\.14	"3.14"
$ (dólar)	\$	\$100	"$100"
* (asterisco)	\*	a\*b	"a*b"

---

Clases de Caracteres

Clases de Caracteres Predefinidas

Patrón	Descripción	Equivalente	Ejemplo	Coincide
\d	Cualquier dígito	[0-9]	\d\d	"42"
\D	Cualquier no-dígito	[^0-9]	\D+	"abc"
\w	Carácter de palabra	[a-zA-Z0-9_]	\w+	"hello_123"
\W	No-palabra	[^a-zA-Z0-9_]	\W	"@", "#"
\s	Espacio en blanco	[ \t\n\r\f\v]	\s+	" " (espacios)
\S	No-espacio	[^ \t\n\r\f\v]	\S+	"hello"
.	Cualquier carácter excepto nueva línea	-	a.c	"abc", "a1c"

Consejo Profesional: \w NO incluye letras Unicode por defecto. Use \p{L} para soporte Unicode (JavaScript/Python).

Clases de Caracteres Personalizadas

Patrón	Descripción	Ejemplo	Coincide
[abc]	Coincide cualquiera de a, b o c	[aeiou]	Vocales: "a", "e", "i", "o", "u"
[^abc]	Coincide cualquiera excepto a, b o c	[^0-9]	No-dígitos
[a-z]	Rango: letras minúsculas	[a-z]+	"hello"
[A-Z]	Rango: letras mayúsculas	[A-Z]+	"HELLO"
[0-9]	Rango: dígitos	[0-9]{4}	"2025"
[a-zA-Z]	Combinado: todas las letras	[a-zA-Z0-9]	Alfanumérico

Ejemplos:

[aeiou]       → Coincide cualquier vocal
[^aeiou]      → Coincide cualquier consonante (no vocal)
[a-z0-9]      → Coincide letras minúsculas y dígitos
[a-zA-Z0-9_]  → Igual a \w (caracteres de palabra)

---

Cuantificadores

Los cuantificadores especifican cuántas veces debe coincidir un patrón.

Cuantificadores Básicos

Patrón	Descripción	Ejemplo	Coincide
*	0 o más	ab*c	"ac", "abc", "abbc", "abbbc"
+	1 o más	ab+c	"abc", "abbc" (NO "ac")
?	0 o 1 (opcional)	colou?r	"color", "colour"
{n}	Exactamente n veces	\d{4}	"2025" (exactamente 4 dígitos)
{n,}	n o más veces	\d{2,}	"42", "123", "9999"
{n,m}	Entre n y m veces	\d{2,4}	"42", "123", "2025"

Cuantificadores Codiciosos vs. Perezosos

Codicioso (por defecto): Coincide lo máximo posible

<.*>      → Coincide: "<div>Hola</div>" (cadena completa)

Perezoso (no-codicioso): Coincide lo mínimo posible (añada ? después del cuantificador)

<.*?>     → Coincide: "<div>" y "</div>" por separado

Codicioso	Perezoso	Descripción
*	*?	0 o más (perezoso)
+	+?	1 o más (perezoso)
?	??	0 o 1 (perezoso)
{n,m}	{n,m}?	Entre n y m (perezoso)

Ejemplo:

Texto: "Hola" y "Mundo"

• ".*" coincide: "Hola" y "Mundo" (codicioso)
• ".*?" coincide: "Hola" y "Mundo" por separado (perezoso)

---

Anclas y Límites

Las anclas coinciden con posiciones, no caracteres.

Patrón	Descripción	Ejemplo	Coincide
^	Inicio de cadena/línea	^Hola	"Hola Mundo" (al inicio)
$	Fin de cadena/línea	Mundo$	"Hola Mundo" (al final)
\b	Límite de palabra	\bgato\b	"gato" en "El gato sentó" (NO "categoría")
\B	No-límite de palabra	\Bgato	"categoría" (gato NO en límite)
\A	Inicio de cadena (no línea)	\AHola	Solo coincide si "Hola" está al inicio absoluto
\z	Fin de cadena (no línea)	Mundo\z	Solo coincide si "Mundo" está al final absoluto
\Z	Fin de cadena (antes de nueva línea final)	Mundo\Z	Coincide "Mundo" o "Mundo\n"

Ejemplos:

^gato$        → Coincide: "gato" (línea completa es "gato")
\bgato\b      → Coincide: "gato" en "el gato sentó" (palabra completa)
\Bgato        → Coincide: "gato" en "categoría" (NO en límite)

Modo Multilínea (flag m):

• Sin m: ^ y $ coinciden inicio/fin de cadena completa
• Con m: ^ y $ coinciden inicio/fin de cada línea

---

Grupos y Alternancia

Grupos de Captura

Los grupos de captura (...) recuerdan el texto coincidente:

(\d+)-(\d+)   → Coincide: "123-456"
                Grupo 1: "123"
                Grupo 2: "456"

Retroreferencias (reutilizar grupos capturados):

(\w)\1        → Coincide: "aa", "bb", "cc" (carácter repetido)
(\w+) \1      → Coincide: "hola hola" (palabra repetida)

Grupos No-Capturadores

Use (?:...) cuando necesite agrupación pero no necesite capturar:

(?:https?://)  → Agrupa "http://" o "https://" sin capturar

¿Por qué usar no-capturadores?

• Rendimiento más rápido (sin overhead de memoria)
• Retroreferencias más limpias (grupos numerados solo cuentan grupos de captura)

Alternancia (O)

Use | para "coincide esto O aquello":

gato|perro     → Coincide: "gato" o "perro"
gris|grisáceo  → Coincide: "gris" o "grisáceo"

Ejemplos:

(Sr|Sra|Dr)\.?   → Coincide: "Sr.", "Sra.", "Dr."
https?://        → Coincide: "http://" o "https://"

Aserciones Lookaround

Los lookarounds son aserciones de anchura cero que coinciden con una posición (como anclas) pero con condiciones.

Lookahead Positivo (?=...)

Coincide si el patrón adelante coincide (pero no lo consume):

\d(?=px)      → Coincide: "10" en "10px" (NO la parte "px")

Caso de uso: Validación de contraseña

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

Desglose:

• (?=.*[A-Z]) - Debe contener mayúscula
• (?=.*[a-z]) - Debe contener minúscula
• (?=.*\d) - Debe contener dígito
• (?=.*[@$!%*?&]) - Debe contener carácter especial
• .{8,} - Al menos 8 caracteres

Lookahead Negativo (?!...)

Coincide si el patrón adelante NO coincide:

\d(?!px)      → Coincide: "10" en "10em" (NO "10px")

Caso de uso: Excluir ciertas palabras

\b(?!test)\w+  → Coincide palabras que NO empiezan con "test"

Lookbehind Positivo (?<=...)

Coincide si el patrón atrás coincide:

(?<=\$)\d+    → Coincide: "100" en "$100" (NO la parte "$")

Caso de uso: Extraer precios

(?<=Precio: \$)\d+\.\d{2}  → Coincide: "29.99" en "Precio: $29.99"

Lookbehind Negativo (?<!...)

Coincide si el patrón atrás NO coincide:

(?<!\$)\d+    → Coincide: "100" pero NO en "$100"

Tabla Resumen:

Tipo	Sintaxis	Descripción	Ejemplo
Lookahead Positivo	(?=...)	Coincide si seguido por...	q(?=u) coincide "q" en "queen"
Lookahead Negativo	(?!...)	Coincide si NO seguido por...	q(?!u) coincide "q" en "iraq"
Lookbehind Positivo	(?<=...)	Coincide si precedido por...	(?<=\$)\d+ coincide "10" en "$10"
Lookbehind Negativo	(?<!...)	Coincide si NO precedido por...	(?<!\$)\d+ coincide "10" en "10"

---

Grupos de Captura Nombrados

Los grupos nombrados (?<nombre>...) hacen regex más legible:

JavaScript:

const dateRegex = /(?<año>\d{4})-(?<mes>\d{2})-(?<día>\d{2})/;
const match = '2025-01-17'.match(dateRegex);

console.log(match.groups.año);  // "2025"
console.log(match.groups.mes);  // "01"
console.log(match.groups.día);  // "17"

Python:

import re

pattern = r'(?P<año>\d{4})-(?P<mes>\d{2})-(?P<día>\d{2})'
match = re.search(pattern, '2025-01-17')

print(match.group('año'))   # "2025"
print(match.group('mes'))   # "01"
print(match.group('día'))   # "17"

C#:

var pattern = @"(?<año>\d{4})-(?<mes>\d{2})-(?<día>\d{2})";
var match = Regex.Match("2025-01-17", pattern);

Console.WriteLine(match.Groups["año"].Value);  // "2025"

---

Grupos Atómicos y Cuantificadores Posesivos

Grupos Atómicos (?>...)

Una vez coincidente, el grupo no retrocede. Previene retroceso catastrófico:

(?>\d+)bar    → Coincide: "123bar" (rápido)

Sin grupo atómico:

\d+bar        → Intenta: "123bar", "12bar", "1bar" (lento en falla)

Cuantificadores Posesivos

Codicioso	Posesivo	Descripción
*	*+	0 o más (sin retroceso)
+	++	1 o más (sin retroceso)
?	?+	0 o 1 (sin retroceso)

Caso de uso: Prevenir retroceso catastrófico en patrones complejos.

---

Soporte Unicode

Los motores modernos de regex soportan categorías y scripts Unicode.

Categorías Unicode \p{...}

JavaScript (ES2018+):

const letras = /\p{L}+/u;      // Cualquier letra (cualquier idioma)
const números = /\p{N}+/u;     // Cualquier número
const moneda = /\p{Sc}/u;      // Símbolos de moneda

Python:

import regex  # Nota: requiere módulo 'regex', no 're'

letras = regex.compile(r'\p{L}+')

Categorías Unicode Comunes:

Categoría	Descripción	Ejemplo
\p{L}	Letra	"a", "字", "א"
\p{N}	Número	"1", "①", "一"
\p{S}	Símbolo	"$", "©", "♥"
\p{Sc}	Símbolo de moneda	"$", "€", "¥"
\p{P}	Puntuación	".", "!", "?"
\p{Z}	Separador	Espacio, tab

Scripts Unicode:

/\p{Script=Greek}/u     → Coincide letras griegas: "α", "β", "γ"
/\p{Script=Cyrillic}/u  → Coincide cirílico: "а", "б", "в"
/\p{Script=Han}/u       → Coincide caracteres chinos

Negación:

/\P{L}+/u   → Coincide cualquier cosa que NO sea letra

---

Modificadores y Flags

Las flags cambian cómo se interpretan los patrones regex.

Flag	Nombre	Descripción	Ejemplo
i	Insensible	Ignora mayúsculas	/hola/i coincide "Hola"
g	Global	Encuentra todas las coincidencias	/gato/g encuentra todos "gato"
m	Multilínea	^ y $ coinciden inicio/fin de línea	/^hola/m
s	Dotall	. coincide nuevas líneas también	/a.b/s coincide "a\nb"
u	Unicode	Habilita características Unicode	/\p{L}+/u
x	Extendido	Ignora espacios (free-spacing)	Permite comentarios
y	Sticky	Coincide en posición exacta	Solo JavaScript

Ejemplos:

Insensible (i):

/hola/i.test('HOLA')   // true

Global (g):

'gato perro gato'.match(/gato/g)   // ["gato", "gato"]

Multilínea (m):

const texto = 'Línea 1\nLínea 2';
/^Línea 2/m.test(texto)   // true (sin 'm': false)

Dotall (s):

/a.b/s.test('a\nb')   // true (sin 's': false)

Modificadores Inline

Aplicar flags a parte del patrón:

(?i)hola       → "hola" insensible
(?-i)MUNDO     → "MUNDO" sensible
(?i:hola)      → Solo "hola" es insensible

---

Patrones Condicionales

Sintaxis: (?(condición)verdadero|falso)

Ejemplo: Coincidir cadenas con o sin comillas

("|')?[^"'\r\n]*(?(1)\1)

Desglose:

• ("|')? - Opcionalmente captura comillas de apertura
• [^"'\r\n]* - Coincide contenido
• (?(1)\1) - Si grupo 1 coincidió (comillas de apertura), coincide comillas de cierre iguales

Coincide:

• "hola" ✅
• 'mundo' ✅
• prueba ✅ (sin comillas)
• "mixto' ❌ (comillas incompatibles)

---

Comentarios en Regex

Comentarios Inline (?# comentario)

\d{3}(?# código de área)-\d{3}(?# prefijo)-\d{4}(?# número de línea)

Modo Free-Spacing (flag x)

Ignora espacios y permite comentarios:

(?x)
  \d{3}     # código de área
  -         # separador
  \d{3}     # prefijo
  -         # separador
  \d{4}     # número de línea

¡Mucho más legible para patrones complejos!

Esta sección demuestra cómo usar regex en 7 lenguajes de programación populares. Cada lenguaje tiene su propia API de regex, pero la sintaxis de patrón central permanece mayormente consistente.

JavaScript / Node.js

Creando Patrones Regex

// Notación literal (más común)
const pattern1 = /\d{3}-\d{4}/;

// Constructor (cuando el patrón es dinámico)
const pattern2 = new RegExp('\\d{3}-\\d{4}');
// Nota: Las barras invertidas deben escaparse en cadenas

// Con flags
const pattern3 = /hola/gi;  // Global, insensible

Métodos de String

// .match() - Encontrar coincidencias
const texto = 'Contacto: 123-4567 o 987-6543';
const matches = texto.match(/\d{3}-\d{4}/g);
console.log(matches);  // ["123-4567", "987-6543"]

// .matchAll() - Obtener todas coincidencias con grupos (ES2020)
const emailPattern = /([\w.-]+)@([\w.-]+\.[a-z]{2,})/gi;
const emails = 'admin@ejemplo.com, user@prueba.org';
for (const match of emails.matchAll(emailPattern)) {
  console.log(`Usuario: ${match[1]}, Dominio: ${match[2]}`);
}
// Usuario: admin, Dominio: ejemplo.com
// Usuario: user, Dominio: prueba.org

// .search() - Encontrar posición de primera coincidencia
const pos = 'Hola Mundo'.search(/Mundo/);
console.log(pos);  // 5

// .replace() - Reemplazar coincidencias
const teléfono = '(123) 456-7890';
const limpio = teléfono.replace(/[^\d]/g, '');
console.log(limpio);  // "1234567890"

// .replaceAll() - Reemplazar todas coincidencias (ES2021)
const texto2 = 'gato perro gato';
const resultado = texto2.replaceAll(/gato/g, 'pájaro');
console.log(resultado);  // "pájaro perro pájaro"

// .split() - Dividir por patrón
const csv = 'manzana,banana, naranja , uva';
const frutas = csv.split(/\s*,\s*/);
console.log(frutas);  // ["manzana", "banana", "naranja", "uva"]

Las demás secciones (Python, PHP, C#, Java, Go, Ruby) siguen el mismo formato con ejemplos completos y adaptados al español...

El Find and Replace de Visual Studio Code (Ctrl/Cmd+H) soporta regex con capacidades poderosas de transformación. Esta sección muestra 28 ejemplos prácticos que los desarrolladores usan todos los días.

Accediendo Find & Replace

Atajos de Teclado:

• Buscar: Ctrl+F (Windows/Linux) / Cmd+F (Mac)
• Reemplazar: Ctrl+H (Windows/Linux) / Cmd+H (Mac)
• Habilitar Regex: Click en el botón .* o presione Alt+R

Consejos:

• Use Ctrl+Enter (Cmd+Enter) para reemplazar todas
• Vista previa de coincidencias antes de reemplazar (se destacan en amarillo)
• Use F3 / Shift+F3 para navegar entre coincidencias

---

Transformaciones de Mayúsculas/Minúsculas

VS Code soporta secuencias especiales de reemplazo para conversión de mayúsculas:

Secuencia	Efecto	Ejemplo
\l	Minúscula siguiente carácter	\l
\u	Mayúscula siguiente carácter	\u
\L	Minúscula todos los caracteres siguientes	\L
\U	Mayúscula todos los caracteres siguientes	\U
\E	Terminar transformación de mayúsculas	\U\E

Ejemplo 1: Capitalizar Primera Letra

Buscar:

\b(\w)(\w*)

Reemplazar:

\u$1$2

Antes:

hola mundo

Después:

Hola Mundo

Esta sección proporciona más de 25 patrones regex listos para usar.

Validación de Email

^[\w.-]+@[\w.-]+\.[a-z]{2,}$

Números de Teléfono (España)

^(\+?34)?\s?\d{3}\s?\d{3}\s?\d{3}$

Fechas (ISO 8601)

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

URLs

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

Direcciones IPv4

^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$

Colores Hexadecimales

^#?([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$

Contraseña Fuerte

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

Nombre de Usuario (3-16 caracteres)

^[a-zA-Z0-9_-]{3,16}$

UUID v4

^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$

¡Y más de 15 patrones con documentación completa!

Aplicaciones de regex del mundo real en desarrollo.

Validación de Formularios

const validadores = {
  email: /^[\w.-]+@[\w.-]+\.[a-z]{2,}$/i,
  teléfono: /^\+?34?\d{3}\d{3}\d{3}$/
};

Extracción de Datos

Extraer emails del texto:

import re
emails = re.findall(r'[\w.-]+@[\w.-]+\.[a-z]{2,}', texto)

Análisis de Logs

patrón = r'(?P<ip>[\d.]+).+(?P<estado>\d{3})'

Refactorización de Código

Convertir llamadas antiguas de API en VS Code:

Buscar: apiClient\.get\('([^']+)'\)
Reemplazar: fetch('$1').then(r => r.json())

Errores Comunes

1. Olvidar Escapar Caracteres Especiales

❌ Incorrecto: archivo.txt
✅ Correcto: archivo\.txt

2. Codicioso vs Perezoso

❌ Codicioso: <.*> coincide todo <div>texto</div>
✅ Perezoso: <.*?> coincide <div> y </div> por separado

3. No Usar Anclas

❌ /\d{3}/ coincide "123" en "abc123def"
✅ /^\d{3}$/ solo coincide exactamente "123"

Consejos de Rendimiento

1. Use clases de caracteres específicas en lugar de .
2. Ancle patrones cuando sea posible
3. Evite cuantificadores anidados (retroceso catastrófico)
4. Use grupos atómicos para rendimiento
5. Compile patrones para reutilización

Depuración

1. Pruebe en regex101.com
2. Use modo verbose con comentarios
3. Divida patrones complejos en partes
4. Pruebe casos extremos

Herramientas Online

Testeadores de Regex

• regex101.com - Mejor testeador con explicaciones
• regexr.com - Constructor visual de regex
• regexpal.com - Simple y rápido

Visualizadores

• debuggex.com - Diagramas ferroviarios
• regexper.com - Herramienta visual

Recursos de Aprendizaje

• regexone.com - Lecciones interactivas
• regexlearn.com - Guía paso a paso
• regular-expressions.info - Documentación

Extensiones IDE

• Regex Previewer (VS Code)
• Regex Tester (VS Code)

Clases de Caracteres

Patrón	Coincide
\d	Dígito [0-9]
\w	Palabra [a-zA-Z0-9_]
\s	Espacio en blanco
.	Cualquier carácter

Cuantificadores

Patrón	Significado
*	0 o más
+	1 o más
?	0 o 1
{n}	Exactamente n

Anclas

Patrón	Significado
^	Inicio de línea
$	Fin de línea
\b	Límite de palabra

Flags

Flag	Significado
i	Insensible
g	Global
m	Multilínea
s	Dotall

Preguntas Generales

P: ¿Cuál es la diferencia entre cuantificadores codiciosos y perezosos?

R: Codiciosos coinciden lo máximo posible. Perezosos (*?, +?) coinciden lo mínimo posible.

P: ¿Cómo coincidir un punto literal?

R: Escape con barra invertida: \.

P: ¿Qué es retroceso catastrófico?

R: Cuando regex intenta muchas combinaciones, causando lentitud. Evite cuantificadores anidados como (a+)+.

P: ¿Puede regex validar email perfectamente?

R: No. Use regex para formato básico, luego verifique vía email.

P: ¿Cómo coincidir en múltiples líneas?

R: Use la flag s, o use [\s\S]* en lugar de .*.

Específico de VS Code

P: ¿Cómo reemplazar con mayúscula en VS Code?

R: Use \u (mayúscula siguiente), \U (mayúscula todos).

P: ¿Puedo usar regex en la búsqueda de archivos de VS Code?

R: ¡Sí! Presione Ctrl+Shift+F y habilite regex (Alt+R).

Extensión Chrome Regex Data Extractor

Nuestro Regex Data Extractor le ayuda a extraer datos de páginas web usando patrones de esta guía.

Características Principales

• Biblioteca de Patrones: Patrones pre-construidos
• Prueba en Vivo: Pruebe regex en cualquier página web
• Exportación Multi-Formato: CSV, JSON, Excel, PDF
• Extracción por Lotes: Extraer de múltiples páginas

Ejemplo: Extraer Emails

1. Instale Regex Data Extractor
2. Navegue a cualquier página web
3. Haga clic en el icono de la extensión
4. Ingrese el patrón: [\w.-]+@[\w.-]+\.[a-z]{2,}
5. Haga clic en "Extraer"
6. Exporte a CSV/JSON

Ejemplo: Extraer Precios

Patrón: €\s?([0-9]{1,3}(?:\.[0-9]{3})*,?[0-9]{2})
Captura: €1.234,56, €99,99

Consejos Profesionales

• Guarde patrones usados frecuentemente
• Use grupos nombrados para datos estructurados
• Pruebe patrones primero
• Exporte para análisis de datos

Obtener Regex Data Extractor →