¿Qué es Regex?

Regex (Regular Expression) es un patrón de texto que define una secuencia de caracteres para buscar, validar y manipular cadenas de texto. Es como un lenguaje especial que describe qué texto estás buscando usando una sintaxis específica de metacaracteres, cuantificadores y grupos que permiten crear patrones muy precisos y flexibles.

¿Para qué sirve Regex?

Las expresiones regulares son fundamentales en programación. Te permiten:

• Validar formatos de datos como emails, teléfonos, URLs y códigos postales.
• Buscar y extraer información específica de textos largos.
• Reemplazar patrones de texto de forma masiva y precisa.
• Limpiar y procesar datos eliminando caracteres no deseados.
• Dividir cadenas de texto basándose en patrones complejos.
• Crear validadores de formularios robustos y flexibles.

¿Cómo funciona?

Imagina Regex como un detector de patrones súper inteligente. Es como darle a alguien una descripción muy específica de lo que buscas: “quiero números que tengan exactamente 3 dígitos, seguidos de un guión, y luego exactamente 4 dígitos más”. El regex encuentra todas las coincidencias que cumplan exactamente esa descripción en cualquier texto.

Ejemplo: Regex básicos

Aquí tienes ejemplos de patrones regex comunes:

// Validar email
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
console.log(emailRegex.test('usuario@email.com')); // true
console.log(emailRegex.test('email-invalido')); // false

// Validar teléfono (formato: xxx-xxx-xxxx)
const phoneRegex = /^\d{3}-\d{3}-\d{4}$/;
console.log(phoneRegex.test('555-123-4567')); // true
console.log(phoneRegex.test('555-12-34567')); // false

// Extraer números de un texto
const numberRegex = /\d+/g;
const texto = 'Tengo 25 años y mi hermana tiene 30';
console.log(texto.match(numberRegex)); // ["25", "30"]

// Validar contraseña segura (min 8 chars, 1 mayúscula, 1 número)
const passwordRegex = /^(?=.*[A-Z])(?=.*\d).{8,}$/;
console.log(passwordRegex.test('MiPass123')); // true
console.log(passwordRegex.test('mipass123')); // false (falta mayúscula)

---

Este ejemplo muestra patrones regex comunes para validación y extracción de datos.

Ejemplo: Regex avanzado para procesamiento de texto

// Función para limpiar y formatear texto
function procesarTexto(texto) {
  // Remover espacios múltiples
  texto = texto.replace(/\s+/g, ' ');

  // Extraer URLs
  const urlRegex = /https?:\/\/[^\s]+/g;
  const urls = texto.match(urlRegex) || [];

  // Extraer mentions (@usuario)
  const mentionRegex = /@(\w+)/g;
  const mentions = [];
  let match;
  while ((match = mentionRegex.exec(texto)) !== null) {
    mentions.push(match[1]);
  }

  // Extraer hashtags
  const hashtagRegex = /#(\w+)/g;
  const hashtags = [];
  while ((match = hashtagRegex.exec(texto)) !== null) {
    hashtags.push(match[1]);
  }

  // Censurar palabras (ejemplo básico)
  const censorRegex = /\b(palabra1|palabra2)\b/gi;
  texto = texto.replace(censorRegex, '***');

  return {
    textoLimpio: texto.trim(),
    urls,
    mentions,
    hashtags,
  };
}

// Validador de formularios con regex
class ValidadorFormulario {
  constructor() {
    this.patrones = {
      nombre: /^[A-Za-zÀ-ÿ\s]{2,50}$/,
      email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
      telefono: /^(\+\d{1,3})?\s?(\d{3})\s?(\d{3})\s?(\d{4})$/,
      fecha: /^(0[1-9]|[12][0-9]|3[01])\/(0[1-9]|1[0-2])\/\d{4}$/,
      codigoPostal: /^\d{5}(-\d{4})?$/,
      tarjetaCredito: /^\d{4}\s?\d{4}\s?\d{4}\s?\d{4}$/,
    };
  }

  validar(campo, valor) {
    if (!this.patrones[campo]) {
      throw new Error(`Campo desconocido: ${campo}`);
    }

    return this.patrones[campo].test(valor);
  }

  extraerErrores(datos) {
    const errores = {};

    for (const [campo, valor] of Object.entries(datos)) {
      if (!this.validar(campo, valor)) {
        errores[campo] = `${campo} tiene un formato inválido`;
      }
    }

    return errores;
  }

  formatearTelefono(telefono) {
    const match = telefono.match(/^(\+\d{1,3})?\s?(\d{3})\s?(\d{3})\s?(\d{4})$/);
    if (match) {
      const [, codigo, area, numero1, numero2] = match;
      return `${codigo || ''}(${area}) ${numero1}-${numero2}`.trim();
    }
    return telefono;
  }
}

// Uso del validador
const validador = new ValidadorFormulario();
const datosUsuario = {
  nombre: 'Juan Pérez',
  email: 'juan@email.com',
  telefono: '555 123 4567',
  fecha: '15/12/2023',
};

console.log('Errores:', validador.extraerErrores(datosUsuario));
console.log('Teléfono formateado:', validador.formatearTelefono(datosUsuario.telefono));

Metacaracteres principales de Regex

• .: Cualquier carácter excepto salto de línea
• *: Cero o más repeticiones del carácter anterior
• +: Una o más repeticiones del carácter anterior
• ?: Cero o una repetición (opcional)
• ^: Inicio de línea o cadena
• $: Final de línea o cadena
• []: Clase de caracteres (cualquiera dentro de los corchetes)
• (): Grupos de captura

Cuantificadores y modificadores

// Cuantificadores específicos
const regexDigitos = /\d{3,5}/; // Entre 3 y 5 dígitos
const regexLetras = /[a-z]{2,}/; // Mínimo 2 letras minúsculas

// Clases de caracteres predefinidas
const regexWhitespace = /\s+/; // Espacios en blanco
const regexWord = /\w+/; // Caracteres de palabra (a-z, A-Z, 0-9, _)
const regexDigit = /\d+/; // Dígitos (0-9)

// Modificadores (flags)
const regexGlobal = /patrón/g; // Buscar todas las coincidencias
const regexInsensitive = /patrón/i; // Ignorar mayúsculas/minúsculas
const regexMultiline = /patrón/m; // Modo multilínea

¿Dónde encuentras Regex?

• En validación de formularios web para emails, contraseñas y teléfonos.
• En editores de texto y IDEs para búsqueda y reemplazo avanzado.
• En procesamiento de logs para extraer información específica.
• En web scraping para extraer datos de páginas HTML.
• En análisis de datos para limpiar y estructurar información.
• En sistemas de validación de APIs y bases de datos.

Herramientas útiles para Regex

// Tester online: regex101.com, regexr.com
// Bibliotecas útiles en JavaScript

// Escapar caracteres especiales
function escapeRegex(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

// Crear regex dinámico
function crearPatronBusqueda(terminos) {
  const terminosEscapados = terminos.map(escapeRegex);
  return new RegExp(`\\b(${terminosEscapados.join('|')})\\b`, 'gi');
}

const patron = crearPatronBusqueda(['JavaScript', 'Python', 'Java']);
console.log(patron.test('Me gusta programar en JavaScript')); // true

Conclusión

Regex es una herramienta poderosa e indispensable para cualquier desarrollador que trabaje con texto. Aunque puede parecer complejo al principio, dominar las expresiones regulares te permitirá realizar validaciones precisas, extraer datos eficientemente y manipular texto de formas que serían muy difíciles con métodos tradicionales. La clave está en practicar con patrones simples y gradualmente construir expresiones más complejas.

---