Guía práctica de expresiones regulares (Regex)

1. ¿Qué es una expresión regular?

Una expresión regular, también conocida como Regex (Regular Expression), es un patrón utilizado para buscar, identificar, validar o reemplazar partes de un texto.

Por ejemplo, una expresión regular puede servir para:

Comprobar si un correo tiene un formato válido.
Encontrar todos los números dentro de un texto.
Verificar si una cadena contiene únicamente letras.
Buscar fechas con un formato específico.
Reemplazar espacios repetidos o caracteres no deseados.
Extraer información de una cadena de texto.

Una expresión regular describe un patrón, no necesariamente un texto literal.

2. Caracteres básicos

Estos son los símbolos más utilizados al construir expresiones regulares.

Símbolo	Significado	Ejemplo
`.`	Cualquier carácter, excepto saltos de línea en el comportamiento habitual	`a.c` encuentra `abc` o `a7c`
`\d`	Un dígito del 0 al 9	`\d` encuentra `5`
`\D`	Un carácter que no sea un dígito	`\D` encuentra `a`
`\w`	Un carácter de palabra; normalmente letras ASCII, números y `_`	`\w+` encuentra `usuario_1`
`\W`	Un carácter que no sea de palabra	`\W` encuentra `!`
`\s`	Un espacio en blanco, tabulación o salto de línea	`\s+`
`\S`	Un carácter que no sea espacio en blanco	`\S+`
`^`	Inicio del texto	`^Hola`
`$`	Final del texto	`mundo$`
`\`	Escapa un símbolo especial o introduce una secuencia especial	`\.` busca un punto literal

Importante: . es un comodín, mientras que \. representa un punto literal. Del mismo modo, \d representa un dígito, mientras que d representa la letra d.

3. Cuantificadores

Los cuantificadores indican cuántas veces puede aparecer el elemento anterior.

Símbolo	Significado	Ejemplo
`*`	Cero o más repeticiones	`ab*` encuentra `a`, `ab` y `abbb`
`+`	Una o más repeticiones	`ab+` encuentra `ab` y `abbb`, pero no `a`
`?`	Cero o una repetición	`colou?r` encuentra `color` y `colour`
`{n}`	Exactamente `n` repeticiones	`\d{4}` encuentra cuatro dígitos consecutivos
`{n,}`	Al menos `n` repeticiones	`\d{2,}` encuentra dos o más dígitos consecutivos
`{n,m}`	Entre `n` y `m` repeticiones	`\d{2,4}` encuentra entre dos y cuatro dígitos

Por ejemplo:

regex

^\d{4}$

Acepta exactamente cuatro dígitos, como 2026, pero no 123 ni 12345.

Cuantificadores codiciosos y no codiciosos

Por defecto, cuantificadores como * y + intentan capturar la mayor cantidad de texto posible.

Agregar ? después de un cuantificador lo vuelve no codicioso (lazy).

regex

<.*>

En el texto Hola, puede coincidir con todo Hola.

regex

<.*?>

En ese mismo texto, encuentra cada etiqueta por separado:  y .

4. Conjuntos y rangos de caracteres

Los corchetes [] permiten definir qué caracteres se aceptan en una posición.

Patrón	Significado
`[abc]`	`a`, `b` o `c`
`[a-z]`	Una letra minúscula ASCII
`[A-Z]`	Una letra mayúscula ASCII
`[0-9]`	Un dígito
`[a-zA-Z]`	Una letra mayúscula o minúscula ASCII
`[a-zA-Z0-9]`	Una letra o un dígito
`[^0-9]`	Un carácter que no sea un dígito
`[aeiou]`	Una vocal minúscula

Ejemplo:

regex

^[A-Z][a-z]+$

Busca una cadena que comience con una mayúscula seguida de una o más minúsculas, como Carlos.

Este patrón no contempla automáticamente todas las letras acentuadas ni caracteres como ñ.

Atención: dentro de [], el símbolo ^ al principio niega el conjunto. Fuera de los corchetes, ^ representa el inicio del texto.

5. Alternativas y agrupaciones

Alternativas: `|`

Permite indicar que se acepta un patrón u otro.

regex

^(SI|NO)$

Acepta SI o NO, pero no SÍ, si ni quizás.

Grupos: `()`

Agrupan partes de una expresión y permiten aplicarles cuantificadores.

regex

(ab)+

Encuentra ab, abab y ababab.

Los grupos también pueden capturar el texto coincidente para utilizarlo posteriormente.

regex

(\d{4})-(\d{2})-(\d{2})

Para un texto como 2026-10-25, captura por separado:

2026: primer grupo.
10: segundo grupo.
25: tercer grupo.

Grupo no capturador: `(?:...)`

Agrupa una parte del patrón sin crear una captura.

regex

^(?:SI|NO)$

Es útil cuando se necesita agrupar alternativas, pero no se requiere recuperar el contenido del grupo.

6. Patrones comunes

Estos ejemplos son puntos de partida. Algunos validan únicamente el formato y no garantizan que el dato sea real o válido en todos los sistemas.

Objetivo	Expresión regular	Qué comprueba
Solo dígitos	`^\d+$`	Uno o más dígitos en toda la cadena
Solo letras ASCII	`^[a-zA-Z]+$`	Una o más letras sin espacios
Código de cuatro dígitos	`^\d{4}$`	Exactamente cuatro dígitos
Contraseña de al menos ocho caracteres	`^.{8,}$`	Longitud mínima de ocho caracteres, excepto saltos de línea en el modo habitual
Código postal de cinco dígitos	`^\d{5}$`	Cinco dígitos, si ese es el formato requerido
Fecha con formato `AAAA-MM-DD`	`^\d{4}-\d{2}-\d{2}$`	La estructura de la fecha, no su validez real
Texto que empieza por `Hola`	`^Hola`	El comienzo del texto
Texto que termina en `.pdf`	`\.pdf$`	El final del texto
Espacios repetidos	`\s{2,}`	Dos o más espacios en blanco consecutivos

Validar un correo electrónico

Un patrón sencillo para comprobar una estructura básica de correo es:

regex

^[^\s@]+@[^\s@]+\.[^\s@]+$

Este patrón comprueba que exista texto antes de @, texto después de @ y un punto en la parte posterior, sin espacios.

No garantiza que el correo exista, que su dominio reciba mensajes ni que cumpla todas las reglas posibles de las direcciones de correo electrónico.

Validar una contraseña

Para exigir al menos ocho caracteres, una mayúscula, una minúscula y un dígito:

regex

^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{8,}$

Este patrón utiliza lookaheads para comprobar condiciones sin consumir caracteres del texto.

(?=.*[A-Z]): exige al menos una mayúscula.
(?=.*[a-z]): exige al menos una minúscula.
(?=.*\d): exige al menos un dígito.
.{8,}: exige al menos ocho caracteres en el comportamiento habitual.

La expresión no exige símbolos especiales y no sustituye las buenas prácticas de almacenamiento y seguridad de contraseñas.

7. Lookahead y lookbehind

Son mecanismos para comprobar condiciones alrededor de una posición sin incluir esos caracteres dentro de la coincidencia principal.

Sintaxis	Significado
`(?=...)`	Lookahead positivo: lo siguiente debe cumplir el patrón
`(?!...)`	Lookahead negativo: lo siguiente no debe cumplir el patrón
`(?<=...)`	Lookbehind positivo: lo anterior debe cumplir el patrón
`(?<!...)`	Lookbehind negativo: lo anterior no debe cumplir el patrón

Ejemplo:

regex

\d+(?=€)

En el texto 25€ y 40$, encuentra 25 porque está seguido de €, pero no incluye el símbolo en la coincidencia.

La compatibilidad de los lookbehind y de otras funciones avanzadas depende del motor de expresiones regulares.

8. Cómo utilizar Regex en JavaScript

JavaScript permite crear expresiones regulares con literales /patrón/flags o con el constructor RegExp.

Crear una expresión regular

javascript

const patron = /^\d+$/;

console.log(patron.test("12345")); // true
console.log(patron.test("12a45")); // false

El método test() devuelve true si encuentra una coincidencia y false en caso contrario.

Buscar coincidencias

javascript

const texto = "Pedido 123, pedido 456";
const coincidencias = texto.match(/\d+/g);

console.log(coincidencias); // ["123", "456"]

Reemplazar texto

javascript

const texto = "Hola     mundo";
const resultado = texto.replace(/\s+/g, " ");

console.log(resultado); // "Hola mundo"

Extraer grupos

javascript

const fecha = "2026-10-25";
const resultado = fecha.match(/^(\d{4})-(\d{2})-(\d{2})$/);

if (resultado) {
  const anio = resultado[1];
  const mes = resultado[2];
  const dia = resultado[3];

  console.log({ anio, mes, dia });
}

El elemento resultado[0] contiene la coincidencia completa; los índices siguientes contienen los grupos capturados.

9. Flags o modificadores

Los flags cambian la forma en que se aplica una expresión regular.

Flag	Nombre	Función
`g`	Global	Busca todas las coincidencias, en lugar de detenerse en la primera
`i`	Insensitive	Ignora diferencias entre mayúsculas y minúsculas
`m`	Multiline	Hace que `^` y `$` puedan coincidir con los límites de cada línea
`s`	DotAll	Permite que `.` coincida también con saltos de línea
`u`	Unicode	Activa el modo Unicode
`y`	Sticky	Busca una coincidencia exactamente desde la posición indicada por `lastIndex`

Ejemplo:

javascript

const texto = "Hola hola HOLA";
const coincidencias = texto.match(/hola/gi);

console.log(coincidencias); // ["Hola", "hola", "HOLA"]

Precaución: las expresiones con g o y pueden modificar su propiedad lastIndex al usar métodos como test(). Si se reutilizan, esto puede producir resultados inesperados.

10. Cómo construir una Regex paso a paso

Si necesitas validar un código de producto que debe tener dos letras mayúsculas seguidas de cuatro dígitos:

Paso 1. Identificar la estructura:

Dos letras mayúsculas.
Cuatro dígitos.
Ningún carácter adicional.

Paso 2. Crear el patrón de las letras:

regex

[A-Z]{2}

Paso 3. Crear el patrón de los dígitos:

regex

\d{4}

Paso 4. Unir ambos patrones:

regex

[A-Z]{2}\d{4}

Paso 5. Exigir que toda la cadena cumpla el formato:

regex

^[A-Z]{2}\d{4}$

Resultados:

Entrada	¿Coincide?
`AB1234`	Sí
`XY0001`	Sí
`A12345`	No
`ab1234`	No
`AB123`	No
`AB12345`	No
`AB1234XYZ`	No

Los símbolos ^ y $ son importantes porque impiden que una parte válida dentro de una cadena más larga se considere suficiente.

11. Errores comunes

Olvidar ^ y $: el patrón puede encontrar una parte válida dentro de una cadena que contiene otros caracteres.
Confundir . con \.: el primero es un comodín; el segundo busca un punto literal.
Usar * cuando se necesita +: * permite cero repeticiones, mientras que + exige al menos una.
Asumir que una fecha con formato válido es real: 2026-99-45 cumple ^\d{4}-\d{2}-\d{2}$, pero no es una fecha válida.
Usar una Regex demasiado compleja: a veces resulta más claro validar el formato con Regex y comprobar las reglas adicionales mediante código.
Suponer que todos los motores son iguales: JavaScript, Python, .NET y otros lenguajes tienen diferencias de sintaxis y compatibilidad.
Validar únicamente en el frontend: las validaciones importantes deben repetirse en el servidor, ya que el cliente puede manipularse.

12. Referencia rápida

Si necesitas…	Puedes empezar con…
Un dígito	`\d`
Una o más letras	`[a-zA-Z]+`
Una o más cifras	`\d+`
Exactamente cinco cifras	`^\d{5}$`
Una palabra completa	`\bpalabra\b`
Buscar sin distinguir mayúsculas	`/patron/i`
Buscar todas las coincidencias	`/patron/g`
Reemplazar espacios repetidos	`\s+`
Comprobar un prefijo	`^texto`
Comprobar un sufijo	`texto$`
Capturar una parte	`(patrón)`
Aceptar una alternativa u otra	`(opcion1

13. Herramientas para practicar

Regex101: escribir patrones, probarlos con texto y consultar una explicación de cada componente. Permite seleccionar distintos motores.
RegExr: editor interactivo para experimentar con expresiones regulares.
MDN: Expresiones regulares: referencia de Regex en JavaScript.
MDN: Objeto RegExp: métodos, flags y comportamiento en JavaScript.

Regla práctica: antes de escribir una expresión regular, define qué entradas deben aceptarse y cuáles deben rechazarse. Después construye el patrón por partes y pruébalo con ejemplos válidos, inválidos y casos límite.

Guía práctica de expresiones regulares (Regex) ​

1. ¿Qué es una expresión regular? ​

2. Caracteres básicos ​

3. Cuantificadores ​

Cuantificadores codiciosos y no codiciosos ​

4. Conjuntos y rangos de caracteres ​

5. Alternativas y agrupaciones ​

Alternativas: | ​

Grupos: () ​

Grupo no capturador: (?:...) ​

6. Patrones comunes ​

Validar un correo electrónico ​

Validar una contraseña ​

7. Lookahead y lookbehind ​

8. Cómo utilizar Regex en JavaScript ​

Crear una expresión regular ​

Buscar coincidencias ​

Reemplazar texto ​

Extraer grupos ​

9. Flags o modificadores ​

10. Cómo construir una Regex paso a paso ​

11. Errores comunes ​

12. Referencia rápida ​

13. Herramientas para practicar ​

Guía práctica de expresiones regulares (Regex)

1. ¿Qué es una expresión regular?

2. Caracteres básicos

3. Cuantificadores

Cuantificadores codiciosos y no codiciosos

4. Conjuntos y rangos de caracteres

5. Alternativas y agrupaciones

Alternativas: `|`

Grupos: `()`

Grupo no capturador: `(?:...)`

6. Patrones comunes

Validar un correo electrónico

Validar una contraseña

7. Lookahead y lookbehind

8. Cómo utilizar Regex en JavaScript

Crear una expresión regular

Buscar coincidencias

Reemplazar texto

Extraer grupos

9. Flags o modificadores

10. Cómo construir una Regex paso a paso

11. Errores comunes

12. Referencia rápida

13. Herramientas para practicar