Regular Expressions
Útil escaparate Regex

Emparejar una fecha

Debe recordar que la expresión regular fue diseñada para coincidir con una fecha (o no). Decir que una fecha es válida es una lucha mucho más complicada, ya que requerirá una gran cantidad de manejo de excepciones (consulte las condiciones del año bisiesto ).

Comencemos por hacer coincidir el mes (1 - 12) con un 0 inicial opcional:

0?[1-9]|1[0-2]

Para emparejar el día, también con un 0 inicial opcional:

0?[1-9]|[12][0-9]|3[01]

Y para coincidir con el año (asumamos el rango 1900 - 2999):

(?:19|20)[0-9]{2}

El separador puede ser un espacio, un guión, una barra oblicua, un espacio vacío, etc. Siéntase libre de agregar cualquier cosa que crea que pueda usarse como separador:

[-\\/ ]?

Ahora concatena todo y obtienes:

(0?[1-9]|1[0-2])[-\\/ ]?(0?[1-9]|[12][0-9]|3[01])[-/ ]?(?:19|20)[0-9]{2} // MMDDYYYY
(0?[1-9]|[12][0-9]|3[01])[-\\/ ]?(0?[1-9]|1[0-2])[-/ ]?(?:19|20)[0-9]{2} // DDMMYYYY
(?:19|20)[0-9]{2}[-\\/ ]?(0?[1-9]|1[0-2])[-/ ]?(0?[1-9]|[12][0-9]|3[01]) // YYYYMMDD

Si desea ser un poco más pedante, puede usar una referencia posterior para asegurarse de que los dos separadores sean iguales:

(0?[1-9]|1[0-2])([-\\/ ]?)(0?[1-9]|[12][0-9]|3[01])\2(?:19|20)[0-9]{2} // MMDDYYYY
                                                 ^ refer to [-/ ]
(0?[1-9]|[12][0-9]|3[01])([-\\/ ]?)(0?[1-9]|1[0-2])\2(?:19|20)[0-9]{2} // DDMMYYYY
(?:19|20)[0-9]{2}([-\\/ ]?)(0?[1-9]|1[0-2])\2(0?[1-9]|[12][0-9]|3[01]) // YYYYMMDD

Coincidir con una dirección de correo electrónico

Hacer coincidir una dirección de correo electrónico dentro de una cadena es una tarea difícil, porque la especificación que la define, el RFC2822 , es compleja, lo que dificulta su implementación como una expresión regular. Para obtener más detalles sobre por qué no es una buena idea hacer coincidir un correo electrónico con una expresión regular, consulte el ejemplo antipattern cuando no use una expresión regular: para correos electrónicos coincidentes . El mejor consejo para tomar nota de esa página es usar una biblioteca revisada por pares y ampliamente en su idioma favorito para implementar esto.

Validar un formato de dirección de correo electrónico

Cuando necesite validar rápidamente una entrada para asegurarse de que se vea como un correo electrónico, la mejor opción es que sea sencillo:

^\S{1,}@\S{2,}\.\S{2,}$

Esa expresión regular comprobará que la dirección de correo es una secuencia de caracteres de longitud superior a uno sin espacios separados por espacios, seguida de una @ , seguida de dos secuencias de caracteres de espacios no espacios de dos o más caracteres separados por a . . No es perfecto y puede validar direcciones no válidas (según el formato), pero lo más importante es que no invalida las direcciones válidas.

Verifica que la dirección exista

La única forma confiable de verificar que un correo electrónico es válido es verificar su existencia. Solía ​​haber el VRFY SMTP que fue diseñado para ese propósito, pero lamentablemente, después de ser abusado por los spammers, ahora ya no está disponible .

Por lo tanto, la única forma de verificar que el correo es válido y existe es enviar un correo electrónico a esa dirección.

Enormes alternativas Regex

Sin embargo, no es imposible validar un correo electrónico de dirección utilizando una expresión regular. El único problema es que cuanto más cerca de la especificación estén esas expresiones regulares, más grandes serán y, por consiguiente, son increíblemente difíciles de leer y mantener. A continuación, encontrará ejemplos de expresiones regulares más precisas que se utilizan en algunas bibliotecas.

⚠️ Las siguientes expresiones regulares se proporcionan para fines de documentación y aprendizaje, y copiarlas en su código es una mala idea. En su lugar, use esa biblioteca directamente, de modo que puede confiar en el código de flujo ascendente y los desarrolladores pares para mantener actualizado y actualizado su código de análisis de correo electrónico.

Módulo de coincidencia de direcciones Perl

Los mejores ejemplos de expresiones regulares de este tipo se encuentran en las bibliotecas estándar de algunos idiomas. Por ejemplo, hay uno del módulo RFC::RFC822::Address en la biblioteca de Perl que intenta ser lo más preciso posible de acuerdo con el RFC. Para su curiosidad, puede encontrar una versión de esa expresión regular en esta URL , que se ha generado a partir de la gramática, y si está tentado de copiarla, aquí hay una cita del autor de la expresión regular:

" No mantengo la expresión regular [vinculada]. Puede que haya errores que ya se hayan solucionado en el módulo Perl " .

Módulo de coincidencia de direcciones .Net

Otra variante más corta es la que usa la biblioteca estándar .Net en el módulo EmailAddressAttribute :

^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$

Pero incluso si es más corto , todavía es demasiado grande para ser legible y fácil de mantener.

Módulo de Ruby Address Match

En ruby, una composición de expresiones regulares se está utilizando en el módulo rfc822 para que coincida con una dirección. Esta es una buena idea, ya que en el caso de que se encuentren errores, será más fácil identificar la parte de expresiones regulares para cambiarla y corregirla.

Módulo de coincidencia de direcciones Python

Como ejemplo de contador, el módulo de análisis de correo electrónico de Python no está utilizando una expresión regular, sino que lo implementa utilizando un analizador.

Coincidir con un número de teléfono

Aquí le indicamos cómo hacer coincidir un código de prefijo (a + o (00), luego un número del 1 al 1939, con un espacio opcional):
^{Esto no busca un prefijo válido sino algo que podría ser un prefijo. Ver la lista completa de prefijos}

(?:00|\+)?[0-9]{4}

Luego, como la longitud total del número de teléfono es, como máximo, 15, podemos buscar hasta 14 dígitos:
^{Se gasta al menos 1 dígito para el prefijo}

[0-9]{1,14}

Los números pueden contener espacios, puntos o guiones y se pueden agrupar por 2 o 3.

(?:[ .-][0-9]{3}){1,5}

Con el prefijo opcional:

(?:(?:00|\+)?[0-9]{4})?(?:[ .-][0-9]{3}){1,5}

Si desea hacer coincidir un formato de país específico, puede utilizar esta consulta de búsqueda y agregar el país, la pregunta ya ha sido hecha.

Coincidir con una dirección IP

IPv4

Para coincidir con el formato de la dirección IPv4, debe verificar los números [0-9]{1,3} tres veces {3} separados por puntos \. y terminando con otro número.

^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$

Esta expresión regular es demasiado simple: si desea que sea precisa, debe verificar que los números estén entre 0 y 255 , con la expresión regular anterior que acepta 444 en cualquier posición. ¿Quiere verificar 250-255 con 25[0-5] , o cualquier otro valor 200 2[0-4][0-9] , o cualquier valor 100 o menos con [01]?[0-9][0-9] . Desea comprobar que va seguido de un punto \. tres veces {3} y luego una vez sin un punto.

^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

IPv6

Las direcciones IPv6 se presentan en forma de 8 palabras, hexagonales de 16 bits delimitados con los dos puntos ( : carácter). En este caso, verificamos 7 palabras seguidas de dos puntos, seguidas de una que no lo sea. Si una palabra tiene ceros iniciales, se pueden truncar, lo que significa que cada palabra puede contener entre 1 y 4 dígitos hexadecimales.

^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

Esto, sin embargo, es insuficiente. Como las direcciones IPv6 pueden volverse bastante "complicadas", la norma especifica que las palabras de solo cero pueden reemplazarse por :: . Esto solo se puede hacer una vez en una dirección (para cualquier lugar entre 1 y 7 palabras consecutivas), ya que de otro modo sería indeterminado. Esto produce una serie de variaciones (bastante desagradables):

^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$
^[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$
^[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:)?[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}::[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}::$

Ahora, al juntarlo todo (usando alternancia) se obtiene:

^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|
^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$|
^[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$|
^[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:)?[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}::[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}::$

Asegúrate de escribirlo en modo multilínea y con un montón de comentarios para que quienquiera que tenga la tarea inevitable de averiguar qué significa esto no te persiga con un objeto contundente.

Validar una cadena de tiempo de 12 horas y 24 horas

Para un formato de 12 horas se puede usar:

^(?:0?[0-9]|1[0-2])[-:][0-5][0-9]\s*[ap]m$

Dónde

• (?:0?[0-9]|1[0-2]) es la hora
• [-:] es el separador, que puede ajustarse para adaptarse a sus necesidades
• [0-5][0-9] es el minuto
• \s*[ap]m siguió cualquier número de caracteres de espacio en blanco, y am o pm

Si necesitas los segundos:

^(?:0?[0-9]|1[0-2])[-:][0-5][0-9][-:][0-5][0-9]\s*[ap]m$

Para un formato de 24 horas:

^(?:[01][0-9]|2[0-3])[-:h][0-5][0-9]$

Dónde:

• (?:[01][0-9]|2[0-3]) es la hora
• [-:h] el separador, que puede ajustarse para adaptarse a sus necesidades
• [0-5][0-9] es el minuto

Con los segundos:

^(?:[01][0-9]|2[0-3])[-:h][0-5][0-9][-:m][0-5][0-9]$

Donde [-:m] es un segundo separador, reemplazando la h por horas con una m por minutos, y [0-5][0-9] es el segundo.

Código postal del Reino Unido del partido

Regex para hacer coincidir los códigos postales en el Reino Unido

El formato es el siguiente, donde A significa una letra y 9 un dígito:

(GIR 0AA)|((([A-Z-[QVX]][0-9][0-9]?)|(([A-Z-[QVX]][A-Z-[IJZ]][0-9][0-9]?)|(([A-Z-[QVX]][0-9][A-HJKPSTUW])|([A-Z-[QVX]][A-Z-[IJZ]][0-9][ABEHMNPRVWXY])))) [0-9][A-Z-[CIKMOV]]{2})

Donde primera parte:

 (GIR 0AA)|((([A-Z-[QVX]][0-9][0-9]?)|(([A-Z-[QVX]][A-Z-[IJZ]][0-9][0-9]?)|(([A-Z-[QVX]][0-9][A-HJKPSTUW])|([A-Z-[QVX]][A-Z-[IJZ]][0-9][ABEHMNPRVWXY]))))

Segundo:

[0-9][A-Z-[CIKMOV]]{2})