Dominando Expresiones Regulares 2026

"Las expresiones regulares son dificiles" - es cierto. Pero una vez que las dominas, puedes reducir el tiempo de procesamiento de texto en un 90%.

Esta guia cubre los patrones regex mas utilizados en la practica con ejemplos.

---

Fundamentos de Regex

Sintaxis Basica

Clases de Caracteres

[abc]     - Uno de a, b, c
[^abc]    - Excepto a, b, c
[a-z]     - De a hasta z
[A-Z]     - De A hasta Z
[0-9]     - De 0 hasta 9
[a-zA-Z]  - Todas las letras

Cuantificadores

{n}       - Exactamente n
{n,}      - n o mas
{n,m}     - Entre n y m
*         - 0 o mas ({0,})
+         - 1 o mas ({1,})
?         - 0 o 1 ({0,1})

Grupos y Captura

(abc)     - Grupo de captura
(?:abc)   - Grupo sin captura
(?<name>abc) - Grupo nombrado
\1        - Referencia al primer grupo

---

Patrones Practicos: Validacion

Direccion de Email

// Patron basico
const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;

// Prueba
emailRegex.test('user@example.com');  // true
emailRegex.test('invalid-email');      // false

Analisis del Patron:

^                     - Inicio
[a-zA-Z0-9._%+-]+     - Parte local (1+ caracteres)
@                     - Simbolo @
[a-zA-Z0-9.-]+        - Dominio (1+ caracteres)
\.                    - . (escapado)
[a-zA-Z]{2,}          - TLD (2+ caracteres)
$                     - Fin

URL

const urlRegex = /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/;

// Prueba
urlRegex.test('https://example.com');           // true
urlRegex.test('https://sub.example.com/path');  // true
urlRegex.test('invalid url');                   // false

Numero de Telefono (Espana)

// Movil espanol
const mobileRegex = /^(\+34)?[6-7]\d{8}$/;

// Fijo espanol
const phoneRegex = /^(\+34)?9\d{8}$/;

// Prueba
mobileRegex.test('+34612345678');  // true
mobileRegex.test('612345678');      // true

Fortaleza de Contrasena

// Minimo 8 caracteres, mayuscula/minuscula, numero, caracter especial
const strongPassword = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;

// Analisis del patron
// (?=.*[a-z])   - Al menos 1 minuscula (lookahead)
// (?=.*[A-Z])   - Al menos 1 mayuscula
// (?=.*\d)      - Al menos 1 digito
// (?=.*[@$!%*?&]) - Al menos 1 caracter especial
// {8,}          - 8 o mas caracteres

Numero de Tarjeta de Credito

// Visa
const visaRegex = /^4[0-9]{12}(?:[0-9]{3})?$/;

// MasterCard
const mastercardRegex = /^5[1-5][0-9]{14}$/;

// Todas las tarjetas (con guiones opcionales)
const cardRegex = /^\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}$/;

---

Patrones Practicos: Extraccion de Texto

Extraccion de Contenido de Etiquetas HTML

const html = '<div class="title">Hello World</div>';

// Extraer contenido de etiqueta
const contentRegex = /<div[^>]*>(.*?)<\/div>/;
const match = html.match(contentRegex);
console.log(match[1]); // "Hello World"

// Eliminar todas las etiquetas
const noTags = html.replace(/<[^>]*>/g, '');
console.log(noTags); // "Hello World"

Extraer Dominio de URL

const url = 'https://www.example.com/path/page.html';

const domainRegex = /^(?:https?:\/\/)?(?:www\.)?([^/]+)/;
const domain = url.match(domainRegex)[1];
console.log(domain); // "example.com"

Analisis de Archivo de Log

const logLine = '[2026-02-21 14:30:45] ERROR: Connection timeout at module.js:42';

const logRegex = /\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] (\w+): (.+) at (.+):(\d+)/;

const [, datetime, level, message, file, line] = logLine.match(logRegex);

console.log({
  datetime,  // "2026-02-21 14:30:45"
  level,     // "ERROR"
  message,   // "Connection timeout"
  file,      // "module.js"
  line,      // "42"
});

Analisis de CSV (Separado por Comas)

const csvLine = 'John,"Doe, Jr.",30,"New York, NY"';

// Dividir por coma (ignorar comas dentro de comillas)
const csvRegex = /(?:^|,)("(?:[^"]*(?:""[^"]*)*)"|[^,]*)/g;

const fields = [];
let match;
while ((match = csvRegex.exec(csvLine)) !== null) {
  fields.push(match[1].replace(/^"|"$/g, '').replace(/""/g, '"'));
}

console.log(fields); // ["John", "Doe, Jr.", "30", "New York, NY"]

---

Patrones Practicos: Busqueda y Reemplazo

Formateo de Numero de Telefono

const phone = '612345678';

// Agregar espacios
const formatted = phone.replace(/(\d{3})(\d{3})(\d{3})/, '$1 $2 $3');
console.log(formatted); // "612 345 678"

Formateo de Numeros

const amount = '1234567890';

// Separadores de miles
const formatted = amount.replace(/\B(?=(\d{3})+(?!\d))/g, '.');
console.log(formatted); // "1.234.567.890"

Enmascaramiento

// Enmascarar email
const email = 'username@example.com';
const masked = email.replace(/(.{2})(.*)(@.*)/, '$1***$3');
console.log(masked); // "us***@example.com"

// Enmascarar telefono
const phone = '612-345-678';
const maskedPhone = phone.replace(/(\d{3})-(\d{3})-(\d{3})/, '$1-***-$3');
console.log(maskedPhone); // "612-***-678"

Limpieza de Espacios en Blanco

const text = '  Hello    World  ';

// Eliminar espacios al inicio/final
const trimmed = text.replace(/^\s+|\s+$/g, '');

// Normalizar multiples espacios a uno
const normalized = text.replace(/\s+/g, ' ').trim();
console.log(normalized); // "Hello World"

---

Funciones Avanzadas

Lookahead

// Lookahead positivo: (?=...)
// Coincidir "foo" solo si seguido de "bar"
const regex = /foo(?=bar)/;
'foobar'.match(regex);  // ["foo"]
'foobaz'.match(regex);  // null

// Lookahead negativo: (?!...)
// Coincidir "foo" solo si NO seguido de "bar"
const regex2 = /foo(?!bar)/;
'foobaz'.match(regex2); // ["foo"]
'foobar'.match(regex2); // null

Lookbehind

// Lookbehind positivo: (?<=...)
// Numeros precedidos por "$"
const priceRegex = /(?<=\$)\d+/g;
'$100 and $200'.match(priceRegex); // ["100", "200"]

// Lookbehind negativo: (?<!...)
// Numeros NO precedidos por "$"
const nonPriceRegex = /(?<!\$)\d+/g;
'$100 and 200'.match(nonPriceRegex); // ["200"]

Grupos Nombrados

const dateRegex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const match = '2026-02-21'.match(dateRegex);

console.log(match.groups.year);  // "2026"
console.log(match.groups.month); // "02"
console.log(match.groups.day);   // "21"

No Codicioso (Non-Greedy)

const html = '<div>Hello</div><div>World</div>';

// Codicioso (por defecto): Coincidir lo mas posible
/<div>.*<\/div>/.exec(html)[0];
// "<div>Hello</div><div>World</div>"

// No codicioso: Coincidir lo menos posible
/<div>.*?<\/div>/.exec(html)[0];
// "<div>Hello</div>"

---

Implementacion por Lenguaje

JavaScript

// Metodos de creacion
const regex1 = /pattern/flags;
const regex2 = new RegExp('pattern', 'flags');

// Metodos
regex.test(str);        // boolean
str.match(regex);       // array o null
str.replace(regex, replacement);
str.split(regex);
regex.exec(str);        // info detallada de coincidencia

// Flags
// g: Busqueda global
// i: Ignorar mayusculas/minusculas
// m: Multilinea
// s: dotAll (. coincide con nueva linea)
// u: Unicode

Python

import re

# Compilar
pattern = re.compile(r'pattern', re.IGNORECASE)

# Metodos
re.match(pattern, string)   # Coincidir desde inicio
re.search(pattern, string)  # Buscar en toda la cadena
re.findall(pattern, string) # Lista de todas las coincidencias
re.sub(pattern, repl, string) # Reemplazar

# Ejemplo
emails = re.findall(r'[\w.+-]+@[\w.-]+\.\w+', text)
cleaned = re.sub(r'\s+', ' ', text).strip()

Go

import "regexp"

// Compilar
re := regexp.MustCompile(`\d+`)

// Metodos
re.MatchString(s)          // bool
re.FindString(s)           // Primera coincidencia
re.FindAllString(s, -1)    // Todas las coincidencias
re.ReplaceAllString(s, r)  // Reemplazar

// Ejemplo
numbers := re.FindAllString("a1b2c3", -1)
// ["1", "2", "3"]

---

Optimizacion de Rendimiento

Reutilizar Regex Compilada

// Lento: Compila cada vez
function validate(email) {
  return /^[\w.+-]+@[\w.-]+\.\w+$/.test(email);
}

// Rapido: Compilar una vez
const emailRegex = /^[\w.+-]+@[\w.-]+\.\w+$/;
function validate(email) {
  return emailRegex.test(email);
}

Usar Grupos Sin Captura

// Captura innecesaria
const regex = /(https?):\/\/(www\.)?(.+)/;

// Sin captura para grupos innecesarios
const regex = /(?:https?):\/\/(?:www\.)?(.+)/;

Evitar Backtracking Catastrofico

// Peligroso: patron (a+)+
const bad = /^(a+)+$/;
'aaaaaaaaaaaaaaaaaaaaaa!'.match(bad); // Muy lento

// Seguro: Reestructurar el patron
const good = /^a+$/;

---

Consejos de Depuracion

Usando Regex Tester

1. Ingresar patron
2. Ingresar cadena de prueba
3. Ver coincidencias resaltadas
4. Verificar grupos de captura

Validacion Paso a Paso

// Validar patrones complejos paso a paso
const parts = [
  '^',                    // Inicio
  '[a-zA-Z0-9._%+-]+',    // Parte local
  '@',                    // @
  '[a-zA-Z0-9.-]+',       // Dominio
  '\\.',                  // .
  '[a-zA-Z]{2,}',         // TLD
  '$',                    // Fin
];

const emailRegex = new RegExp(parts.join(''));

---

Preguntas Frecuentes

Q1: Cual es la diferencia entre . y \.?

R: . coincide con cualquier caracter (comodin), \. coincide con un punto literal.

Q2: Cual es la diferencia entre * y +?

R: * coincide con 0 o mas, + coincide con 1 o mas.

• ab*c -> "ac", "abc", "abbc"
• ab+c -> "abc", "abbc" ("ac" no coincide)

Q3: Como ignoro mayusculas/minusculas?

R: Usa el flag i.

• JavaScript: /pattern/i
• Python: re.IGNORECASE

Q4: Como hago que . coincida con nueva linea?

R: Usa el flag s (dotAll).

• JavaScript: /pattern/s
• Python: re.DOTALL

Q5: Que caracteres necesitan escape?

R: \ ^ $ . | ? * + ( ) [ ] { } - escapar estos con \.

---

Conclusion

Esenciales de Regex:

1. Sintaxis basica: ., *, +, ?, [], ()
2. Metacaracteres: \d, \w, \s, ^, $
3. Cuantificadores: {n}, {n,}, {n,m}
4. Funciones avanzadas: Lookahead, Lookbehind, Grupos Nombrados

La practica es clave. Prueba en tiempo real en Regex Tester.

---

Herramientas Relacionadas