Skip to content

01 RegEx

Jump to bottom
Alan edited this page Jun 13, 2026 · 1 revision

Expresiones Regulares (RegEx)

Qué son las Expresiones Regulares

Las Expresiones Regulares, RegEx o Regular Expressions son un conjunto de caracteres especiales que definen un patrón de texto (similar a los Wildcards).

Las expresiones regulares nacieron de la teoría de la computación, como una manera de normalizar la definición de lenguajes regulares (lenguajes de tipo 3), convirtiéndose hoy en día en una herramienta muy poderosa en el mundo de la computación.

Important

En este documento no profundizaremos sobre los fundamentos de las expresiones regulares, sino nos enfocaremos a su uso dentro del mundo de la computación.

Importancia de las RegEx en Computación

Las RegEx son ampliamente utilizadas en el mundo de la computación, debido a que son una herramienta muy poderosa para definir patrones de texto. Son muy utilizadas en programación (e.g., Perl, Python, JS, PHP, Rust), herramientas de procesamiento de texto (e.g., grep, sed), editores de texto plano (e.g., Vim, Neovim), IDEs (e.g., VSCode, Zed), e inclusive herramientas de ofimática (e.g., Google Workspace (i.e., Google Docs, Google Sheets, Gmail, etc.), Microsoft Office, LibreOffice).

Estándares de RegEx

Si bien la sintaxis puede diferir entre herramientas, lenguajes y programas —algunos proporcionando un conjunto mayor de metacaracteres y funciones adicionales—, la mayoría comparte la misma base. Las implementaciones más comunes se rigen por los estándares IEEE POSIX:

  • BRE (Basic Regular Expressions)
  • ERE (Extended Regular Expressions)
  • SRE (Simple Regular Expressions, deprecado)

o por las sintaxis derivadas de Perl, ya que fue uno de los primeros lenguajes en popularizar las expresiones regulares ampliamente:

  • PCRE (Perl Compatible Regular Expressions)
  • PCRE2

Para qué Sirven las RegEx

Validación de Información

Si bien en un lenguaje de programación se puede desarrollar un algoritmo para validar si un string cumple con un patrón, estos requieren mayor tiempo y esfuerzo frente a las RegEx, las cuales, con un simple conjunto de caracteres, permiten validar si un string cumple dicho patrón.

Búsqueda de Archivos

Herramientas como find, fd y locate pueden utilizar expresiones regulares para buscar archivos que cumplan con cierto patrón.

Búsqueda, Extracción y Reemplazo de Texto

Herramientas como grep y rg permiten usar expresiones regulares para buscar y extraer patrones de texto dentro de archivos. Por ejemplo, una RegEx adecuada puede extraer todas las direcciones de correo electrónico de un documento rápidamente.

Editores de texto (e.g., Vim, Neovim) e IDEs (e.g., VSCode, Zed) incorporan funciones de búsqueda y reemplazo basadas en expresiones regulares, permitiendo reemplazos más inteligentes en base a patrones.

División de Strings

Las expresiones regulares también se pueden utilizar para dividir strings en partes según un patrón específico, lo cual es útil al analizar o procesar datos de texto de forma estructurada.

Sintaxis de las Expresiones Regulares

Metacaracteres

Los caracteres son simplemente caracteres que hacen referencia a sí mismos. En cambio, los metacaracteres son todos aquellos caracteres especiales que tienen un significado especial dentro de las expresiones regulares.

Los metacaracteres definidos por el estándar POSIX basic son: ^, $, ., [, ], (, ) y *. Mientras que el estándar POSIX extended añade: ?, + y |.

Important

Para que los metacaracteres puedan ser representados como caracteres literales, estos deben ser escapados (usualmente con \).

Los Metacaracteres ., | y \

Símbolo Descripción Estándar POSIX IEEE
. Un carácter cualquiera, excepto saltos de línea Básico
| Operador lógico OR Extendido
\ Indica que el siguiente carácter es literal en vez de especial Básico

Clases de Caracteres

Una clase de caracteres no es más que un conjunto de caracteres que indica que cualquier carácter perteneciente a dicha clase es válido para dicha posición en el patrón.

Para definir una clase podemos definir cada uno de los caracteres de la clase (e.g., [AEIOUaeiou], [1234567890]) o definir rangos de caracteres ASCII (separados por -) dentro de la clase, ya sea mediante el uso de caracteres (e.g., [a-z], [A-Z], [a-zA-Z], [0-9]) o mediante el uso de sus valores hexadecimales (e.g., [\x61-\x7A], [\x41-\x5A], [\x61-\x7A\x41-\x5A], [\x30-\x39]).

Important

Al definir clases de caracteres, solo tenemos que escapar los siguientes caracteres si queremos usarlos como caracteres literales:

  • Un ^ inicial
  • Un - no inicial ni final
  • Un ] no inicial
  • Un \

Clases de Caracteres Predefinidas

Descripción POSIX Perl/Tcl Vim Java ASCII
Caracteres ASCII \p{ASCII} [\x00-\x7F]
Caracteres alfanuméricos [:alnum:] \p{Alnum} [A-Za-z0-9]
Caracteres alfanuméricos más _ (word character) \w \w \w [A-Za-z0-9_]
Cualquier non-word character \W \W \W [^A-Za-z0-9_]
Caracteres alfabéticos [:alpha:] \a \p{Alpha} [A-Za-z]
Espacio y tab [:blank:] \s \p{Blank} [ \t]
Word boundaries \b < > \b (?<=\W)(?=\w) | (?<=\w)(?=\W)
Non-word boundaries \B \B \B (?<=\W)(?=\W) | (?<=\w)(?=\w)
Caracteres de control [:cntrl:] \p{Cntrl} [\x00-\x1F\x7F]
Dígitos [:digit:] \d \d \p{Digit}
\d		 [0-9]
Cualquier carácter que no sea un dígito \D \D \D [^0-9]
Caracteres imprimibles [:graph:] \p{Graph} [\x21-\x7E]
Minúsculas [:lower:] \l \p{Lower} [a-z]
Caracteres imprimibles y el espacio [:print:] \p \p{Print} [\x20-\x7E]
Caracteres de puntuación [:punct:] \p{Punct} [][!"#$%&'()*+,./:;<=>?@\^_`{|}~-]
Caracteres de espaciado [:space:] \s \s \p{Space}
\s		 [ \t\r\n\v\f]
Cualquier carácter que no sea de espaciado \S \S \S [^ \t\r\n\v\f]
Mayúsculas [:upper:] \u \p{Upper} [A-Z]
Dígitos hexadecimales [:xdigit:] \x \p{XDigit} [A-Fa-f0-9]

Note

  • Las clases de caracteres POSIX solo se pueden utilizar dentro de corchetes (e.g., 0x[A-Fa-f[:digit:]]).
  • Para negar una clase basta con añadir ^ al inicio de la clase, después del carácter [ (e.g., [^0-9], [^[:digit:]], [^\d]).
  • Una clase adicional fuera del estándar POSIX, reconocida por algunas herramientas, es [:word:], usualmente definida como [[:alnum:]_].

Ejemplo de Clases de Caracteres

Se busca una expresión regular que describa el siguiente patrón: strings que comienzan con dos dígitos, después un guión medio -, seguido de una o más letras del abecedario (excluyendo acentos).

[0-9][0-9]-[a-zA-Z]+             # Definiendo clases explícitas (ASCII)
[[:digit:]][[:digit:]]-[a-zA-Z]+ # Usando clases predefinidas (POSIX)
\d\d-[a-zA-Z]+                   # Usando clases predefinidas (Perl)
\d\d-\a+                         # Usando clases predefinidas (Vim)
\d\d-\p{Alpha}+                  # Usando clases predefinidas (Java)
\p{Digit}\p{Digit}-\p{Alpha}+    # Usando clases predefinidas (Java)

Cuantificadores o Contadores

Tip

Utiliza agrupación (...) para aplicar cuantificadores a un grupo.

Permiten definir la cantidad de veces que un carácter o grupo de caracteres debe aparecer en la cadena para que coincida con el patrón.

Cuantificador El elemento precedente aparece
* Cero o más veces
+ Una o más veces
? Cero o una vez (solo estándar POSIX extendido)
{n} Exactamente n veces
{min,max} Entre min y max veces
{min,} Como mínimo min veces
{,max} Hasta máximo max veces

Note

  • En teoría de la computación, el cuantificador * es conocido como cierre de Kleene o clausura de Kleene, mientras que el cuantificador + es conocido como clausura de Kleene positiva.
  • El cuantificador {,max} no forma parte del estándar POSIX (BRE ni ERE); es una extensión soportada por PCRE y GNU.

Ejemplos de Uso de Cuantificadores

\d{10}          # Números de diez dígitos
\w{5,}          # Palabras de 5 o más caracteres
0x[0-9A-Fa-f]+  # Números hexadecimales con el prefijo 0x
computadoras?   # Palabra "computadora" o "computadoras"
.*\.docx        # Strings que terminen con .docx (e.g., archivos .docx)
(jaja){2,}      # Dos o más repeticiones de "ja" (i.e., jaja, jajaja, ...)

Anclajes

Permiten especificar la posición en la cadena donde debe ocurrir una coincidencia.

  • ^: Inicio de la línea
  • $: Fin de la línea

Ejemplos de Uso de Anclajes

.*:$            # Strings que terminan con dos puntos

^\d+\. .*       # Strings que inician con uno o más dígitos, seguidos de un
                # punto y un espacio, y luego cero o más caracteres cualesquiera.
                # Representa un elemento de lista enumerada en formato MD
                # (e.g., 1. Conseguir los ingredientes)

# Definición de funciones de Python sin parámetros
^\s*def\s+[a-zA-Z_]\w*\(\s*\)\s*:$

^\w+( \w+)*\.$  # Strings que inicien con una palabra, seguida de cero o más
                # palabras adicionales separadas por espacio, y terminen con
                # un punto (e.g., Esto es un ejemplo.)

Ejemplos Interesantes de RegEx

Note

Las validaciones a continuación pueden no ser 100% correctas según los estándares definidos. Son ejemplos bastante completos definidos por mí.

Tip

Se recomienda intentar construir las expresiones regulares propias antes de ver los ejemplos.

Validación de Números Telefónicos

Números telefónicos de 10 dígitos con formato opcional 2-4-4 separado ya sea con espacios o guiones medios:

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

Fechas de Cumpleaños

Fechas de cumpleaños en formato DD/MM/AAAA para los años 1900 al 2025:

(0[1-9]|[12]\d|3[0-1])/(0[1-9]|1[0-2])/(19\d{2}|20([01]\d|2[0-5]))

Validación de Emails

^[\w-]([\w\.%+\-]*[\w])?@\w[\w-]*(\.\w{2,5}){1,2}$

Desglose:

^[\w-]([\w\.%+\-]*[\w])?   # Nombre de usuario: empieza y termina en \w o -,
                           # con caracteres opcionales en el medio
@                          # Arroba
\w[\w-]*                   # Nombre del dominio
(\.\w{2,5}){1,2}$          # Una o dos extensiones de 2 a 5 caracteres
                           # (e.g., .com, .gob.mx, .edu, .tech)

Versión RFC 5321 (Estándar Completo)

([!#-'*+/-9=?A-Z^-~-]+(\.[!#-'*+/-9=?A-Z^-~-]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([!#-'*+/-9=?A-Z^-~-]+(\.[!#-'*+/-9=?A-Z^-~-]+)*|\[[\t -Z^-~]*\])

Validación de URLs

(https?:\/{2})?(www\.)?\w[\w.\-]*\.\w{2,5}

Desglose:

(https?:\/{2})?  # Protocolo http:// o https:// (opcional)
(www\.)?         # www. (opcional)
\w[\w.\-]*       # Dominio y subdominios
\.\w{2,5}        # Extensión de 2 a 5 caracteres (e.g., .com, .gob, .edu, .tech)

Direcciones IP

Direcciones IPv4

Direcciones IPv4 en formato decimal con octetos (números de 0-255) separados por un punto .:

((25[0-5]|2[0-4]\d|[01]?\d{1,2})\.){3}(25[0-5]|2[0-4]\d|[01]?\d{1,2})

Direcciones IPv6

Direcciones IPv6 completas (sin abreviación) en formato hexadecimal con "hextetos" (números hexadecimales de 4 dígitos) separados por dos puntos ::

([0-9A-Fa-f]{4}:){7}[0-9A-Fa-f]{4}

CURP (Clave Única de Registro de Población)

Compuesta de 18 caracteres:

[A-Z][AEIOU][A-Z]{2}\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[0-1])[HMX](AS|BC|BS|CC|CL|CM|CS|CH|DF|DG|GT|GR|HG|JC|MC|MN|MS|NT|NL|OC|PL|QT|QR|SP|SL|SR|TC|TS|TL|VZ|YN|ZS|NE)[B-DF-HJ-NP-TV-Z]{3}[A-Z\d]\d

RFC (Registro Federal de Contribuyentes)

RFC para Personas Físicas

El RFC para personas físicas se compone de:

  • Clave de nombre de 4 letras
  • Fecha de nacimiento (AAMMDD)
  • Homoclave de 3 caracteres
[A-Z][AEIOU][A-Z]{2}\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[0-1])[A-Za-z0-9]{3}

RFC para Personas Morales

El RFC para personas morales se compone de:

  • Clave de nombre de 3 letras
  • Fecha de constitución (AAMMDD)
  • Homoclave de 3 caracteres
[A-Z]{3}\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[0-1])[A-Za-z0-9]{3}

Recursos Recomendados

Documentación General de RegEx

Documentación Específica de RegEx

Validadores de RegEx

Referencias

Introducción a los Sistemas Operativos

Introducción a Linux

Licencias de Software

Archivos y Directorios

Introducción a la CLI

Manipulación de Archivos y Directorios

Documentación y Exploración de Comandos

Redirección

Búsqueda de Archivos y Texto

Editores de Texto de Terminal

Gestión de Usuarios y Grupos

Propiedad y Permisos

Herramientas Esenciales

Hardware

Apéndice

Clone this wiki locally