Expresiones regulares explicadas: patrones, grupos y ejemplos reales
Las regex parecen ruido de teclado — \d{3}-\d{4} —, pero son un pequeño lenguaje para describir texto. Aprende los bloques básicos, cómo compara realmente el motor y los patrones que vale la pena memorizar.
Qué aprenderás
- Leer una regex en voz alta y decir qué coincide
- Usar clases de caracteres, cuantificadores, anclas y grupos con confianza
- Saber cuándo muerde la coincidencia codiciosa, y cómo la arregla la coincidencia perezosa
- Escribir patrones para correos, fechas, números de teléfono y líneas de registro
- Reconocer los patrones que congelan un programa (backtracking catastrófico)
- Qué es una expresión regular
- Los bloques básicos
- Cómo compara realmente el motor: codicioso, perezoso y backtracking
- Patrones que vale la pena memorizar
- Flags: los interruptores que lo cambian todo
- Errores comunes
- Pruébalo: probador de regex
- Preguntas frecuentes
Qué es una expresión regular
A expresión regular (regex) es un patrón que describe un conjunto de cadenas. En lugar de escribir código que diga «comprueba cada carácter uno por uno», escribes una descripción compacta — \d{3}-\d{4} — y preguntas: ¿contiene este texto algo con esa forma?
Las regex viven en todas partes: buscar en un editor, validar un formulario, renombrar mil archivos, analizar un registro, resaltar coincidencias en una página. No son un lenguaje de programación propio, pero casi todos los lenguajes incorporan la misma sintaxis básica: apréndela una vez y te seguirá de JavaScript a Python y a la línea de comandos.
El problema es la legibilidad. La regex es famosa por ser de solo escritura: un patrón que escribiste el mes pasado puede parecer ruido hoy. La solución no es evitar la regex, sino construir patrones a partir de piezas pequeñas con nombre y probarlos, que es exactamente para lo que sirven esta guía y el probador que la acompaña.
Los bloques básicos
Casi todos los patrones se ensamblan a partir de estas piezas:
| Pieza | Significado | Ejemplo |
|---|---|---|
abc | Caracteres literales | coincide con abc exactamente |
. | Cualquier carácter (excepto salto de línea) | a.c coincide con abc, a-c |
\d \w \s | Dígito, carácter de palabra, espacio en blanco | \d coincide con 7 |
\D \W \S | Los opuestos (no un dígito, etc.) | \D coincide con a |
[abc] [a-z] [^0-9] | Clase de caracteres / clase negada | [aeiou] coincide con una vocal |
* + ? {n} {n,m} | Cuantificadores: 0+, 1+, 0/1, exactamente n, de n a m | \d{3} coincide con tres dígitos |
^ $ \b | Anclas: inicio, fin, límite de palabra | ^cat coincide solo al principio |
( ) (?: ) (?<name> ) | Grupo de captura, grupo sin captura, grupo con nombre | (\d+)-(\d+) captura dos números |
| | Alternancia (o) | cat|dog coincide con cualquiera de las dos |
\ | Escape: convierte un carácter especial en literal | \. coincide con un punto real |
Dos piezas causan la mayoría de los errores de principiante. Primero, . es especial: para buscar un punto literal en example.com debes escribir example\.com, o tu patrón también coincide con exampleXcom. Segundo, una clase de caracteres [.] no necesita escapes dentro de los corchetes: la mayoría de los caracteres pierden su magia ahí.
Cómo compara realmente el motor: codicioso, perezoso y backtracking
Un motor de regex lee tu patrón de izquierda a derecha e intenta coincidir, paso a paso. Cuando se encuentra con un cuantificador como .* este es codicioso por defecto: toma todo lo posible y luego va devolviendo caracteres de uno en uno hasta que encaja el resto del patrón. Ese proceso — intentar, fallar, devolver — se llama backtracking.
<p>first</p> <p>second</p> Pattern: <p>.*</p> → matches the WHOLE line (greedy) Pattern: <p>.*?</p> → matches <p>first</p> only (lazy)
Añadir ? después de un cuantificador lo vuelve perezoso: coincide lo menos posible. Lo codicioso es lo adecuado por defecto para «todo hasta el final»; lo perezoso es lo adecuado por defecto para «la siguiente etiqueta de cierre». Elegir mal es la razón más común por la que un patrón coincide mucho más (o mucho menos) de lo esperado.
(a+)+$ con una cadena larga de aes puede tardar prácticamente una eternidad: el motor prueba un número exponencial de formas de repartir los mismos caracteres. La regla: no anides nunca cuantificadores sobre opciones que se solapan, y prefiere un patrón específico ([^<]*) antes que uno vago (.*) dentro de un grupo repetido.Patrones que vale la pena memorizar
Guárdalos como punto de partida: prueba cada uno con tus datos reales antes de publicarlo:
# A simple email check (good enough for a form hint, not proof)
\b[\w.+-]+@[\w-]+\.[\w.]+\b
# Date: YYYY-MM-DD
^\d{4}-\d{2}-\d{2}$
# North American phone number, flexible separators
^\+?1?[-. ]?\(?\d{3}\)?[-. ]?\d{3}[-. ]?\d{4}$
# A word, with its position: capture the username from user@host
^(?<user>[\w.+-]+)@(?<host>[\w-]+\.[\w.]+)$
# Lines starting with ERROR in a log file (multiline flag m)
^ERROR: (.*)$Ten en cuenta que el patrón de correo es deliberadamente imperfecto: el estándar real para las direcciones de correo es tan complicado que una sola regex para «todos los correos válidos» tiene cientos de caracteres y sigue siendo incorrecta. El enfoque profesional es una simple comprobación de cordura más enviar realmente un correo de confirmación.
Flags: los interruptores que lo cambian todo
| Flag | Efecto |
|---|---|
g | Global: encuentra todas las coincidencias, no solo la primera |
i | Sin distinción entre mayúsculas y minúsculas — cat coincide con CAT |
m | Multilínea — ^ y $ coinciden con los inicios y finales de línea |
s | Dot-all — . también coincide con los saltos de línea |
u | Modo Unicode: manejo correcto de emoji y caracteres astrales |
La m La flag es la que más sorprende: sin ella, ^ERROR solo coincide al principio de todo el texto, no al principio de cada línea de un archivo de registro. Si tu patrón funciona en una línea pero no en un archivo, la m que falta es lo primero que hay que comprobar.
Errores comunes
- Usar
.*cuando quieres decir[^<]*o\S+. Los patrones vagos hacen backtracking y coinciden de más; los específicos son más rápidos y seguros. - Olvidar escapar
.,(,+en el texto literal.file.txtcomo patrón también coincide confileatxt. - Validar el correo con una sola regex gigante. Usa una comprobación sencilla y luego verifica enviando un correo.
- Analizar HTML o estructuras anidadas con regex. HTML no es un lenguaje regular: un analizador es la herramienta adecuada, y la regex se romperá con la primera etiqueta anidada.
- Cuantificadores anidados como
(a+)+o(.*)*. El bloqueo clásico. Reescribe con un solo cuantificador sobre una clase precisa. - Olvidar la
gflag. En muchas herramientas solo se devuelve la primera coincidencia, a menos que pidas todas.
Pruébalo: probador de regex
Cada patrón de esta guía se puede probar: pégalo en el probador de regex, escribe tu propio texto debajo y mira cómo se resaltan las coincidencias en vivo, con cada grupo de captura listado.
Sigue aprendiendo
Preguntas frecuentes
¿Qué variante de regex debo aprender?
La sintaxis básica es la misma en casi todas partes. JavaScript, Python, Java y Go coinciden en lo básico de la tabla anterior; difieren en los bordes (lookbehind, sintaxis de grupos con nombre, manejo de Unicode). Aprende lo básico y luego consulta la documentación de tu lenguaje para los bordes, y prueba en el probador de regex, que usa el motor JavaScript de tu navegador.
¿Qué es un grupo de captura y para qué lo usaría?
Los paréntesis hacen dos trabajos: agrupan parte de un patrón y, por defecto, también capturan lo que coincidieron, así que puedes reutilizarlo; por ejemplo, convertir 2026-11-21 en 21/11/2026 con un reemplazo como $3/$2/$1. Usa (?:…) cuando solo necesites agrupar y no quieras la captura.
¿Por qué mi regex es lenta o congela la página?
Casi siempre backtracking catastrófico: cuantificadores anidados sobre opciones que se solapan, con una entrada larga. Simplifica el patrón, sustituye .* por una clase negada o añade un ancla para que el motor falle rápido en lugar de probar cada reparto.
¿Cuál es la diferencia entre * y +?
* significa «cero o más»: la pieza puede no aparecer en absoluto. + significa «uno o más»: debe aparecer al menos una vez. \d* coincide con una cadena vacía; \d+ no. Esa diferencia de un carácter es una fuente frecuente de patrones que coinciden cuando no deberían.
¿Puede una regex validar una dirección de correo correctamente?
Ninguna regex práctica cubre todo el estándar: las cadenas entre comillas, los comentarios y los dominios inusuales la hacen absurdamente larga. Un patrón corto más un correo de confirmación es la respuesta profesional; la regex caza erratas, no es una prueba.