Regex

¿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.

Usamos cookies para mejorar tu experiencia. ¿Aceptas las cookies de análisis?