Hoja de Referencia de Regex: Patrones Comunes y Referencia Rápida
· 12 min de lectura
Tabla de Contenidos
Las expresiones regulares son una de las herramientas más poderosas en el kit de un desarrollador, sin embargo siguen siendo intimidantes para muchos programadores. Esta hoja de referencia completa desglosa los patrones de regex en secciones digeribles con ejemplos prácticos que puedes usar inmediatamente.
Ya sea que estés validando direcciones de correo electrónico, analizando archivos de registro o limpiando datos desordenados, esta guía te ayudará a escribir mejores patrones de regex más rápido. Cubriremos todo, desde la coincidencia básica de caracteres hasta aserciones avanzadas de lookaround.
Fundamentos de Regex
Las expresiones regulares (regex o regexp) son patrones utilizados para coincidir combinaciones de caracteres en cadenas. Son compatibles con prácticamente todos los lenguajes de programación—JavaScript, Python, Java, PHP, Ruby, Go y más—así como editores de texto como VS Code, Sublime Text y herramientas de línea de comandos como grep y sed.
En su núcleo, los patrones de regex consisten en dos tipos de caracteres: caracteres literales que coinciden exactamente consigo mismos, y metacaracteres que tienen significados especiales y definen reglas de coincidencia.
El regex más simple es una cadena literal. El patrón hello coincide con el texto "hello" exactamente donde sea que aparezca. Pero el verdadero poder proviene de los metacaracteres que agregan flexibilidad—como coincidir cualquier dígito, repetir patrones o anclar a posiciones específicas.
Consejo profesional: Usa nuestro Probador de Regex para experimentar con patrones en tiempo real. Verás las coincidencias resaltadas instantáneamente mientras escribes, lo que hace mucho más fácil entender cómo funcionan los patrones.
Caracteres Literales vs Metacaracteres
La mayoría de los caracteres en un patrón de regex son literales—coinciden consigo mismos. El patrón cat coincide con las letras c, a y t en esa secuencia exacta. Sin embargo, ciertos caracteres tienen significados especiales:
. ^ $ * + ? { } [ ] \ | ( )son metacaracteres- Para coincidir estos literalmente, escápalos con una barra invertida:
\.coincide con un punto - Dentro de las clases de caracteres
[], la mayoría de los metacaracteres pierden su significado especial
Por ejemplo, example\.com coincide con "example.com" literalmente, mientras que example.com coincidiría con "exampleXcom" porque el punto sin escapar coincide con cualquier carácter.
Clases de Caracteres
Las clases de caracteres te permiten coincidir un carácter de un conjunto de posibilidades. Son la base de la coincidencia de patrones flexible y vienen en dos formas: clases abreviadas predefinidas y expresiones de corchetes personalizadas.
| Patrón | Coincide | Ejemplo |
|---|---|---|
. |
Cualquier carácter excepto nueva línea | h.t → hat, hot, hit, h@t |
\d |
Cualquier dígito [0-9] | \d{3} → 123, 456, 789 |
\D |
Cualquier no-dígito | \D+ → abc, xyz, @#$ |
\w |
Carácter de palabra [a-zA-Z0-9_] | \w+ → hello_world, var123 |
\W |
Carácter no-palabra | \W → @, #, espacio, puntuación |
\s |
Espacio en blanco (espacio, tabulación, nueva línea) | \s+ → cualquier secuencia de espacios en blanco |
\S |
No-espacio en blanco | \S+ → cualquier carácter visible |
[abc] |
Cualquiera de a, b o c | [aeiou] → cualquier vocal |
[^abc] |
No a, b o c | [^0-9] → cualquier no-dígito |
[a-z] |
Rango: a hasta z | [A-Za-z] → cualquier letra |
[a-z0-9] |
Múltiples rangos | [a-fA-F0-9] → dígitos hexadecimales |
Clases de Caracteres Personalizadas
Las expresiones de corchetes [] te permiten definir tus propios conjuntos de caracteres. Dentro de los corchetes, la mayoría de los metacaracteres pierden su significado especial—no necesitas escaparlos.
[aeiou]coincide con cualquier vocal individual[0-9]coincide con cualquier dígito (equivalente a\d)[a-zA-Z]coincide con cualquier letra, mayúscula o minúscula[^0-9]coincide con cualquier cosa excepto dígitos (el^niega la clase)[a-z-]coincide con letras minúsculas o un guion (guion al final es literal)
Consejo rápido: El orden de los caracteres en una clase de caracteres no importa. [abc] y [bca] son idénticos. La clase coincide si cualquiera de los caracteres está presente.
Ejemplos Prácticos
Aquí hay algunos usos del mundo real de las clases de caracteres:
[A-Z][a-z]+coincide con palabras capitalizadas como "Hello" o "World"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}coincide con direcciones IP (patrón básico)[a-fA-F0-9]{6}coincide con códigos de color hexadecimales como "FF5733"[^\s]+coincide con cualquier secuencia de no-espacios en blanco (una "palabra" en el sentido más amplio)
Cuantificadores y Repetición
Los cuantificadores especifican cuántas veces debe repetirse un patrón. Se colocan después del elemento que deseas repetir—un carácter, clase de caracteres o grupo.
| Cuantificador | Significado | Ejemplo |
|---|---|---|
* |
0 o más veces | ab*c → ac, abc, abbc, abbbc |
+ |
1 o más veces | ab+c → abc, abbc (no ac) |
? |
0 o 1 vez (opcional) | colou?r → color, colour |
{n} |
Exactamente n veces | \d{4} → 2026, 1999 |
{n,} |
n o más veces | \w{3,} → palabras con 3+ caracteres |
{n,m} |
Entre n y m veces | \d{2,4} → 12, 123, 1234 |
*? |
Coincidencia perezosa/mínima (0 o más) | <.*?> → solo primera etiqueta |
+? |
Coincidencia perezosa/mínima (1 o más) | ".+?" → primera cadena entre comillas |
?? |
Coincidencia perezosa/mínima (0 o 1) | \d?? → coincide con 0 dígitos si es posible |
Coincidencia Codiciosa vs Perezosa
Este es uno de los conceptos más importantes en regex. Por defecto, los cuantificadores son codiciosos—coinciden con tanto texto como sea posible mientras aún permiten que el patrón general coincida.
Considera la cadena HTML <b>bold</b> and <i>italic</i>:
<.*>(codicioso) coincide con toda la cadena desde el primer<hasta el último><.*?>(perezoso) coincide solo con<b>, luego</b>, luego<i>, luego</i>por separado
Agregar ? después de un cuantificador lo hace perezoso (también llamado no-codicioso o mínimo). Coincide con tan poco texto como sea posible mientras aún permite que el patrón tenga éxito.
Consejo profesional: Al extraer contenido entre delimitadores (comillas, etiquetas, corchetes), casi siempre usa cuantificadores perezosos. El patrón ".*?" extrae correctamente cadenas individuales entre comillas, mientras que ".*" coincidiría desde la primera comilla hasta la última comilla en todo el texto.
Patrones Comunes de Cuantificadores
Aquí hay patrones que usarás constantemente:
\d+coincide con uno o más dígitos (números como 42, 1000, 7)\w+coincide con uno o más caracteres de palabra (identificadores, nombres de variables)\s*coincide con espacios en blanco opcionales (cero o más espacios/tabulaciones).+?coincide con cualquier carácter perezosamente (contenido entre marcadores)[a-z]{2,}coincide con palabras con al menos 2 letras minúsculas\d{3}-\d{3}-\d{4}coincide con números de teléfono como 555-123-4567
Anclas y Límites
Las anclas no coinciden con caracteres—coinciden con posiciones en la cadena. Son esenciales para asegurar que los patrones coincidan en ubicaciones específicas en lugar de en cualquier lugar del texto.
| Ancla | Posición | Ejemplo |
|---|---|---|
^ |
Inicio de cadena (o línea con bandera m) | ^Hello → coincide con "Hello world" pero no con "Say Hello" |
$ |
Fin de cadena (o línea con bandera m) | end$ → coincide con "The end" pero no con "end of story" |
\b |
Límite de palabra | \bcat\b → coincide con "cat" pero no con "category" |
\B |
No es un límite de palabra | \Bcat\B → coincide con "concatenate" pero no con "cat" |
\A |
Inicio de cadena (nunca línea) | Como ^ pero ignora el modo multilínea |
\Z |
Fin de cadena (nunca línea) | Como $ pero ignora el modo multilínea |
Límites de Palabra Explicados
El límite de palabra \b es increíblemente útil pero a menudo mal entendido. Coincide con la posición entre un carácter de palabra (\w) y un carácter no-palabra (\W), o al inicio/fin de la cadena.
Considera el patrón \bcat\b aplicado a diferentes cadenas:
- "the cat sat" → coincide (cat está rodeado de espacios)
- "category" → no coincide (cat es seguido por el carácter de palabra 'e')
- "concatenate" → no coincide (cat está precedido y seguido por caracteres de palabra)
- "cat" → coincide (cat está al inicio y fin de la cadena)
- "cat!" → coincide (cat es seguido por puntuación, un carácter no-palabra)
Esto hace que \b sea perfecto para encontrar palabras completas sin coincidir accidentalmente con partes de palabras más grandes.
Anclas de Inicio y Fin
Las anclas ^ y $ son esenciales para la validación. Cuando quieres asegurar que una cadena completa coincida con un patrón (no solo que lo contenga), envuelve tu patrón con estas anclas.
^\d+$asegura que toda la cadena sean dígitos (valida entrada numérica)^[A-Z]asegura que la cadena comience con una letra mayúscula[.!?]$asegura que la cadena termine con puntuación^https?://asegura que una URL comience con http:// o https://
Consejo rápido: Al validar entrada de usuario (correo electrónico, teléfono, nombre de usuario), siempre usa ^ y $ para anclar tu patrón. Sin ellos, el patrón \d{3} aceptaría "abc123def" cuando probablemente quieres rechazar cualquier cosa que no sea exactamente 3 dígitos.
Grupos y Captura
Los paréntesis () sirven para dos propósitos en regex: agrupan partes de un patrón juntas, y capturan el texto coincidente para uso posterior. Aquí es donde regex se vuelve verdaderamente poderoso para extracción y transformación.
| Sintaxis | Propósito | Ejemplo |
|---|---|---|
(abc) |
Grupo de captura | (\d{3})-(\d{4}) captura código de área y número |
(?:abc) |
Grupo sin captura | (?:https?://)?example\.com agrupa sin capturar |
(a|b) |
Alternancia (O) | (cat|dog) coincide con "cat" o "dog" |
\1 |
Referencia inversa al grupo 1 | (\w+)\s+\1 coincide con palabras repetidas como "the the" |
(?<name>abc) |
Grupo de captura nombrado | (?<year>\d{4})-(?<month>\d{2}) para fechas |
Grupos de Captura
Cuando envuelves parte de un patrón en paréntesis, el motor de regex captura el texto coincidente. Luego puedes referenciar estas capturas en tu código o incluso dentro del regex mismo usando referencias inversas.
Por ejemplo, el patrón (\d{3})-(\d{3})-(\d{4}) aplicado a "555-123-4567" crea tres capturas:
- Grupo 1: "555"
- Grupo 2: "123"
- Grupo 3: "4567"
En la mayoría de los lenguajes de programación, puedes acceder a estas capturas a través de objetos de coincidencia o cadenas de reemplazo. Esto te permite reformatear datos fácilmente—convirtiendo "555-123-4567" en "(555) 123-4567" con un reemplazo como ($1) $2-$3.
Grupos Sin Captura
A veces necesitas agrupación para cuantificadores o alternancia pero no necesitas capturar el texto. Usa (?:...) para esto.