Expresiones regulares

En este artículo vamos a explicar las expresiones regulares que debes saber, aplicables a diferentes lenguajes y ámbitos de programación. Como programador, las expresiones regulares son muy comunes y utilizadas para optimizar y dar más rendimiento a partes del código.

Como definición básica, una expresión regular es un patrón o trocito de texto que utilizamos para buscar coincidéncias en otros textos. A partir de aquí, hay muchísimos ámbitos dentro de la programación donde puede ser útil su utilización.

En este sentido, tal vez te interese mi libro Guía básica .htaccess donde explico las expresiones regulares que debes saber si utilizas el servidores Apache.

También te puede interesar el artículo de introducción al archivo .htaccess o el artículo sobre cómo hacer URL amigables con .htacces y PHP.

Expresiones regulares que debes saber

Hay varias expresiones regulares que todo programador debe saber porque son muy utilizadas en programación. Aunque puede haber ciertas variaciones entre lenguajes de programación, en general, las expresiones regulares están diseñadas para ser utilizadas en todos los lenguajes.

En este artículo vamos a explicar 10 expresiones regulares básicas que todo programador debe saber aplicadas a diferentes lenguajes de programación. En cada expresión regular se explica con detalle su objetivo, funcionamiento y el desglose de los patrones de búsqueda.

Expresión regular para extraer URLs de imágenes

Lenguaje: JavaScript
Expresión Regular: /<img[^>]+src="([^">]+)"/ig
Propósito: Extraer las URLs de las imágenes en las etiquetas <img> de un documento HTML.
Funcionamiento: Busca la etiqueta <img> y el atributo src, capturando la URL de la imagen entre comillas.

   const html = '<img src="imagen1.jpg"><img src="imagen2.jpg">';
   const matches = html.match(/<img[^>]+src="([^">]+)"/ig);
   console.log(matches);

Este código JavaScript se encarga de buscar y extraer las URLs de las imágenes en una cadena de texto HTML. El funcionamiento del código es el siguiente:

const html = '<img src="imagen1.jpg"><img src="imagen2.jpg">';
Define una cadena de texto html que contiene dos etiquetas <img> con atributos src que apuntan a imágenes. Es importante notar que aquí estamos asumiendo que estas etiquetas están formateadas correctamente y no contienen ningún error de sintaxis.
const matches = html.match(/<img[^>]+src="([^">]+)"/ig);
Utiliza el método match() de JavaScript junto con una expresión regular para buscar coincidencias en la cadena html. El desglose de la expresión regular es el siguiente:
- / Delimitador de expresiones regulares.
- <img Coincide con el texto <img.
- [^>]+ Coincide con uno o más caracteres que no sean el carácter > (caracteres que forman el atributo src).
- src=" Coincide con el texto src=".
- ([^">]+) Grupo de captura que coincide con cualquier caracter excepto " o >, lo que captura la URL dentro del atributo src.
- " Coincide con el carácter " de cierre.
- ig Flags de la expresión regular: i hace que la coincidencia sea insensible a mayúsculas y minúsculas, y g significa que buscará todas las coincidencias en lugar de detenerse después de la primera.
console.log(matches);
Imprime la lista de coincidencias encontradas en la consola. Estas coincidencias serán las URLs de las imágenes extraídas de las etiquetas <img> en la cadena html.

En resumen, el código toma una cadena de texto que contiene etiquetas <img> y utiliza una expresión regular para buscar y extraer las URLs de las imágenes a partir de los atributos src de estas etiquetas. Luego, imprime estas URLs en la consola. El resultado impreso en la consola sería un array que contiene las URLs de las imágenes encontradas en la cadena html.

Expresiones regulares para filtrar fechas YYYY-MM-DD

Lenguaje: Python
Expresión Regular: \d{4}-\d{2}-\d{2}
Propósito: Identificar y filtrar fechas en el formato YYYY-MM-DD.
Funcionamiento: Busca secuencias de cuatro dígitos, seguidos de dos dígitos, luego otros dos dígitos.

   import re
   text = "Fecha: 2023-06-10, otra fecha: 2023-06-15"
   dates = re.findall(r'\d{4}-\d{2}-\d{2}', text)
   print(dates)

Este código en Python se encarga de buscar y extraer fechas en formato YYYY-MM-DD de una cadena de texto. No comprueba que la fecha sea correcta, sólo extrae el patrón numérico. Este es el desglose del funcionamiento del código:

import re
Importa el módulo re, que proporciona funcionalidades para trabajar con expresiones regulares en Python.
text = "Fecha: 2023-06-10, otra fecha: 2023-06-15"
Define una cadena de texto llamada text que contiene dos fechas en el formato YYYY-MM-DD y otras descripciones de texto.
dates = re.findall(r'\d{4}-\d{2}-\d{2}', text)
Utiliza la función findall() del módulo re para buscar todas las coincidencias de fechas en la cadena de texto.
- \d{4}-\d{2}-\d{2} Es la expresión regular que se utiliza para buscar fechas en el formato YYYY-MM-DD.
  - \d{4} Coincide con cuatro dígitos (año).
  - - Coincide con un guión literal.
  - \d{2} Coincide con dos dígitos (mes).
  - - Coincide con un guión literal.
  - \d{2} Coincide con dos dígitos (día).
- La expresión regular captura la fecha completa en el formato deseado.
print(dates)
Imprime la lista de fechas encontradas en la cadena de texto. Esta lista contendrá todas las fechas que coinciden con el patrón en el formato YYYY-MM-DD.

En resumen, el código toma una cadena de texto que contiene fechas en el formato YYYY-MM-DD y utiliza una expresión regular para buscar y extraer todas las fechas en ese formato. Luego, imprime estas fechas en la consola. El resultado impreso será una lista que contiene las fechas encontradas en la cadena text.

Expresión regular para validar emails

Lenguaje: PHP
Expresión Regular: ^[\w\.-]+@[\w\.-]+\.\w+$
Propósito: Validar si una cadena es una dirección de correo electrónico válida.
Funcionamiento: Verifica que la cadena comience con caracteres alfanuméricos y permita puntos y guiones en el nombre de usuario, seguido de una ‘@’, luego más caracteres alfanuméricos y un punto, y finalmente caracteres alfanuméricos en el dominio.

   $email = "usuario@example.com";
   if (preg_match('/^[\w\.-]+@[\w\.-]+\.\w+$/', $email)) {
       echo "Email válido";
   } else {
       echo "Email inválido";
   }

Este código en PHP se encarga de validar si una dirección de correo electrónico es válida utilizando una expresión regular. A continuación, se describe el funcionamiento del código:

$email = "usuario@example.com";
Define una variable llamada $email que contiene una dirección de correo electrónico que se va a validar.
if (preg_match('/^[\w\.-]+@[\w\.-]+\.\w+$/', $email)) {
Utiliza la función preg_match() de PHP para comprobar si la dirección de correo electrónico cumple con el patrón definido por la expresión regular.
- /^[\w\.-]+@[\w\.-]+\.\w+$/ Es la expresión regular que se utiliza para validar direcciones de correo electrónico.
- ^ y $ Delimitan el inicio y el final de la cadena, lo que asegura que toda la cadena cumpla con el patrón.
- [\w\.-]+@[\w\.-]+\.\w+ Define el patrón de la dirección de correo electrónico:
  - [\w\.-]+ Coincide con uno o más caracteres alfanuméricos, guiones bajos, puntos y guiones.
  - @ Coincide con el símbolo @.
  - [\w\.-]+ Coincide con uno o más caracteres alfanuméricos, guiones bajos, puntos y guiones (dominio).
  - \. Coincide con un punto literal.
  - \w+ Coincide con uno o más caracteres alfanuméricos (dominio de nivel superior).
- En resumen, la expresión regular valida si la dirección de correo electrónico tiene un formato básico válido.
echo "Email válido";
Si la función preg_match() devuelve true, significa que la dirección de correo electrónico cumple con el patrón de la expresión regular, por lo que se imprime «Email válido».
} else {
En caso contrario, si la dirección de correo electrónico no cumple con el patrón, el código ejecuta el bloque else.
echo "Email inválido";
En el bloque else, se imprime «Email inválido» para indicar que la dirección de correo electrónico no es válida según el patrón.

En resumen, el código verifica si una dirección de correo electrónico tiene un formato válido utilizando una expresión regular. Si cumple con el patrón, se imprime «Email válido»; de lo contrario, se imprime «Email inválido».

Expresiones regulares para validar números de teléfono

Lenguaje: Java
Expresión Regular: ^\+\d{1,3}-\d{3,}-\d{4,}$
Propósito: Validar si un número de teléfono está en formato internacional, por ejemplo: +123-456-7890.
Funcionamiento: Verifica que la cadena comience con un ‘+’ seguido de uno a tres dígitos, un guión, luego al menos tres dígitos, otro guión, y finalmente al menos cuatro dígitos.

   String phoneNumber = "+123-456-7890";
   if (phoneNumber.matches("^\\+\\d{1,3}-\\d{3,}-\\d{4,}$")) {
       System.out.println("Número válido");
   } else {
       System.out.println("Número inválido");
   }

Este código en Java se encarga de validar si un número de teléfono en formato internacional tiene un patrón específico. Este es el funcionamiento del código:

String phoneNumber = "+123-456-7890";
Define una variable de tipo String llamada phoneNumber que contiene un número de teléfono en formato internacional.
if (phoneNumber.matches("^\\+\\d{1,3}-\\d{3,}-\\d{4,}$")) {
Utiliza el método matches() de la clase String para verificar si el número de teléfono cumple con el patrón definido por la expresión regular.
- "^\\+\\d{1,3}-\\d{3,}-\\d{4,}$" Es la expresión regular que se utiliza para validar el número de teléfono.
  - ^ y $ Delimitan el inicio y el final de la cadena, asegurando que toda la cadena cumpla con el patrón.
  - \\+ Coincide con el símbolo «+» literal.
  - \\d{1,3} Coincide con uno a tres dígitos (código de país).
  - - Coincide con un guión literal.
  - \\d{3,} Coincide con tres o más dígitos (prefijo regional).
  - - Coincide con un guión literal.
  - \\d{4,} Coincide con cuatro o más dígitos (número local).
- En resumen, la expresión regular valida números de teléfono en formato internacional con un rango específico de dígitos.
System.out.println("Número válido");
Si el método matches() devuelve true, significa que el número de teléfono cumple con el patrón de la expresión regular, por lo que se imprime «Número válido».
} else {
En caso contrario, si el número de teléfono no cumple con el patrón, el código ejecuta el bloque else.
System.out.println("Número inválido");
En el bloque else, se imprime «Número inválido» para indicar que el número de teléfono no es válido según el patrón.

En resumen, el código verifica si un número de teléfono en formato internacional cumple con un patrón específico utilizando una expresión regular. Si cumple con el patrón, se imprime «Número válido»; de lo contrario, se imprime «Número inválido».

Expresión regular para validar códigos postales (EEUU)

Lenguaje: C#
Expresión Regular: ^\d{5}(-\d{4})?$
Propósito: Validar códigos postales en EE. UU. en formato básico (XXXXX) o extendido (XXXXX-XXXX).
Funcionamiento: Verifica que la cadena tenga cinco dígitos, seguidos opcionalmente por un guión y cuatro dígitos adicionales.

   using System;
   using System.Text.RegularExpressions;
   string postalCode = "12345-6789";
   if (Regex.IsMatch(postalCode, @"^\d{5}(-\d{4})?$")) {
       Console.WriteLine("Código postal válido");
   } else {
       Console.WriteLine("Código postal inválido");
   }

Este código en C# se encarga de validar si un código postal cumple con un patrón específico. Este es el desglose del funcionamiento del código:

using System;
Importa el espacio de nombres System, que proporciona tipos fundamentales y funcionalidades básicas del sistema.
using System.Text.RegularExpressions;
Importa el espacio de nombres System.Text.RegularExpressions, que contiene las clases y métodos relacionados con las expresiones regulares.
string postalCode = "12345-6789";
Define una variable de tipo string llamada postalCode que contiene un código postal.
if (Regex.IsMatch(postalCode, @"^\d{5}(-\d{4})?$")) {
Utiliza el método IsMatch() de la clase Regex para verificar si el código postal cumple con el patrón definido por la expresión regular.
- @"^\d{5}(-\d{4})?$" Es la expresión regular que se utiliza para validar el código postal.
  - ^ y $ Delimitan el inicio y el final de la cadena, asegurando que toda la cadena cumpla con el patrón.
  - \d{5} Coincide con exactamente cinco dígitos (código postal básico).
  - (-\d{4})? Es un grupo opcional que coincide con un guión seguido de exactamente cuatro dígitos (extensión del código postal).
  - ? Hace que el grupo anterior sea opcional.
- En resumen, la expresión regular valida códigos postales en el formato básico de cinco dígitos, con una extensión opcional separada por un guión.
Console.WriteLine("Código postal válido");
Si el método IsMatch() devuelve true, significa que el código postal cumple con el patrón de la expresión regular, por lo que se imprime «Código postal válido».
} else {
En caso contrario, si el código postal no cumple con el patrón, el código ejecuta el bloque else.
Console.WriteLine("Código postal inválido");
En el bloque else, se imprime «Código postal inválido» para indicar que el código postal no es válido según el patrón.

En resumen, el código verifica si un código postal cumple con un patrón específico utilizando una expresión regular. Si cumple con el patrón, se imprime «Código postal válido»; de lo contrario, se imprime «Código postal inválido».

Expresiones regulares para extraer etiquetas HTML

Lenguaje: JavaScript
Expresión Regular: /<[^>]+>/g
Propósito: Extraer todas las etiquetas HTML de una cadena.
Funcionamiento: Busca cualquier texto que comience con ‘<‘, seguido de cualquier contenido que no sea ‘>’, y termina con ‘>’, lo que captura todas las etiquetas HTML.

   const html = '<p>Texto <b>en</b> HTML</p>';
   const tags = html.match(/<[^>]+>/g);
   console.log(tags);

Este código JavaScript se encarga de extraer y mostrar todas las etiquetas HTML presentes en una cadena de texto. Este es el funcionamiento del código:

const html = '<p>Texto <b>en</b> HTML</p>';
Define una cadena de texto html que contiene contenido en formato HTML.
const tags = html.match(/<[^>]+>/g);
Utiliza el método match() de JavaScript junto con una expresión regular para buscar todas las coincidencias de etiquetas HTML en la cadena de texto.
- <[^>]+> Es la expresión regular que busca etiquetas HTML.
  - < Coincide con el símbolo < literal que inicia una etiqueta.
  - [^>]+ Coincide con uno o más caracteres que no sean el símbolo > (nombre de la etiqueta).
  - > Coincide con el símbolo > literal que cierra una etiqueta.
- /g Es la bandera global que indica que la búsqueda debe ser global, es decir, busca todas las coincidencias en la cadena en lugar de detenerse después de la primera.
console.log(tags);
Imprime la lista de etiquetas HTML encontradas en la consola. Esta lista contendrá todas las etiquetas presentes en la cadena html.

En este ejemplo, si ejecutas el código, el resultado podría ser algo como esto:

[ '<p>', '<b>', '</b>', '</p>' ]

El código busca en la cadena html todas las coincidencias que se ajustan al patrón en la expresión regular y devuelve una lista de etiquetas HTML encontradas. Ten en cuenta que esta extracción de etiquetas es bastante simple y no maneja casos especiales ni consideraciones avanzadas en el análisis de HTML.

Expresión regular para validar contraseñas fuertes

Lenguaje: Ruby
Expresión Regular: ^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$
Propósito: Validar si una contraseña contiene al menos una letra mayúscula, una minúscula, un número y un carácter especial, y tiene al menos 8 caracteres.
Funcionamiento: Utiliza ‘lookaheads’ para verificar cada requisito por separado y luego permite cualquier combinación de esos caracteres en la longitud especificada.

   password = "Abcd@1234"
   if password.match(/^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/)
       puts "Contraseña fuerte"
   else
       puts "Contraseña débil"
   end

Este código en Ruby se encarga de verificar si una contraseña cumple con los criterios de fortaleza definidos, como tener al menos una letra mayúscula, una letra minúscula, un dígito y un carácter especial. A continuación, se describe el funcionamiento del código:

password = "Abcd@1234"
Define una variable password que contiene la contraseña que se va a verificar.
if password.match(/^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/)
Utiliza el método match() de Ruby junto con una expresión regular para verificar si la contraseña cumple con el patrón definido.
- /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/ Es la expresión regular que se utiliza para validar la contraseña.
  - ^ y $ Delimitan el inicio y el final de la cadena, asegurando que toda la cadena cumpla con el patrón.
  - (?=.*[A-Z]) Utiliza un «positive lookahead» para verificar si hay al menos una letra mayúscula en la contraseña.
  - (?=.*[a-z]) Utiliza un «positive lookahead» para verificar si hay al menos una letra minúscula en la contraseña.
  - (?=.*\d) Utiliza un «positive lookahead» para verificar si hay al menos un dígito en la contraseña.
  - (?=.*[@$!%*?&]) Utiliza un «positive lookahead» para verificar si hay al menos un carácter especial en la contraseña (los caracteres dentro de los corchetes representan los caracteres especiales permitidos).
  - [A-Za-z\d@$!%*?&]{8,} Coincide con ocho o más caracteres que son letras mayúsculas, letras minúsculas, dígitos o los caracteres especiales permitidos.
puts "Contraseña fuerte"
Si el método match() devuelve una coincidencia (la contraseña cumple con el patrón de la expresión regular), se imprime «Contraseña fuerte».
else
En caso contrario, si la contraseña no cumple con el patrón, el código ejecuta el bloque else.
puts "Contraseña débil"
En el bloque else, se imprime «Contraseña débil» para indicar que la contraseña no es lo suficientemente fuerte según los criterios definidos.

NOTA: El «positive lookahead» se explica más adelante.

En resumen, el código verifica si una contraseña cumple con los criterios de fortaleza definidos utilizando una expresión regular. Si cumple con el patrón, se imprime «Contraseña fuerte»; de lo contrario, se imprime «Contraseña débil».

Expresiones regulares para validar nombres alfanuméricos

Lenguaje: PHP
Expresión Regular: ^[a-zA-Z0-9_]{3,20}$
Propósito: Validar si un nombre de usuario contiene solo letras mayúsculas/minúsculas, dígitos o guiones bajos, y tiene entre 3 y 20 caracteres.
Funcionamiento: Verifica que la cadena contenga solo caracteres permitidos y tenga una longitud dentro del rango especificado.

   $username = "user_123";
   if (preg_match('/^[a-zA-Z0-9_]{3,20}$/', $username)) {
       echo "Nombre de usuario válido";
   } else {
       echo "Nombre de usuario inválido";
   }

Este código en PHP se encarga de validar si un nombre de usuario cumple con ciertos criterios utilizando una expresión regular. Este es el funcionamiento del código:

$username = "user_123";
Define una variable llamada $username que contiene el nombre de usuario que se va a validar.
if (preg_match('/^[a-zA-Z0-9_]{3,20}$/', $username)) {
Utiliza la función preg_match() de PHP junto con una expresión regular para verificar si el nombre de usuario cumple con el patrón definido.
- /^[a-zA-Z0-9_]{3,20}$/ Es la expresión regular que se utiliza para validar el nombre de usuario.
  - ^ y $ Delimitan el inicio y el final de la cadena, asegurando que toda la cadena cumpla con el patrón.
  - [a-zA-Z0-9_] Coincide con cualquier carácter alfanumérico o guión bajo.
  - {3,20} Indica que el nombre de usuario debe tener entre 3 y 20 caracteres de longitud.
- En resumen, la expresión regular valida nombres de usuario que contienen solo letras, dígitos y guiones bajos, y que tienen una longitud entre 3 y 20 caracteres.
echo "Nombre de usuario válido";
Si la función preg_match() devuelve true, significa que el nombre de usuario cumple con el patrón de la expresión regular, por lo que se imprime «Nombre de usuario válido».
} else {
En caso contrario, si el nombre de usuario no cumple con el patrón, el código ejecuta el bloque else.
echo "Nombre de usuario inválido";
En el bloque else, se imprime «Nombre de usuario inválido» para indicar que el nombre de usuario no es válido según el patrón.

En resumen, el código verifica si un nombre de usuario cumple con ciertos criterios utilizando una expresión regular. Si cumple con el patrón, se imprime «Nombre de usuario válido»; de lo contrario, se imprime «Nombre de usuario inválido».

Expresión regular para validar URLs

Lenguaje: Python
Expresión Regular: ^(http|https):\/\/[a-zA-Z0-9\-.]+\.[a-zA-Z]{2,}(\/\S*)?$
Propósito: Valida URLs que comienzan con «http://» o «https://» seguido de un dominio (que debe tener al menos dos letras alfabéticas), y opcionalmente una ruta (path).
Funcionamiento: Se utiliza el módulo re de Python para buscar y extraer URLs en una cadena de texto

   import re
   text = "Visita mi sitio en https://www.ejemplo.com"
   urls = re.findall(r'https?://[a-zA-Z0-9\-.]+\.[a-zA-Z]{2,}(/\S*)?', text)
   print(urls)

Este código en Python utiliza la biblioteca re para buscar y extraer URLs de una cadena de texto. A continuación, se describe cómo funciona el código:

import re
Importa el módulo re, que proporciona funcionalidades para trabajar con expresiones regulares en Python.
text = "Visita mi sitio en https://www.ejemplo.com"
Define una cadena de texto llamada text que contiene una frase que incluye una URL.
urls = re.findall(r'https?://[a-zA-Z0-9\-.]+\.[a-zA-Z]{2,}(/\S*)?', text)
Utiliza la función findall() del módulo re para buscar todas las coincidencias de URLs en la cadena de texto.
- 'https?://[a-zA-Z0-9\-.]+\.[a-zA-Z]{2,}(/\S*)?' Es la expresión regular que se utiliza para buscar URLs en el texto. Aquí está el desglose:
  - https?:// Coincide con «http://» o «https://».
  - [a-zA-Z0-9\-.]+ Coincide con uno o más caracteres alfanuméricos, guiones y puntos (dominio).
  - \. Coincide con un punto literal.
  - [a-zA-Z]{2,} Coincide con dos o más letras (extensión de dominio, como «com», «org»).
  - (/\S*)? Grupo opcional que coincide con una barra seguida de cero o más caracteres no espacios (ruta o path de la URL).
- re.findall() Devuelve una lista de todas las coincidencias encontradas en la cadena de texto.
print(urls)
Imprime la lista de URLs encontradas en la consola.

En este ejemplo, si ejecutas el código, el resultado podría ser algo como esto:

['https://www.ejemplo.com']

El código busca en la cadena text cualquier coincidencia que se ajuste al patrón en la expresión regular y devuelve la lista de URLs encontradas. En este caso, encontró una URL válida que comienza con «https://» y tiene el dominio «www.ejemplo.com».

Positive lookahead

Un «positive lookahead» (o búsqueda anticipada positiva) es un concepto utilizado en expresiones regulares para definir una condición que debe cumplirse más adelante en una cadena de texto, pero sin consumir los caracteres correspondientes en la coincidencia actual. En otras palabras, es una forma de verificar si algo sigue a cierta posición en la cadena sin realmente avanzar en la cadena.

El formato general de un positive lookahead en una expresión regular es (?(?=pattern)result), donde pattern es la condición que se busca y result es la parte que se intenta coincidir después de verificar la condición.

Por ejemplo, considera la expresión regular (?=\d)\w+. Aquí, (?=\d) es un positive lookahead que verifica si hay un dígito en la cadena, pero no consumirá ese dígito en la coincidencia. Luego, \w+ coincidirá con una o más letras, dígitos o guiones bajos.

Supongamos que aplicas esta expresión regular a la cadena "abc123". El positive lookahead verificará si hay un dígito en la cadena, lo que es verdadero. Luego, \w+ coincidirá con "abc123", ya que el positive lookahead no ha consumido el dígito.

En resumen, un positive lookahead permite verificar si cierta condición se cumple más adelante en la cadena sin consumir los caracteres correspondientes en la coincidencia actual. Esto es útil para establecer condiciones adicionales en una expresión regular sin afectar directamente la coincidencia actual.

Resumen sobre expresiones regulares

En general, las expresiones regulares son patrones de búsqueda y coincidencia que están diseñados para funcionar en múltiples lenguajes de programación. Sin embargo, puede haber algunas diferencias sutiles en la forma en que se implementan o en las funciones específicas que se utilizan para trabajar con expresiones regulares en cada lenguaje. Estas son algunas consideraciones a tener en cuenta:

Sintaxis de Escape: La sintaxis utilizada para escapar caracteres especiales (como ^, $, ., [, ], etc.) en expresiones regulares puede variar ligeramente entre los lenguajes. Asegúrate de consultar la documentación del lenguaje específico para conocer la sintaxis correcta.
Funciones Específicas: Cada lenguaje puede proporcionar funciones específicas para trabajar con expresiones regulares. Por ejemplo, en JavaScript se utiliza match(), en Python findall(), en PHP preg_match(), etc. Las funciones pueden tener parámetros y opciones específicos del lenguaje (como r en Phyton).
Modificadores: Algunos lenguajes permiten añadir modificadores a las expresiones regulares para cambiar su comportamiento. Por ejemplo, el modificador i en JavaScript y PHP indica que la coincidencia debe ser insensible a mayúsculas/minúsculas.
Soporte Unicode: Si necesitas trabajar con caracteres Unicode, es posible que haya diferencias en cómo los diferentes lenguajes manejan la coincidencia y búsqueda en expresiones regulares.
Cadenas Raw: Algunos lenguajes permiten utilizar cadenas raw (sin procesar) para expresiones regulares, lo que puede evitar la necesidad de duplicar las barras invertidas de escape.

A pesar de estas sutilezas, en su mayoría, las expresiones regulares siguen siendo portables entre diferentes lenguajes. Si estás familiarizado con la sintaxis básica y los conceptos detrás de las expresiones regulares, podrás adaptarlas a diferentes lenguajes con relativa facilidad. Sin embargo, siempre es recomendable consultar la documentación del lenguaje específico para asegurarte de utilizar la sintaxis y las funciones correctas. En la mayoría de los casos, las diferencias se encuentran en los elementos de escape de caracteres y delimitadores de texto \ / ‘

¡ Espero que este artículo sea de vuestro interés !

Cookie	Duración	Descripción
cookielawinfo-checkbox-analytics	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Analytics".
cookielawinfo-checkbox-functional	11 months	The cookie is set by GDPR cookie consent to record the user consent for the cookies in the category "Functional".
cookielawinfo-checkbox-necessary	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookies is used to store the user consent for the cookies in the category "Necessary".
cookielawinfo-checkbox-others	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Other.
cookielawinfo-checkbox-performance	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Performance".
viewed_cookie_policy	11 months	The cookie is set by the GDPR Cookie Consent plugin and is used to store whether or not user has consented to the use of cookies. It does not store any personal data.