Regular Expressions
Vitrine utile de regex

Faire correspondre une date

Vous devez vous rappeler que regex a été conçu pour correspondre à une date (ou non). Dire qu'une date est valide est une tâche beaucoup plus complexe, car elle nécessitera beaucoup de gestion des exceptions (voir conditions des années bissextiles ).

Commençons par faire correspondre le mois (1 - 12) avec un 0 optionnel:

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

Pour correspondre au jour, également avec un 0 optionnel:

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

Et pour correspondre à l'année (supposons juste la gamme 1900 - 2999):

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

Le séparateur peut être un espace, un tiret, une barre oblique, un espace vide, etc. N'hésitez pas à ajouter tout ce qui pourrait être utilisé comme séparateur:

[-\\/ ]?

Maintenant, vous concaténez le tout et obtenez:

(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 vous voulez être un peu plus pédant, vous pouvez utiliser une référence arrière pour vous assurer que les deux séparateurs seront identiques:

(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

Correspond à une adresse e-mail

Faire correspondre une adresse e-mail dans une chaîne est une tâche difficile, car la spécification qui la définit, la RFC2822 , est complexe, ce qui la rend difficile à implémenter en tant que regex. Pour plus de détails pourquoi ce n'est pas une bonne idée de faire correspondre un email avec une regex, veuillez vous référer à l'exemple d'antipattern pour ne pas utiliser une regex: pour les emails correspondants . Le meilleur conseil à noter sur cette page est d’utiliser une bibliothèque évaluée par des pairs et largement répandue dans votre langue préférée pour l’implémenter.

Valider un format d'adresse e-mail

Lorsque vous devez valider rapidement une entrée pour vous assurer qu'elle ressemble à un courrier électronique, la meilleure solution est de rester simple:

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

Cette regex vérifiera que l'adresse mail est une séquence de caractères de longueur supérieure à un, séparés par un espace, suivie d'un @ , suivie de deux séquences de caractères non-espaces de longueur supérieure ou égale à deux . . Ce n'est pas parfait et peut valider des adresses non valides (selon le format), mais surtout, cela n'invalide pas les adresses valides.

Vérifiez l'adresse existe

Le seul moyen fiable de vérifier la validité d’un email est de vérifier son existence. VRFY commande VRFY SMTP avait été conçue à cette fin, mais malheureusement, après avoir été abusée par des spammeurs, elle n’est plus disponible .

Donc, la seule façon de vérifier que le courrier est valide et qu’il existe, c’est d’envoyer un courrier électronique à cette adresse.

Énormes alternatives Regex

Cependant, il n'est pas impossible de valider une adresse email en utilisant une regex. Le seul problème est que plus les spécifications seront proches de la spécification, plus elles seront grosses et, par conséquent, difficiles à lire et à gérer. Vous trouverez ci-dessous des exemples de regex plus précises utilisées dans certaines bibliothèques.

X Les regex suivantes sont données à des fins de documentation et d'apprentissage, les copier-coller dans votre code est une mauvaise idée. Au lieu de cela, utilisez directement cette bibliothèque, de sorte que vous pouvez vous fier au code en amont et aux développeurs homologues pour maintenir votre code d'analyse des e-mails à jour et maintenu.

Module de correspondance d'adresses Perl

Les meilleurs exemples de telles regex se trouvent dans certaines bibliothèques standard de langages. Par exemple, il y en a un du module RFC::RFC822::Address dans la bibliothèque Perl qui essaie d'être aussi précis que possible selon la RFC. Pour votre curiosité, vous pouvez trouver une version de cette regex à cette URL , qui a été générée à partir de la grammaire, et si vous êtes tenté de copier-coller, voici une citation de l'auteur de regex:

" Je ne maintiens pas l'expression régulière [linked]. Il peut y avoir des bogues déjà corrigés dans le module Perl. "

Module de correspondance d'adresse .Net

Une autre variante, plus courte, est celle utilisée par la bibliothèque standard .Net dans le module 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])))\.?$

Mais même s'il est plus court, il est encore trop gros pour être lisible et facile à maintenir.

Module de correspondance d'adresse Ruby

Dans Ruby, une composition de regex est utilisée dans le module rfc822 pour correspondre à une adresse. C'est une bonne idée, car si des bogues sont détectés, il sera plus facile de trouver la partie regex à modifier et de la réparer.

Module de correspondance d'adresse Python

Par exemple, le module d'analyse de courrier électronique python n'utilise pas de regex, mais l'implémente à l'aide d'un analyseur.

Faire correspondre un numéro de téléphone

Voici comment faire correspondre un code de préfixe (a + ou (00), puis un nombre compris entre 1 et 1939, avec un espace facultatif):
^{Cela ne cherche pas un préfixe valide mais quelque chose qui pourrait être un préfixe. Voir la liste complète des préfixes}

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

Puis, comme la longueur totale du numéro de téléphone est, au maximum, 15, nous pouvons rechercher jusqu'à 14 chiffres:
^{Au moins un chiffre est dépensé pour le préfixe}

[0-9]{1,14}

Les numéros peuvent contenir des espaces, des points ou des tirets et peuvent être groupés par 2 ou 3.

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

Avec le préfixe optionnel:

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

Si vous souhaitez faire correspondre un format de pays spécifique, vous pouvez utiliser cette requête de recherche et ajouter le pays, la question a certainement déjà été posée.

Faire correspondre une adresse IP

IPv4

Pour correspondre au format d'adresse IPv4, vous devez vérifier les nombres [0-9]{1,3} trois fois {3} séparés par des points \. et se terminant par un autre numéro.

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

Cette expression régulière est trop simple - si vous voulez qu'elle soit précise, vous devez vérifier que les nombres sont compris entre 0 et 255 , avec le regex ci-dessus acceptant 444 dans n'importe quelle position. Vous voulez vérifier 250-255 avec 25[0-5] , ou toute autre valeur 200 2[0-4][0-9] , ou toute valeur 100 ou moins avec [01]?[0-9][0-9] . Vous voulez vérifier qu'il est suivi d'un point \. trois fois {3} et une fois sans période.

^(?:(?: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

Les adresses IPv6 prennent la forme de mots de 8 hexagonaux de 16 bits délimitées par les deux points ( : caractère). Dans ce cas, nous vérifions 7 mots suivis de deux-points, suivis d'un autre qui ne l'est pas. Si un mot a des zéros non significatifs, ils peuvent être tronqués, ce qui signifie que chaque mot peut contenir entre 1 et 4 chiffres hexadécimaux.

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

Ceci est cependant insuffisant. Comme les adresses IPv6 peuvent devenir très "verbeuses", la norme spécifie que les mots contenant uniquement des zéros peuvent être remplacés par :: . Cela ne peut être fait qu'une seule fois dans une adresse (pour n'importe où entre 1 et 7 mots consécutifs), car il serait autrement indéterminé. Cela produit un certain nombre de variations (plutôt désagréables):

^::(?:[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}::$

Maintenant, mettre tout cela ensemble (en utilisant l'alternance) donne:

^(?:[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}::$

Assurez-vous de l'écrire en mode multiligne et avec une pile de commentaires afin que quiconque est inévitablement chargé de déterminer ce que cela signifie ne vous poursuit pas avec un objet contondant.

Valider une chaîne de temps de 12 heures et 24 heures

Pour un format de 12 heures, on peut utiliser:

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

Où

• (?:0?[0-9]|1[0-2]) est l'heure
• [-:] est le séparateur qui peut être ajusté pour répondre à vos besoins
• [0-5][0-9] est la minute
• \s*[ap]m suivi un nombre quelconque de caractères d'espacement et am ou pm

Si vous avez besoin des secondes:

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

Pour un format de 24 heures:

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

Où:

• (?:[01][0-9]|2[0-3]) est l'heure
• [-:h] le séparateur, qui peut être ajusté pour répondre à vos besoins
• [0-5][0-9] est la minute

Avec les secondes:

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

Où [-:m] est un deuxième séparateur, en remplaçant le h pour les heures par un m pour les minutes et [0-5][0-9] pour le second.

Code postal du Royaume-Uni

Regex pour faire correspondre les codes postaux au Royaume-Uni

Le format est le suivant, où A signifie une lettre et 9 un chiffre:

(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})

Où première partie:

 (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]))))

Seconde:

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