Introducción
Las expresiones regulares, a menudo llamadas "regex" o "regexp", son una de las herramientas más poderosas en el conjunto de herramientas de un desarrollador. Le permiten buscar, coincidir y manipular texto con increíble precisión. Sin embargo, muchos desarrolladores encuentran regex intimidante, con su sintaxis críptica y capacidades aparentemente mágicas.
Esta guía desmitificará las expresiones regulares enfocándose en patrones prácticos del mundo real que realmente usará. Al final, comprenderá no solo cómo funciona regex, sino también cuándo y por qué usarlo.
¿Qué Son las Expresiones Regulares?
Una expresión regular es una secuencia de caracteres que define un patrón de búsqueda. Piense en ella como una función "Buscar" súper poderosa que puede coincidir con patrones de texto complejos, no solo cadenas exactas.
¿Por Qué Usar Regex?
- Coincidencia de Patrones: Encontrar texto que sigue un patrón específico
- Validación: Verificar formatos de datos (correos, números de teléfono, etc.)
- Procesamiento de Texto: Extraer, reemplazar o transformar texto
- Buscar y Reemplazar: Encontrar y modificar texto en masa
- Extracción de Datos: Extraer información específica de texto no estructurado
Conceptos Básicos
Antes de sumergirse en patrones, comprenda estos conceptos centrales:
- Caracteres Literales: Coincidir texto exacto
- Metacaracteres: Caracteres especiales con significado (., *, +, ?, etc.)
- Clases de Caracteres: Coincidir conjuntos de caracteres ([a-z], \d, etc.)
- Cuantificadores: Especificar cuántas veces coincidir (*, +, ?, {n})
- Anclas: Coincidir posiciones (^, $, \b)
- Grupos: Capturar y organizar coincidencias ((...))
Patrones Regex Esenciales
1. Validación de Email
Uno de los casos de uso de regex más comunes:
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
Desglose:
^- Inicio de cadena[a-zA-Z0-9._%+-]+- Uno o más caracteres alfanuméricos, puntos, guiones bajos, etc.@- Símbolo @ literal[a-zA-Z0-9.-]+- Parte del dominio\.- Punto literal (escapado)[a-zA-Z]{2,}- Dominio de nivel superior (2+ letras)$- Fin de cadena
Uso:
const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
if (emailRegex.test(userEmail)) {
console.log("Email válido");
}
2. Coincidencia de Números de Teléfono
Coincidir varios formatos de números telefónicos:
^(\+?1[-.\s]?)?\(?([0-9]{3})\)?[-.\s]?([0-9]{3})[-.\s]?([0-9]{4})$
Coincide:
- (123) 456-7890
- 123-456-7890
- 123.456.7890
- +1 123 456 7890
- 1234567890
3. Validación de URL
Coincidir URLs web:
^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$
Desglose:
^https?://- Protocolo (http o https)(www\.)?- www opcional[-a-zA-Z0-9@:%._\+~#=]{1,256}- Nombre de dominio\.[a-zA-Z0-9()]{1,6}- Dominio de nivel superior\b- Límite de palabra([-a-zA-Z0-9()@:%_\+.~#?&//=]*)- Ruta opcional
4. Fuerza de Contraseña
Verificar contraseñas fuertes:
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$
Requisitos:
- Al menos una letra minúscula
- Al menos una letra mayúscula
- Al menos un dígito
- Al menos un carácter especial
- Mínimo 8 caracteres
5. Números de Tarjetas de Crédito
Coincidir formatos comunes de tarjetas de crédito:
^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|3[0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12})$
Coincide:
- Visa: 4xxxxxxxxxxxxx
- MasterCard: 5xxxxxxxxxxxxxx
- American Express: 34xxxxxxxxxxxxx o 37xxxxxxxxxxxxx
- Discover: 6011xxxxxxxxxxxx
Clases de Caracteres Comunes
Clases Predefinidas
\d # Cualquier dígito [0-9]
\w # Carácter de palabra [a-zA-Z0-9_]
\s # Espacio en blanco [ \t\n\r\f\v]
\D # No dígito [^0-9]
\W # No carácter de palabra [^a-zA-Z0-9_]
\S # No espacio en blanco [^ \t\n\r\f\v]
Clases de Caracteres Personalizadas
[aeiou] # Coincidir cualquier vocal
[^aeiou] # Coincidir cualquier cosa excepto vocales
[a-z] # Coincidir letras minúsculas
[A-Z] # Coincidir letras mayúsculas
[0-9] # Coincidir dígitos
[a-zA-Z0-9] # Coincidir alfanumérico
[0-9a-fA-F] # Coincidir hexadecimal
Cuantificadores
Controlar cuántas veces coincide un patrón:
* # Cero o más (codicioso)
+ # Uno o más (codicioso)
? # Cero o uno (opcional)
{n} # Exactamente n veces
{n,} # n o más veces
{n,m} # Entre n y m veces
*? # Cero o más (perezoso)
+? # Uno o más (perezoso)
Ejemplos
a* # Coincide "", "a", "aa", "aaa", ...
a+ # Coincide "a", "aa", "aaa", ... (no "")
a? # Coincide "", "a"
a{3} # Coincide exactamente "aaa"
a{3,} # Coincide "aaa", "aaaa", "aaaaa", ...
a{3,5} # Coincide "aaa", "aaaa", "aaaaa"
Anclas y Límites
Anclas de Posición
^ # 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
\B # No límite de palabra
\A # Inicio de cadena (siempre)
\Z # Fin de cadena (siempre)
Ejemplos
^Hello # "Hello" al inicio
World$ # "World" al final
\bword\b # Palabra completa "word" (no "sword" o "words")
Grupos y Captura
Grupos de Captura
(abc) # Grupo de captura
(?:abc) # Grupo sin captura
(?<name>abc) # Grupo de captura con nombre
Ejemplos
const regex = /(\d{3})-(\d{3})-(\d{4})/;
const match = "123-456-7890".match(regex);
// match[0] = "123-456-7890" (coincidencia completa)
// match[1] = "123" (primer grupo)
// match[2] = "456" (segundo grupo)
// match[3] = "7890" (tercer grupo)
Lookaheads y Lookbehinds
Lookahead Positivo
(?=pattern) # Debe estar seguido por patrón
Ejemplo: Coincidir "cat" solo si seguido por "s":
cat(?=s) # Coincide "cat" en "cats" pero no "cat" en "catch"
Lookahead Negativo
(?!pattern) # NO debe estar seguido por patrón
Ejemplo: Coincidir "cat" solo si NO seguido por "s":
cat(?!s) # Coincide "cat" en "catch" pero no "cat" en "cats"
Lookbehinds
(?<=pattern) # Debe estar precedido por patrón
(?<!pattern) # NO debe estar precedido por patrón
Casos de Uso del Mundo Real
1. Validación de Formularios
// Validación de email
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
if (!emailRegex.test(email)) {
return "Formato de email inválido";
}
// Validación de teléfono
const phoneRegex = /^\+?[\d\s\-()]+$/;
if (!phoneRegex.test(phone)) {
return "Número de teléfono inválido";
}
2. Extracción de Texto
// Extraer todas las direcciones de email del texto
const text = "Contáctenos en [email protected] o [email protected]";
const emailRegex = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g;
const emails = text.match(emailRegex);
// ["[email protected]", "[email protected]"]
3. Reemplazo de Texto
// Enmascarar números de tarjetas de crédito
const cardNumber = "1234-5678-9012-3456";
const masked = cardNumber.replace(/\d{4}(?=\d)/g, "****-");
// "****-****-****-3456"
4. Limpieza de Datos
// Eliminar espacios extra
const text = "Hola mundo de regex";
const cleaned = text.replace(/\s+/g, " ");
// "Hola mundo de regex"
// Eliminar caracteres especiales
const dirty = "Hola@Mundo#123!";
const clean = dirty.replace(/[^a-zA-Z0-9\s]/g, "");
// "HolaMundo123"
5. Análisis de URL
const urlRegex = /^https?:\/\/([^\/]+)(\/.*)?$/;
const url = "https://example.com/path/to/page";
const match = url.match(urlRegex);
// match[1] = "example.com"
// match[2] = "/path/to/page"
Errores Comunes
Error 1: Patrones Demasiado Complejos
# MALO: Demasiado complejo
^([a-zA-Z0-9_\-\.]+)@([a-zA-Z0-9_\-\.]+)\.([a-zA-Z]{2,5})$
# BUENO: Más simple y mantenible
^[^\s@]+@[^\s@]+\.[^\s@]+$
Error 2: No Escapar Caracteres Especiales
# MALO: El punto coincide con cualquier carácter
/example.com/
# BUENO: Punto escapado coincide con punto literal
/example\.com/
Error 3: Coincidencia Codiciosa vs Perezosa
# Codicioso: Coincide tanto como sea posible
/<.*>/ # Coincide todo "<div><p>text</p></div>"
# Perezoso: Coincide lo menos posible
/<.*?>/ # Coincide etiquetas individuales "<div>", "<p>", etc.
Consejos de Rendimiento
- Compilar Una Vez: Si usa el mismo regex repetidamente, compílelo una vez
- Usar Anclas:
^y$hacen la coincidencia más rápida - Evitar Backtracking Catastrófico: Cuidado con cuantificadores anidados
- Usar Patrones Específicos: Patrones más específicos son más rápidos
- Considerar Alternativas: A veces métodos de cadena son más rápidos que regex
Probar Su Regex
Herramientas en Línea
- Regex101: Probar y depurar patrones regex
- Regexr: Prueba interactiva de regex
- RegEx Pal: Probador simple de regex
Mejores Prácticas
- Probar con varias entradas
- Probar casos límite (cadenas vacías, caracteres especiales)
- Probar con entradas inválidas
- Documentar sus patrones
- Usar comentarios en regex complejo
Conclusión
Las expresiones regulares son una herramienta poderosa que, cuando se domina, puede mejorar dramáticamente sus capacidades de procesamiento de texto. Comience con patrones simples, practique regularmente y avance gradualmente hacia expresiones más complejas.
Recuerde: Regex es una herramienta, no una solución para cada problema. A veces métodos simples de cadena son más apropiados. Pero cuando necesita coincidencia de patrones, validación o extracción de texto, regex es a menudo la mejor opción.
La clave para dominar regex es la práctica. Comience con los patrones comunes en esta guía, comprenda cómo funcionan, luego adáptelos a sus necesidades específicas.
Usar Nuestras Herramientas Regex
En 1tool.dev, ofrecemos un poderoso Probador de Regex que le ayuda a probar, depurar y comprender expresiones regulares. Nuestra herramienta proporciona coincidencia en tiempo real, explicaciones detalladas y soporta múltiples variantes de regex.
¡Pruebe nuestro probador de regex hoy y conviértase en un experto en regex!
