Comment valider une adresse email en utilisant une expression régulière?

Question

Au fil des ans, j'ai lentement développé une expression régulière qui valide correctement la plupart des adresses électroniques, en supposant qu'elles n'utilisent pas d'adresse IP comme partie serveur.

Je l'utilise dans plusieurs programmes PHP, et cela fonctionne la plupart du temps. Cependant, de temps en temps, une personne qui rencontre un problème avec un site qui l'utilise me contacte et je dois faire quelques ajustements (tout récemment, j'ai réalisé que je n'autorisais pas les TLD à 4 caractères).

Quelle est la meilleure expression régulière que vous avez ou avez vue pour valider vos emails?

J'ai vu plusieurs solutions qui utilisent des fonctions qui utilisent plusieurs expressions plus courtes, mais je préférerais une expression complexe longue dans une fonction simple au lieu de plusieurs expressions courtes dans une fonction plus complexe.

bortzmeyer · Accepted Answer

Le regex conforme à la norme RFC 822 est inefficace et obscur en raison de sa longueur. Heureusement, la RFC 822 a été remplacée deux fois et la spécification actuelle pour les adresses électroniques est RFC 5322 . La RFC 5322 conduit à une expression régulière qui peut être comprise si elle est étudiée pendant quelques minutes et qui est suffisamment efficace pour une utilisation réelle.

Vous pouvez trouver une expression rationnelle conforme à la norme RFC 5322 en haut de la page à l’adresse http://emailregex.com/ mais utilise le modèle d’adresse IP qui flotte sur Internet avec un bogue qui permet à 00 pour toute valeur décimale d'octet non signé dans une adresse délimitée par des points, ce qui est illégal. Le reste semble être conforme à la grammaire RFC 5322 et passe plusieurs tests utilisant grep -Po, y compris les noms de domaine, les adresses IP, les adresses incorrectes et les noms de compte avec et sans guillemets.

En corrigeant le bogue 00 dans le modèle IP, nous obtenons une regex fonctionnelle et assez rapide. (Grattez la version rendue, pas la démarque, pour le code réel.)

(?: [a-z0-9! # $% & '* +/=? ^ _ `{|} ~ -] + (?: \. [a-z0-9! # $% &' * +/=? ^ _ `{|} ~ -] +) * |" (?: [\ x01-\x08\x0b\x0c\x0e-\x1f\x21\x21- xxb\x5d-\x7f] | \ [\ x01-\x09\x0b\x0c\x0e-\x7f]) * ") @ (?: (?: [a-z0-9] (?: [a-z0-9 -] * [a-z0 -9])? \.) + [A-z0-9] (?: [A-z0-9 -] * [a-z0-9])? |$$(? :(? :(:: 2 (5 [0-5] | [0-4] [0-9]) | 1 [0-9] [0-9] | [1-9]? [0-9])). 3) ( ? :( 2 (5 [0-5] | [0-4] [0-9]) | 1 [0-9] [0-9] | [1-9]? [0-9]) | [ a-z0-9 -] * [a-z0-9]: (?: [\ x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f] | \ [\ x01-\x09\x0b\x0c\x0e-\x7f]) +) $$)

Voici diagramme de machine à états finis pour l'expression rationnelle ci-dessus, ce qui est plus clair que l'expression rationnelle elle-même

Les modèles plus sophistiqués dans Perl et PCRE (bibliothèque de regex utilisée par exemple en PHP) peuvent analyser correctement la RFC 5322 sans accroc . Python et C # peuvent le faire aussi, mais ils utilisent une syntaxe différente de celle des deux premières. Toutefois, si vous êtes obligé d’utiliser l’un des nombreux langages de correspondance de modèle moins puissants, il est préférable d’utiliser un véritable analyseur.

Il est également important de comprendre que la validation conformément à la RFC ne vous dit absolument pas si cette adresse existe réellement dans le domaine fourni ou si la personne qui entre l'adresse est son véritable propriétaire. Les gens inscrivent les autres aux listes de diffusion de cette façon tout le temps. Les corrections nécessitant une validation plus sophistiquée consistant à envoyer à cette adresse un message contenant un jeton de confirmation destiné à être entré sur la même page Web que celle-ci était l'adresse.

Les jetons de confirmation sont le seul moyen de savoir si vous avez l'adresse de la personne qui l'a saisie. C'est pourquoi la plupart des listes de diffusion utilisent maintenant ce mécanisme pour confirmer les inscriptions. Après tout, n'importe qui peut écrire president@whitehouse.gov, et cela sera même considéré comme légal, mais ce n'est probablement pas la personne qui se trouve à l'autre bout.

Pour PHP, vous devez ne pas utiliser le modèle indiqué dans Valider une adresse électronique avec PHP, dans le bon sens à partir duquel Je cite:

Il existe un risque que l'utilisation courante et le codage très répandu ne créent une norme de facto pour les adresses électroniques plus restrictive que la norme formelle enregistrée.

Ce n'est pas meilleur que tous les autres modèles non-RFC. Il n’est même pas assez intelligent pour gérer même RFC 822 , sans parler du RFC 5322. Celui-ci , cependant, est.

Si vous voulez être chic et pédant, implémentez un moteur d'état complet . Une expression régulière ne peut servir que de filtre rudimentaire. Le problème avec les expressions régulières est de dire à quelqu'un que son adresse électronique parfaitement valide est invalide (un faux positif) parce que votre expression régulière ne peut pas la gérer est simplement grossière et impolie du point de vue de l'utilisateur. Un moteur d'état à cet effet peut à la fois valider et même corriger les adresses de messagerie qui seraient autrement considérées comme non valides car il désassemble l'adresse de messagerie en fonction de chaque RFC. Cela permet une expérience potentiellement plus agréable, comme

L'adresse de messagerie spécifiée "myemail @ address, com" est invalide. Voulez-vous dire 'myemail@address.com'?

Voir aussi Validation des adresses électroniques , y compris les commentaires. Ou Comparaison d'une adresse électronique validant des expressions régulières .

Démo Debuggex

SLaks · Answer

You should not use regular expressions to validate email addresses.

Instead, use the MailAddress class, like this:

try { address = new MailAddress(address).Address; } catch(FormatException) { //address is invalid }

The MailAddress class uses a BNF parser to validate the address in full accordance with RFC822.

If you really want to use a regex, here it is:

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t] )+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?: \r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:( ?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\0 31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\ ](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+ (?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?: (?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z |(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n) ?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\ r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n) ?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t] )*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])* )(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t] )+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*) *:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+ |\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r \n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?: \r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t ]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031 ]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\]( ?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(? :(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(? :\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\". \000-\031]+(?:(? :(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)? [ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]| \.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<> @,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|" (?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t] )*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\ ".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(? :[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[ $$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\". \000- \031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|( ?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,; :\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([ ^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\" . \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[\ ]\r$$|\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\".\ [\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\ r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\] |\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\". \0 00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\ .|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@, ;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(? :[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])* (?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\". \[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[ ^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$ ]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*( ?:(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\ ".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:( ?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[ $$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t ])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t ])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(? :\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+| \Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*|(?: [^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[\ ]]))|"(?:[^\"\r$$|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n) ?[ \t])*(?:@(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$" ()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n) ?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<> @,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@, ;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t] )*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\ ".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)? (?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\". \[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?: \r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$ "()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t]) *))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t]) +|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\ .(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z |(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:( ?:\r\n)?[ \t])*))*)?;\s*)

JacquesB · Answer

Cette question est souvent posée, mais je pense que vous devriez prendre du recul et vous demander pourquoi vous voulez valider les adresses électroniques de manière syntaxique? Quel est l'avantage vraiment?

Il n'attrapera pas les fautes de frappe courantes.
Cela n'empêche pas les personnes d'entrer des adresses électroniques non valides ou inventées, ou d'entrer l'adresse d'une autre personne.

Si vous souhaitez valider qu'un courrier électronique est correct, vous n'avez pas d'autre choix que d'envoyer un courrier électronique de confirmation et que l'utilisateur y réponde. Dans de nombreux cas, vous devrez {avoir} _ toujours envoyer un courrier électronique de confirmation pour des raisons de sécurité ou pour des raisons éthiques (vous ne pourrez par exemple pas engager un service contre son gré).

Good Person · Answer

Cela dépend de ce que vous entendez par meilleur: Si vous parlez d’attraper chaque adresse e-mail valide, utilisez ce qui suit:

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t] )+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?: \r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:( ?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\0 31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\ ](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+ (?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?: (?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z |(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n) ?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\ r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n) ?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t] )*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])* )(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t] )+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*) *:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+ |\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r \n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?: \r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t ]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031 ]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\]( ?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(? :(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(? :\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\". \000-\031]+(?:(? :(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)? [ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]| \.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<> @,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|" (?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t] )*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\ ".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(? :[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[ $$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\". \000- \031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|( ?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,; :\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([ ^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\" . \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[\ ]\r$$|\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\".\ [\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\ r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\] |\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\". \0 00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\ .|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@, ;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|"(? :[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])* (?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\". \[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[ ^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[$$ ]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*( ?:(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\ ".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:( ?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[ $$"()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t ])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t ])+|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(? :\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+| \Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*|(?: [^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\".\[\ ]]))|"(?:[^\"\r$$|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n) ?[ \t])*(?:@(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$" ()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n) ?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<> @,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@, ;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t] )*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\ ".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)? (?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$"()<>@,;:\". \[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?: \r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[$$ "()<>@,;:\".\[$$]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t]) *))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t]) +|\Z|(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*)(?:\ .(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\". \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z |(?=[$$"()<>@,;:\".\[$$]))|$$([^\[$$\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:( ?:\r\n)?[ \t])*))*)?;\s*)

( http://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html ) Si vous recherchez quelque chose de plus simple mais qui attrape la plupart des adresses e-mail valides :

"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"

EDIT: Du lien:

Cette expression régulière validera uniquement les adresses dont les commentaires ont été supprimés et remplacés par des espaces (ceci est effectué par le module).

Andy Lester · Answer

Tout dépend de votre précision. Pour mes besoins, lorsque j'essaie simplement d'empêcher des choses telles que bob @ aol.com (espaces dans les emails) ou steve (aucun domaine) ou mary@aolcom (aucune période avant .com), j'utilise

/^\S+@\S+\.\S+$/

Bien sûr, cela correspondra aux éléments qui ne sont pas des adresses électroniques valides, mais il suffit de jouer à la règle des 90/10.

Dominic Sayers · Answer

[MISE À JOUR] J'ai réuni tout ce que je sais sur la validation des adresses électroniques ici: http://isemail.info , qui non seulement valide, mais diagnostique également les problèmes liés aux adresses électroniques. Je suis d’accord avec beaucoup des commentaires ici: la validation n’est qu’une partie de la réponse; voir mon essai à http://isemail.info/about .

is_email () reste, à ma connaissance, le seul validateur qui vous dira définitivement si une chaîne donnée est une adresse email valide ou non. J'ai téléchargé une nouvelle version à http://isemail.info/

J'ai rassemblé des cas de test de Cal Henderson, Dave Child, Phil Haack, Doug Lovell, RFC5322 et RFC 3696. Au total, 275 adresses de test. J'ai exécuté tous ces tests contre tous les validateurs gratuits que j'ai pu trouver.

Je vais essayer de garder cette page à jour à mesure que les gens améliorent leurs validateurs. Merci à Cal, Michael, Dave, Paul et Phil pour leur aide et leur coopération dans la compilation de ces tests et la critique constructive de mon propre validateur .

Les gens doivent être conscients de la errata contre la RFC 3696 en particulier. Trois des exemples canoniques sont en fait des adresses invalides. Et la longueur maximale d'une adresse est de 254 ou 256 caractères, not 320.

Josh Stodola · Answer

Per spécification HTML5 du W3C :

^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$

Le contexte:

Une adresse e-mail valide est une chaîne qui correspond à la production ABNF […].

Remarque: Cette exigence est un violation volontaire de RFC 5322 , qui définit une syntaxe à la fois trop stricte pour les adresses de messagerie (avant le caractère "@"). trop vague (après le caractère "@") et trop laxiste (permettant des commentaires, des caractères d'espacement, et des chaînes entre guillemets inconnus de la plupart des utilisateurs) pour une utilisation pratique ici.

L'expression régulière suivante compatible JavaScript et Perl est une implémentation de la définition ci-dessus.
/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/ 

Abigail · Answer

C’est facile avec Perl 5.10 ou plus récent:

/(?(DEFINE) (?<address> (?&mailbox) | (?&group)) (?<mailbox> (?&name_addr) | (?&addr_spec)) (?<name_addr> (?&display_name)? (?&angle_addr)) (?<angle_addr> (?&CFWS)? < (?&addr_spec) > (?&CFWS)?) (?<group> (?&display_name) : (?:(?&mailbox_list) | (?&CFWS))? ; (?&CFWS)?) (?<display_name> (?&phrase)) (?<mailbox_list> (?&mailbox) (?: , (?&mailbox))*) (?<addr_spec> (?&local_part) \@ (?&domain)) (?<local_part> (?&dot_atom) | (?&quoted_string)) (?<domain> (?&dot_atom) | (?&domain_literal)) (?<domain_literal> (?&CFWS)? $$ (?: (?&FWS)? (?&dcontent))* (?&FWS)? $$ (?&CFWS)?) (?<dcontent> (?&dtext) | (?&quoted_pair)) (?<dtext> (?&NO_WS_CTL) | [\x21-\x5a\x5e-\x7e]) (?<atext> (?&ALPHA) | (?&DIGIT) | [!#\$%&'*+-/=?^_`{|}~]) (?<atom> (?&CFWS)? (?&atext)+ (?&CFWS)?) (?<dot_atom> (?&CFWS)? (?&dot_atom_text) (?&CFWS)?) (?<dot_atom_text> (?&atext)+ (?: \. (?&atext)+)*) (?<text> [\x01-\x09\x0b\x0c\x0e-\x7f]) (?<quoted_pair> \ (?&text)) (?<qtext> (?&NO_WS_CTL) | [\x21\x23-\x5b\x5d-\x7e]) (?<qcontent> (?&qtext) | (?&quoted_pair)) (?<quoted_string> (?&CFWS)? (?&DQUOTE) (?:(?&FWS)? (?&qcontent))* (?&FWS)? (?&DQUOTE) (?&CFWS)?) (?<Word> (?&atom) | (?&quoted_string)) (?<phrase> (?&Word)+) # Folding white space (?<FWS> (?: (?&WSP)* (?&CRLF))? (?&WSP)+) (?<ctext> (?&NO_WS_CTL) | [\x21-\x27\x2a-\x5b\x5d-\x7e]) (?<ccontent> (?&ctext) | (?&quoted_pair) | (?&comment)) (?<comment> $ (?: (?&FWS)? (?&ccontent))* (?&FWS)? $ ) (?<CFWS> (?: (?&FWS)? (?&comment))* (?: (?:(?&FWS)? (?&comment)) | (?&FWS))) # No whitespace control (?<NO_WS_CTL> [\x01-\x08\x0b\x0c\x0e-\x1f\x7f]) (?<ALPHA> [A-Za-z]) (?<DIGIT> [0-9]) (?<CRLF> \x0d \x0a) (?<DQUOTE> ") (?<WSP> [\x20\x09]) ) (?&address)/x

Per Hornsh&#248;j-Schierbeck · Answer

J'utilise

^\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$

Quel est celui utilisé dans ASP.NET par RegularExpressionValidator.

Chris Vest · Answer

Je ne sais pas ce qu'il y a de mieux, mais celui-ci est au moins correct, tant que les adresses ont leurs commentaires effacés et remplacés par des espaces.

Sérieusement. Vous devriez utiliser une bibliothèque déjà écrite pour valider vos emails. La meilleure solution consiste probablement à envoyer un courrier électronique de vérification à cette adresse.

davcar · Answer

Les adresses de messagerie que je veux valider vont être utilisées par une application Web ASP.NET utilisant l'espace de noms System.Net.Mail pour envoyer des courriers électroniques à une liste de personnes. Ainsi, plutôt que d’utiliser une expression régulière très complexe, j’essaie simplement de créer une instance MailAddress à partir de l’adresse. Le constructeur MailAddress lèvera une exception si l'adresse n'est pas formée correctement. De cette façon, je sais que je peux au moins obtenir le courrier électronique de la porte. Bien sûr, il s’agit d’une validation côté serveur, mais vous en avez au moins besoin de toute façon.

protected void emailValidator_ServerValidate(object source, ServerValidateEventArgs args) { try { var a = new MailAddress(txtEmail.Text); } catch (Exception ex) { args.IsValid = false; emailValidator.ErrorMessage = "email: " + ex.Message; } }

Rinke · Answer

Réponse rapide

Utilisez les expressions régulières suivantes pour la validation des entrées:

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\[\t -~]))+")@[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)+

Adresses correspondant à cette expression rationnelle:

avoir une partie locale (c'est-à-dire la partie précédant le signe @) strictement conforme à la RFC 5321/5322,
avoir une partie de domaine (c'est-à-dire la partie après le signe @) qui est un nom d'hôte avec au moins deux étiquettes, chacune comportant au plus 63 caractères.

La deuxième contrainte est une restriction de la RFC 5321/5322.

Réponse élaborée

L'utilisation d'une expression régulière qui reconnaît les adresses électroniques peut être utile dans différentes situations: par exemple, rechercher des adresses électroniques dans un document, valider les entrées de l'utilisateur ou imposer une contrainte d'intégrité à un référentiel de données.

Il convient toutefois de noter que si vous souhaitez savoir si l'adresse fait effectivement référence à une boîte aux lettres existante, rien ne remplace l'envoi d'un message à l'adresse. Si vous voulez seulement vérifier si une adresse est grammaticalement correcte, vous pouvez utiliser une expression régulière, mais notez que ""@[] est une adresse électronique grammaticalement correcte qui ne fait certainement pas référence à une boîte aux lettres existante.

La syntaxe des adresses électroniques a été définie dans divers RFC , plus particulièrement RFC 822 et RFC 5322 . La RFC 822 doit être considérée comme la norme "originale" et la RFC 5322 comme la dernière norme. La syntaxe définie dans la RFC 822 est la plus indulgente et les normes ultérieures ont restreint de plus en plus la syntaxe, les nouveaux systèmes ou services devant reconnaître la syntaxe obsolète sans la produire jamais.

Dans cette réponse, je vais prendre le terme «adresse électronique» pour désigner addr-spec tel que défini dans les RFC (c.-à-d. jdoe@example.org, mais pas "John Doe"<jdoe@example.org>, ni some-group:jdoe@example.org,mrx@exampel.org;).

La traduction des syntaxes RFC en expressions rationnelles pose un problème: les syntaxes ne sont pas régulières! En effet, ils autorisent des commentaires facultatifs dans les adresses électroniques qui peuvent être imbriquées à l'infini, tandis que l'imbrication infinie ne peut pas être décrite par une expression régulière. Pour rechercher ou valider des adresses contenant des commentaires, vous avez besoin d'un analyseur ou d'expressions plus puissantes. (Notez que les langages tels que Perl ont des constructions pour décrire les grammaires sans contexte de la même manière que les expressions rationnelles.) Dans cette réponse, je ne prendrai pas en compte les commentaires et ne considérerai que les expressions rationnelles appropriées.

Les RFC définissent des syntaxes pour les messages électroniques, pas pour les adresses électroniques en tant que telles. Les adresses peuvent apparaître dans différents champs d’en-tête et c’est là qu’elles sont définies. Lorsqu'ils apparaissent dans les champs d'en-tête, les adresses peuvent contenir (entre les jetons lexicaux) des espaces, des commentaires et même des sauts de ligne. Sémantiquement, cela n'a aucune signification. En supprimant cet espace, etc. d'une adresse, vous obtenez une représentation sémantiquement équivalente canonique. Ainsi, la représentation canonique de first. last (comment) @ [3.5.7.9] est first.last@[3.5.7.9].

Différentes syntaxes doivent être utilisées à des fins différentes. Si vous souhaitez numériser des adresses électroniques dans un document (peut-être très ancien), il peut être judicieux d'utiliser la syntaxe telle que définie dans la RFC 822. D'autre part, si vous souhaitez valider la saisie de l'utilisateur, vous pouvez utiliser la syntaxe telle que définie dans la RFC 5322, n'acceptant probablement que des représentations canoniques. Vous devez décider quelle syntaxe s'applique à votre cas particulier.

J'utilise des expressions régulières "étendues" POSIX dans cette réponse, en supposant un jeu de caractères compatible ASCII.

RFC 822

Je suis arrivé à l'expression régulière suivante. J'invite tout le monde à essayer de le casser. Si vous trouvez des faux positifs ou des faux négatifs, merci de les poster dans un commentaire et je tenterai de corriger l'expression le plus rapidement possible.

([^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]))*(\\r)*")(\.([^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]))*(\\r)*"))*@([^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]))*(\\r)*])(\.([^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]))*(\\r)*]))*

Je crois qu'il est totalement compatible avec la RFC 822, y compris le errata . Il reconnaît uniquement les adresses électroniques sous leur forme canonique. Pour une expression rationnelle qui reconnaît (plie) les espaces, voir la dérivation ci-dessous.

La dérivation montre comment je suis arrivé à l'expression. Je liste toutes les règles de grammaire pertinentes de la RFC exactement comme elles apparaissent, suivies de la regex correspondante. Lorsqu'un erratum a été publié, je donne une expression distincte pour la règle de grammaire corrigée (marquée "erratum") et utilise la version mise à jour comme sous-expression dans les expressions régulières suivantes.

Comme indiqué au paragraphe 3.1.4. de la RFC 822, un espace blanc linéaire facultatif peut être inséré entre les jetons lexicaux. Le cas échéant, j'ai développé les expressions pour tenir compte de cette règle et marqué le résultat avec "opt-lwsp".

CHAR = <any ASCII character> =~ . CTL = <any ASCII control character and DEL> =~ [\x00-\x1F\x7F] CR = <ASCII CR, carriage return> =~ \r LF = <ASCII LF, linefeed> =~ \n SPACE = <ASCII SP, space> =~ HTAB = <ASCII HT, horizontal-tab> =~ \t <"> = <ASCII quote mark> =~ " CRLF = CR LF =~ \r\n LWSP-char = SPACE / HTAB =~ [ \t] linear-white-space = 1*([CRLF] LWSP-char) =~ ((\r\n)?[ \t])+ specials = "(" / ")" / "<" / ">" / "@" / "," / ";" / ":" / "\" / <"> / "." / "[" / "]" =~ [][()<>@,;:\".] quoted-pair = "\" CHAR =~ \. qtext = <any CHAR excepting <">, "\" & CR, and including linear-white-space> =~ [^"\\r]|((\r\n)?[ \t])+ dtext = <any CHAR excluding "[", "]", "\" & CR, & including linear-white-space> =~ [^][\\r]|((\r\n)?[ \t])+ quoted-string = <"> *(qtext|quoted-pair) <"> =~ "([^"\\r]|((\r\n)?[ \t])|\.)*" (erratum) =~ "(\n|(\\r)*([^"\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*" domain-literal = "[" *(dtext|quoted-pair) "]" =~ \[([^][\\r]|((\r\n)?[ \t])|\.)*] (erratum) =~ \[(\n|(\\r)*([^][\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*] atom = 1*<any CHAR except specials, SPACE and CTLs> =~ [^][()<>@,;:\". \x00-\x1F\x7F]+ Word = atom / quoted-string =~ [^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*" domain-ref = atom sub-domain = domain-ref / domain-literal =~ [^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*] local-part = Word *("." Word) =~ ([^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*")(\.([^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*"))* (opt-lwsp) =~ ([^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*")(((\r\n)?[ \t])*\.((\r\n)?[ \t])*([^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*"))* domain = sub-domain *("." sub-domain) =~ ([^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*])(\.([^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*]))* (opt-lwsp) =~ ([^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*])(((\r\n)?[ \t])*\.((\r\n)?[ \t])*([^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*]))* addr-spec = local-part "@" domain =~ ([^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*")(\.([^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*"))*@([^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*])(\.([^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*]))* (opt-lwsp) =~ ([^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*")((\r\n)?[ \t])*(\.((\r\n)?[ \t])*([^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*")((\r\n)?[ \t])*)*@((\r\n)?[ \t])*([^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*])(((\r\n)?[ \t])*\.((\r\n)?[ \t])*([^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]|(\r\n)?[ \t]))*(\\r)*]))* (canonical) =~ ([^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]))*(\\r)*")(\.([^][()<>@,;:\". \x00-\x1F\x7F]+|"(\n|(\\r)*([^"\\r\n]|\[^\r]))*(\\r)*"))*@([^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]))*(\\r)*])(\.([^][()<>@,;:\". \x00-\x1F\x7F]+|\[(\n|(\\r)*([^][\\r\n]|\[^\r]))*(\\r)*]))*

RFC 5322

Je suis arrivé à l'expression régulière suivante. J'invite tout le monde à essayer de le casser. Si vous trouvez des faux positifs ou des faux négatifs, merci de les poster dans un commentaire et je tenterai de corriger l'expression le plus rapidement possible.

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

Je crois qu'il est totalement compatible avec la RFC 5322, y compris le errata . Il reconnaît uniquement les adresses électroniques sous leur forme canonique. Pour une expression rationnelle qui reconnaît (plie) les espaces, voir la dérivation ci-dessous.La dérivation montre comment je suis arrivé à l'expression. Je liste toutes les règles de grammaire pertinentes de la RFC exactement comme elles apparaissent, suivies de la regex correspondante. Pour les règles qui incluent des espaces sémantiquement non pertinents (repliement), je donne une expression rationnelle distincte marquée "(normalisée)" qui n'accepte pas cet espace.

J'ai ignoré toutes les règles "obs" de la RFC. Cela signifie que les expressions rationnelles correspondent uniquement aux adresses électroniques strictement conformes à la norme RFC 5322. Si vous devez faire correspondre les "anciennes" adresses (comme le fait la grammaire plus souple, y compris les règles "obs"), vous pouvez utiliser l'une des expressions rationnelles RFC 822 du paragraphe précédent.

VCHAR = %x21-7E =~ [!-~] ALPHA = %x41-5A / %x61-7A =~ [A-Za-z] DIGIT = %x30-39 =~ [0-9] HTAB = %x09 =~ \t CR = %x0D =~ \r LF = %x0A =~ \n SP = %x20 =~ DQUOTE = %x22 =~ " CRLF = CR LF =~ \r\n WSP = SP / HTAB =~ [\t ] quoted-pair = "\" (VCHAR / WSP) =~ \[\t -~] FWS = ([*WSP CRLF] 1*WSP) =~ ([\t ]*\r\n)?[\t ]+ ctext = %d33-39 / %d42-91 / %d93-126 =~ []!-'*-[^-~] ("comment" is left out in the regex) ccontent = ctext / quoted-pair / comment =~ []!-'*-[^-~]|(\[\t -~]) (not regular) comment = "(" *([FWS] ccontent) [FWS] ")" (is equivalent to FWS when leaving out comments) CFWS = (1*([FWS] comment) [FWS]) / FWS =~ ([\t ]*\r\n)?[\t ]+ atext = ALPHA / DIGIT / "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "/" / "=" / "?" / "^" / "_" / "`" / "{" / "|" / "}" / "~" =~ [-!#-'*+/-9=?A-Z^-~] dot-atom-text = 1*atext *("." 1*atext) =~ [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)* dot-atom = [CFWS] dot-atom-text [CFWS] =~ (([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)? (normalized) =~ [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)* qtext = %d33 / %d35-91 / %d93-126 =~ []!#-[^-~] qcontent = qtext / quoted-pair =~ []!#-[^-~]|(\[\t -~]) (erratum) quoted-string = [CFWS] DQUOTE ((1*([FWS] qcontent) [FWS]) / FWS) DQUOTE [CFWS] =~ (([\t ]*\r\n)?[\t ]+)?"(((([\t ]*\r\n)?[\t ]+)?([]!#-[^-~]|(\[\t -~])))+(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?)"(([\t ]*\r\n)?[\t ]+)? (normalized) =~ "([]!#-[^-~ \t]|(\[\t -~]))+" dtext = %d33-90 / %d94-126 =~ [!-Z^-~] domain-literal = [CFWS] "[" *([FWS] dtext) [FWS] "]" [CFWS] =~ (([\t ]*\r\n)?[\t ]+)?\[((([\t ]*\r\n)?[\t ]+)?[!-Z^-~])*(([\t ]*\r\n)?[\t ]+)?](([\t ]*\r\n)?[\t ]+)? (normalized) =~ \[[\t -Z^-~]*] local-part = dot-atom / quoted-string =~ (([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?"(((([\t ]*\r\n)?[\t ]+)?([]!#-[^-~]|(\[\t -~])))+(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?)"(([\t ]*\r\n)?[\t ]+)? (normalized) =~ [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\[\t -~]))+" domain = dot-atom / domain-literal =~ (([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?\[((([\t ]*\r\n)?[\t ]+)?[!-Z^-~])*(([\t ]*\r\n)?[\t ]+)?](([\t ]*\r\n)?[\t ]+)? (normalized) =~ [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|\[[\t -Z^-~]*] addr-spec = local-part "@" domain =~ ((([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?"(((([\t ]*\r\n)?[\t ]+)?([]!#-[^-~]|(\[\t -~])))+(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?)"(([\t ]*\r\n)?[\t ]+)?)@((([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?\[((([\t ]*\r\n)?[\t ]+)?[!-Z^-~])*(([\t ]*\r\n)?[\t ]+)?](([\t ]*\r\n)?[\t ]+)?) (normalized) =~ ([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\[\t -~]))+")@([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|\[[\t -Z^-~]*])

Restrictions supplémentaires.

SMTP (tel que défini dans RFC 5321 ) restreint encore plus l'ensemble des adresses électroniques valides (ou en réalité: les noms de boîtes aux lettres). Il semble raisonnable d'imposer cette grammaire plus stricte, de sorte que l'adresse électronique correspondante puisse réellement être utilisée pour envoyer un courrier électronique.

La RFC 5321 laisse essentiellement la partie "locale" (c'est-à-dire la partie précédant le signe @), mais est plus stricte pour la partie domaine (c'est-à-dire la partie après le signe @). Il autorise uniquement les noms d'hôtes à la place des atomes de points et les littéraux d'adresse à la place des littéraux de domaine.

La grammaire présentée dans la RFC 5321 est trop indulgente en ce qui concerne les noms d'hôtes et les adresses IP. Je me suis permis de "corriger" les règles en question, en utilisant ce projet et RFC 1034 comme lignes directrices. Voici la regex résultante.

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\[\t -~]))+")@([0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)*|\[((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)|(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+)]).

Notez que, selon le cas d'utilisation, vous ne souhaiterez peut-être pas autoriser un "littéral d'adresse général" dans votre expression rationnelle. Notez également que j’ai utilisé un (?!IPv6:) avec lookahead négatif dans la regex finale pour empêcher la partie "General-address-literal" de correspondre aux adresses IPv6 mal formées. Certains processeurs de regex ne prennent pas en charge la prévision négative. Supprimez la sous-chaîne |(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+ de l'expression régulière si vous souhaitez supprimer la totalité de la partie "General-address-literal".

Voici la dérivation:.

Let-Dig = ALPHA / DIGIT =~ [0-9A-Za-z] Ldh-str = *( ALPHA / DIGIT / "-" ) Let-Dig =~ [0-9A-Za-z-]*[0-9A-Za-z] (regex is updated to make sure sub-domains are max. 63 charactes long - RFC 1034 section 3.5) sub-domain = Let-Dig [Ldh-str] =~ [0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])? Domain = sub-domain *("." sub-domain) =~ [0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)* Snum = 1*3DIGIT =~ [0-9]{1,3} (suggested replacement for "Snum") ip4-octet = DIGIT / %x31-39 DIGIT / "1" 2DIGIT / "2" %x30-34 DIGIT / "25" %x30-35 =~ 25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9] IPv4-address-literal = Snum 3("." Snum) =~ [0-9]{1,3}(\.[0-9]{1,3}){3} (suggested replacement for "IPv4-address-literal") ip4-address = ip4-octet 3("." ip4-octet) =~ (25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3} (suggested replacement for "IPv6-hex") ip6-h16 = "0" / ( (%x49-57 / %x65-70 /%x97-102) 0*3(%x48-57 / %x65-70 /%x97-102) ) =~ 0|[1-9A-Fa-f][0-9A-Fa-f]{0,3} (not from RFC) ls32 = ip6-h16 ":" ip6-h16 / ip4-address =~ (0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3} (suggested replacement of "IPv6-addr") ip6-address = 6(ip6-h16 ":") ls32 / "::" 5(ip6-h16 ":") ls32 / [ ip6-h16 ] "::" 4(ip6-h16 ":") ls32 / [ *1(ip6-h16 ":") ip6-h16 ] "::" 3(ip6-h16 ":") ls32 / [ *2(ip6-h16 ":") ip6-h16 ] "::" 2(ip6-h16 ":") ls32 / [ *3(ip6-h16 ":") ip6-h16 ] "::" ip6-h16 ":" ls32 / [ *4(ip6-h16 ":") ip6-h16 ] "::" ls32 / [ *5(ip6-h16 ":") ip6-h16 ] "::" ip6-h16 / [ *6(ip6-h16 ":") ip6-h16 ] "::" =~ (((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?:: IPv6-address-literal = "IPv6:" ip6-address =~ IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::) Standardized-tag = Ldh-str =~ [0-9A-Za-z-]*[0-9A-Za-z] dcontent = %d33-90 / %d94-126 =~ [!-Z^-~] General-address-literal = Standardized-tag ":" 1*dcontent =~ [0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+ address-literal = "[" ( IPv4-address-literal / IPv6-address-literal / General-address-literal ) "]" =~ \[((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)|(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+)] Mailbox = Local-part "@" ( Domain / address-literal ) =~ ([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\[\t -~]))+")@([0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)*|\[((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)|(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+)])

Un cas d'utilisation courant est la validation des entrées utilisateur, par exemple sur un formulaire HTML. Dans ce cas, il est généralement raisonnable d'empêcher les littéraux d'adresse et d'exiger au moins deux étiquettes dans le nom d'hôte. En prenant comme base la regex RFC 5321 améliorée de la section précédente, l'expression résultante serait:

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\[\t -~]))+")@[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)+

Je ne recommande pas de restreindre davantage la partie locale, par exemple. en excluant les chaînes entre guillemets, car nous ne savons pas quel type de nom de boîte aux lettres est autorisé par certains hôtes (comme "a..b"@example.net ou même "a b"@example.net).

Je ne recommande pas non plus de valider explicitement une liste de domaines de premier niveau littéraux ni même d'imposer des contraintes de longueur (rappelez-vous comment ".museum" a invalidé [a-z]{2,4}), mais si vous devez:.

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\[\t -~]))+")@([0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?\.)*(net|org|com|info|etc ... )

Assurez-vous de garder votre regex à jour si vous décidez de vous engager sur la voie de la validation de domaine de premier niveau explicite.

Autres considérations.

Lorsque vous n'acceptez que les noms d'hôte dans la partie de domaine (après le signe @), les expressions rationnelles ci-dessus acceptent uniquement les étiquettes comportant au plus 63 caractères, comme elles le devraient. Cependant, ils n'imposent pas le fait que le nom d'hôte complet doit comporter au maximum 253 caractères (points compris). Bien que cette contrainte soit à proprement parler encore régulière, il n’est pas possible de créer une expression régulière qui intègre cette règle.

Une autre considération, en particulier lors de l'utilisation des expressions rationnelles pour la validation des entrées, est le retour d'informations à l'utilisateur. Si un utilisateur entre une adresse incorrecte, il serait agréable de donner un peu plus de retour qu'une simple "adresse syntaxiquement incorrecte". Avec les regex "Vanilla", ce n'est pas possible.

Ces deux considérations pourraient être résolues en analysant l'adresse. La contrainte de longueur supplémentaire sur les noms d'hôte pourrait dans certains cas également être traitée en utilisant une expression rationnelle supplémentaire qui la vérifie, et en comparant l'adresse aux deux expressions.

Aucune des expressions rationnelles dans cette réponse n'est optimisée pour la performance. Si les performances sont un problème, vous devriez voir si (et comment) la regex de votre choix peut être optimisée.

None of the regexes in this answer are optimized for performance. If performance is an issue, you should see if (and how) the regex of your choice can be optimized.

Draemon · Answer

Il existe de nombreux exemples de cela sur le net (et je pense même un qui valide complètement le RFC - mais il a des dizaines/centaines de lignes de long si la mémoire est insuffisante). Les gens ont tendance à s'emballer pour valider ce genre de chose. Pourquoi ne pas simplement vérifier qu'il a un @ et au moins un. et respecte une longueur minimale simple. Il est trivial d'entrer un faux email et de faire correspondre une expression rationnelle valide de toute façon. Je suppose que les faux positifs sont meilleurs que les faux négatifs.

Evan Carroll · Answer

Cette expression rationnelle provient de Email :: Valid library de Perl. Je pense que c'est le plus précis, il correspond à tous les 822. Et il est basé sur l'expression régulière dans le livre O'Reilly:

Expression régulière construite à l'aide de l'exemple de Jeffrey Friedl dans Maîtriser les expressions régulières ( http://www.ora.com/catalog/regexp/ ).

$RFC822PAT = <<'EOF'; [\040\t]*(?:$[^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\ xff\n\015()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015()]*)*$)[^\\x80-\xf f\n\015()]*)*\)[\040\t]*)*(?:(?:[^(\040)<>@,;:".\\000-\037\x80-\x ff]+(?![^(\040)<>@,;:".\\000-\037\x80-\xff])|"[^\\x80-\xff\n\015 "]*(?:$$^\x80-\xff][^\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\x80-\ xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80 -\xff][^\\x80-\xff\n\015()]*)*\))[^\\x80-\xff\n\015()]*)*\)[\040\t]* )*(?:\.[\040\t]*(?:\([^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\ \x80-\xff\n\015()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015()]*)*\))[^\\ x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\[$$\000-\037\x8 0-\xff]+(?![^(\040)<>@,;:".\\000-\037\x80-\xff])|"[^\\x80-\xff\n \015"]*(?:$$^\x80-\xff][^\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\x 80-\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^ \x80-\xff][^\\x80-\xff\n\015()]*)*\))[^\\x80-\xff\n\015()]*)*\)[\040 \t]*)*)*@[\040\t]*(?:\([^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([ ^\\x80-\xff\n\015()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015()]*)*\))[^\ \x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\[$$\000-\037\ x80-\xff]+(?![^(\040)<>@,;:".\\000-\037\x80-\xff])|$$(?:[^\\x80- \xff\n\015\[$$]|$$^\x80-\xff])*$$)[\040\t]*(?:$[^\\x80-\xff\n\015() ]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80-\xff][^\\ x80-\xff\n\015()]*)*$)[^\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\04 0\t]*(?:$[^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\ n\015()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015()]*)*$)[^\\x80-\xff\n\ 015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\000-\037\x80-\xff]+(?! [^(\040)<>@,;:".\\000-\037\x80-\xff])|$$(?:[^\\x80-\xff\n\015\[\ ]]|\[^\x80-\xff])*$$)[\040\t]*(?:$[^\\x80-\xff\n\015()]*(?:(?:\[^\ x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80-\xff][^\\x80-\xff\n\01 5()]*)*$)[^\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*|(?:[^(\040)<>@,;:". \\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\000-\037\x80-\xff] )|"[^\\x80-\xff\n\015"]*(?:$$^\x80-\xff][^\\x80-\xff\n\015"]*)*")[^ ()<>@,;:".\\[$$\x80-\xff\000-\010\012-\037]*(?:(?:$[^\\x80-\xff\n\0 15()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80-\xff][ ^\\x80-\xff\n\015()]*)*$)[^\\x80-\xff\n\015()]*)*\)|"[^\\x80-\xff\ n\015"]*(?:$$^\x80-\xff][^\\x80-\xff\n\015"]*)*")[^()<>@,;:".\\[$$\ x80-\xff\000-\010\012-\037]*)*<[\040\t]*(?:$[^\\x80-\xff\n\015()]*(? :(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80-\xff][^\\x80- \xff\n\015()]*)*$)[^\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:@[\040\t]* (?:$[^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015 ()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015()]*)*$)[^\\x80-\xff\n\015() ]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\000-\037\x80-\xff]+(?![^(\0 40)<>@,;:".\\000-\037\x80-\xff])|$$(?:[^\\x80-\xff\n\015\[$$]|\ [^\x80-\xff])*\])[\040\t]*(?:$[^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\ xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015()]* )*$)[^\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:$[^\\x80 -\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x 80-\xff][^\\x80-\xff\n\015()]*)*$)[^\\x80-\xff\n\015()]*)*\)[\040\t ]*)*(?:[^(\040)<>@,;:".\\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\ \000-\037\x80-\xff])|$$(?:[^\\x80-\xff\n\015\[$$]|$$^\x80-\xff]) *$$)[\040\t]*(?:$[^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x 80-\xff\n\015()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015()]*)*$)[^\\x80 -\xff\n\015()]*)*\)[\040\t]*)*)*(?:,[\040\t]*(?:$[^\\x80-\xff\n\015( )]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80-\xff][^\ \x80-\xff\n\015()]*)*$)[^\\x80-\xff\n\015()]*)*\)[\040\t]*)*@[\040\t ]*(?:$[^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\0 15()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015()]*)*$)[^\\x80-\xff\n\015 ()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\000-\037\x80-\xff]+(?![^( \040)<>@,;:".\\000-\037\x80-\xff])|$$(?:[^\\x80-\xff\n\015\[$$]| $$^\x80-\xff])*$$)[\040\t]*(?:$[^\\x80-\xff\n\015()]*(?:(?:\[^\x80 -\xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015() ]*)*$)[^\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:$[^\\x 80-\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^ \x80-\xff][^\\x80-\xff\n\015()]*)*$)[^\\x80-\xff\n\015()]*)*\)[\040 \t]*)*(?:[^(\040)<>@,;:".\\000-\037\x80-\xff]+(?![^(\040)<>@,;:". \\000-\037\x80-\xff])|$$(?:[^\\x80-\xff\n\015\[$$]|$$^\x80-\xff ])*$$)[\040\t]*(?:$[^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\ \x80-\xff\n\015()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015()]*)*$)[^\\x 80-\xff\n\015()]*)*\)[\040\t]*)*)*)*:[\040\t]*(?:$[^\\x80-\xff\n\015 ()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80-\xff][^\ \x80-\xff\n\015()]*)*$)[^\\x80-\xff\n\015()]*)*\)[\040\t]*)*)?(?:[^ (\040)<>@,;:".\\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\000- \037\x80-\xff])|"[^\\x80-\xff\n\015"]*(?:$$^\x80-\xff][^\\x80-\xff\ n\015"]*)*")[\040\t]*(?:\([^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\xff]| \([^\\x80-\xff\n\015()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015()]*)*\)) [^\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\x80-\xff \n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80-\x ff][^\\x80-\xff\n\015()]*)*\))[^\\x80-\xff\n\015()]*)*\)[\040\t]*)*( ?:[^(\040)<>@,;:".\\[$$\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\ 000-\037\x80-\xff])|"[^\\x80-\xff\n\015"]*(?:$$^\x80-\xff][^\\x80-\ xff\n\015"]*)*")[\040\t]*(?:\([^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\x ff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015()]*) *\))[^\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*@[\040\t]*(?:\([^\\x80-\x ff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80- \xff][^\\x80-\xff\n\015()]*)*\))[^\\x80-\xff\n\015()]*)*\)[\040\t]*) *(?:[^(\040)<>@,;:".\\[$$\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\$$\ ]\000-\037\x80-\xff])|\[(?:[^\\x80-\xff\n\015\[$$]|$$^\x80-\xff])*$$ )[\040\t]*(?:$[^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x80- \xff\n\015()]*(?:\[^\x80-\xff][^\\x80-\xff\n\015()]*)*$)[^\\x80-\x ff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:$[^\\x80-\xff\n\015()]*( ?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()]*(?:\[^\x80-\xff][^\\x80 -\xff\n\015()]*)*$)[^\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)< >@,;:".\\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\000-\037\x8 0-\xff])|$$(?:[^\\x80-\xff\n\015\[$$]|$$^\x80-\xff])*$$)[\040\t]*(?: $[^\\x80-\xff\n\015()]*(?:(?:\[^\x80-\xff]|\([^\\x80-\xff\n\015()] *(?:\[^\x80-\xff][^\\x80-\xff\n\015()]*)*$)[^\\x80-\xff\n\015()]*) *\)[\040\t]*)*)*>) EOF

DOK · Answer

Lorsque vous décidez quels personnages sont autorisés, souvenez-vous de vos amis apostrophés et à trait d'union. Je n'ai aucun contrôle sur le fait que mon entreprise génère mon adresse e-mail en utilisant mon nom depuis le système HR. Cela inclut l'apostrophe dans mon nom de famille. Je ne peux pas vous dire combien de fois j'ai été empêché d'interagir avec un site Web en raison du fait que mon adresse électronique est "invalide".

SimonSimCity · Answer

Pendant que vous écrivez dans PHP, je vous conseillerais d'utiliser la validation intégrée de PHP pour les courriels.

filter_var($value, FILTER_VALIDATE_EMAIL)

Si vous utilisez une version php inférieure à 5.3.6, tenez compte de ce problème: https://bugs.php.net/bug.php?id=53091

Si vous souhaitez plus d'informations sur le fonctionnement de cette validation intégrée, voir ici: La variable filter_var de PHP, FILTER_VALIDATE_EMAIL, fonctionne-t-elle réellement?

adnam · Answer

Cal Henderson (Flickr) a écrit un article intitulé Analyse des adresses électroniques dans PHP et explique comment analyser correctement les adresses électroniques conformes à la norme RFC (2) 822. Vous pouvez également obtenir le code source dans php , python et Ruby qui est cc sous licence .

Kon · Answer

Je n'ai jamais pris la peine de créer avec ma propre expression régulière, car il est probable que quelqu'un d'autre a déjà mis au point une meilleure version. J'utilise toujours regexlib pour en trouver un à mon goût.

PhiLho · Answer

Il n'y en a pas qui soit vraiment utilisable.
Je discute de certains problèmes dans ma réponse à Existe-t-il une bibliothèque php pour la validation des adresses e-mail? , il est également discuté dans Regexp la reconnaissance de l’adresse électronique est-elle difficile?

En bref, ne vous attendez pas à ce qu'une seule expression rationnelle utilisable fasse un travail correct. Et la meilleure expression rationnelle validera la syntaxe, pas la validité d'un e-mail (jhohn@example.com est correct mais il rebondira probablement ...).

spig · Answer

Une expression régulière simple qui au moins ne rejetterait aucune adresse électronique valide consisterait à rechercher quelque chose, suivie d'un signe @, puis de quelque chose suivie d'un point et d'au moins 2 ans. Il ne rejettera rien, mais après avoir examiné les spécifications, je ne trouve aucun courrier électronique qui serait valide et rejeté.

email = ~ /.+@[^@]+\.[^@]{2,}$/

chaos · Answer

Vous pouvez utiliser celui employé par le plugin jQuery Validation:

/^((([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])))\.?$/i

Eric Schoonover · Answer

Pour l'évaluation la plus complète possible de la meilleure expression régulière permettant de valider une adresse électronique, veuillez consulter ce lien. " Comparaison d'adresse de messagerie en validant des expressions régulières "

Voici la principale expression courante à des fins de référence:

/^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+[a-z]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$/i

BalusC · Answer

Sans oublier que les noms de domaine non latins (chinois, arabe, grec, hébreu, cyrillique, etc.) doivent être autorisés dans les proche avenir . Tout le monde doit changer l'adresse e-mail utilisée, car ces caractères ne doivent sûrement pas être couverts par [a-z]/i ni \w. Ils vont tous échouer.

Après tout, le moyen best de valider l'adresse e-mail consiste toujours à envoyer un e-mail à l'adresse en question pour valider l'adresse. Si l'adresse e-mail fait partie de l'authentification de l'utilisateur (enregistrement/connexion/etc), vous pouvez parfaitement la combiner avec le système d'activation de l'utilisateur. C'est à dire. envoyer un email avec un lien avec une clé d'activation unique à l'adresse email spécifiée et n'autoriser la connexion que lorsque l'utilisateur a activé le compte nouvellement créé à l'aide du lien contenu dans l'email.

Si l'objectif de l'expression régulière est simplement d'informer rapidement l'utilisateur dans l'interface utilisateur que l'adresse électronique spécifiée ne ressemble pas au bon format, il est préférable de vérifier si elle correspond fondamentalement à l'expression régulière suivante:

^([^.@]+)(\.[^.@]+)*@([^.@]+\.)+([^.@]+)$

Aussi simple que cela. Pourquoi diable voudriez-vous vous soucier des caractères utilisés dans le nom et le domaine? Il incombe au client de saisir une adresse électronique valide, pas celle du serveur. Même lorsque le client entre une adresse e-mail valide comme syntaxiquement comme aa@bb.cc, cela ne garantit pas qu’il s’agit bien d’une adresse e-mail légitime. Aucun regex ne peut couvrir cela.

Luna · Answer

La spécification HTML5 suggère une expression rationnelle simple pour valider les adresses électroniques:

/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/

Cela ne respecte pas intentionnellement RFC 5322 .

Remarque: Cette exigence est une violation volontaire de RFC 5322 , qui définit une syntaxe pour les adresses électroniques à la fois trop stricte (avant le caractère @), trop vague (après le @ caractère), et trop laxiste (permettant à des commentaires, des caractères d'espacement et des chaînes citées de manières inconnues de la plupart des utilisateurs) d'être d'une utilisation pratique ici.

La longueur totale pourrait également être limitée à 254 caractères, par RFC 3696, errata 1690 .

Greg Bacon · Answer

Pour une démonstration éclatante, le monstre suivant est assez bon mais ne reconnaît toujours pas correctement toutes les adresses électroniques valides du point de vue de la syntaxe: il reconnaît les commentaires imbriqués allant jusqu'à quatre niveaux.

Il s’agit d’un travail pour un analyseur, mais même si une adresse est syntaxiquement valide, il se peut qu’elle ne soit pas livrable. Parfois, vous devez recourir à la méthode hillbilly de "Hey, vous tous, regardez-nous!"

// derivative of work with the following copyright and license: // Copyright (c) 2004 Casey West. All rights reserved. // This module is free software; you can redistribute it and/or // modify it under the same terms as Perl itself. // see http://search.cpan.org/~cwest/Email-Address-1.80/ private static string gibberish = @" (?-xism:(?:(?-xism:(?-xism:(?-xism:(?-xism:(?-xism:(?-xism:\ s*$(?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^ \x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\]+)) |(?-xism:\(?-xism:[^\x0A\x0D]))|)+)*\s*$\s*))+)*\s*\)\s*)+ |\s+)*[^\x00-\x1F\x7F()<>:;@\,.<DQ>\s]+(?-xism:(?-xism:\ s*$(?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^ \x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\]+)) |(?-xism:\(?-xism:[^\x0A\x0D]))|)+)*\s*$\s*))+)*\s*\)\s*)+ |\s+)*)|(?-xism:(?-xism:(?-xism:\s*$(?:\s*(?-xism:(?-xism:( ?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((? :\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x 0D]))|)+)*\s*$\s*))+)*\s*\)\s*)+|\s+)*<DQ>(?-xism:(?-xism:[ ^\<DQ>])|(?-xism:$?-xism:[^\x0A\x0D])))+<DQ>(?-xism:(?-xi sm:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xis m:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\ ]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|)+)*\s*$\s*))+)*\s*\)\ s*)+|\s+)*))+)?(?-xism:(?-xism:(?-xism:\s*$(?:\s*(?-xism:(? -xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|(?-xism: \s*\((?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[ ^\x0A\x0D]))|)+)*\s*$\s*))+)*\s*\)\s*)+|\s+)*<(?-xism:(?-xi sm:(?-xism:(?-xism:(?-xism:\s*$(?:\s*(?-xism:(?-xism:(?>[^( )\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*( ?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D])) |)+)*\s*$\s*))+)*\s*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()< >:;@\,.<DQ>\s]+(?:\.[^\x00-\x1F\x7F()<>:;@\,.<DQ>\s] +)*)(?-xism:(?-xism:\s*$(?:\s*(?-xism:(?-xism:(?>[^()\]+)) |(?-xism:\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism: (?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|)+)*\s *$\s*))+)*\s*\)\s*)+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*$(? :\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x 0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xi sm:\(?-xism:[^\x0A\x0D]))|)+)*\s*$\s*))+)*\s*\)\s*)+|\s+)* <DQ>(?-xism:(?-xism:[^\<DQ>])|(?-xism:$?-xism:[^\x0A\x0D] )))+<DQ>(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\ ]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-x ism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|)+ )*\s*$\s*))+)*\s*\)\s*)+|\s+)*))\@(?-xism:(?-xism:(?-xism:( ?-xism:\s*$(?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(? -xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^ ()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|)+)*\s*$\s*))+)*\s *\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()<>:;@\,.<DQ>\s]+( ?:\.[^\x00-\x1F\x7F()<>:;@\,.<DQ>\s]+)*)(?-xism:(?-xism: \s*$(?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[ ^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\]+) )|(?-xism:\(?-xism:[^\x0A\x0D]))|)+)*\s*$\s*))+)*\s*\)\s*) +|\s+)*)|(?-xism:(?-xism:(?-xism:\s*$(?:\s*(?-xism:(?-xism: (?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\(( ?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\ x0D]))|)+)*\s*$\s*))+)*\s*\)\s*)+|\s+)*$$(?:\s*(?-xism:(?-x ism:[^\[$$\])|(?-xism:$?-xism:[^\x0A\x0D])))+)*\s*\](?-xi sm:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism: \(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:( ?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|)+)*\s*$\s*))+ )*\s*\)\s*)+|\s+)*)))>(?-xism:(?-xism:\s*$(?:\s*(?-xism:(?- xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|(?-xism:\ s*\((?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^ \x0A\x0D]))|)+)*\s*$\s*))+)*\s*\)\s*)+|\s+)*))|(?-xism:(?-x ism:(?-xism:(?-xism:(?-xism:\s*$(?:\s*(?-xism:(?-xism:(?>[^ ()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s* (?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]) )|)+)*\s*$\s*))+)*\s*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F() <>:;@\,.<DQ>\s]+(?:\.[^\x00-\x1F\x7F()<>:;@\,.<DQ>\s ]+)*)(?-xism:(?-xism:\s*$(?:\s*(?-xism:(?-xism:(?>[^()\]+) )|(?-xism:\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism :(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|)+)*\ s*$\s*))+)*\s*\)\s*)+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*$( ?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\ x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-x ism:\(?-xism:[^\x0A\x0D]))|)+)*\s*$\s*))+)*\s*\)\s*)+|\s+) *<DQ>(?-xism:(?-xism:[^\<DQ>])|(?-xism:$?-xism:[^\x0A\x0D ])))+<DQ>(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\ \]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?- xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|) +)*\s*$\s*))+)*\s*\)\s*)+|\s+)*))\@(?-xism:(?-xism:(?-xism: (?-xism:\s*$(?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\( ?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[ ^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|)+)*\s*$\s*))+)*\ s*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()<>:;@\,.<DQ>\s]+ (?:\.[^\x00-\x1F\x7F()<>:;@\,.<DQ>\s]+)*)(?-xism:(?-xism :\s*$(?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism: [^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\]+ ))|(?-xism:\(?-xism:[^\x0A\x0D]))|)+)*\s*$\s*))+)*\s*\)\s* )+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*$(?:\s*(?-xism:(?-xism :(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\( (?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A \x0D]))|)+)*\s*$\s*))+)*\s*\)\s*)+|\s+)*$$(?:\s*(?-xism:(?- xism:[^\[$$\])|(?-xism:$?-xism:[^\x0A\x0D])))+)*\s*\](?-x ism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism :\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism: (?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|)+)*\s*$\s*)) +)*\s*\)\s*)+|\s+)*))))(?-xism:\s*$(?:\s*(?-xism:(?-xism:(? >[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?: \s*(?-xism:(?-xism:(?>[^()\]+))|(?-xism:\(?-xism:[^\x0A\x0 D]))|)+)*\s*$\s*))+)*\s*\)\s*)*)" .Replace("<DQ>", "\"") .Replace("\t", "") .Replace(" ", "") .Replace("\r", "") .Replace("\n", ""); private static Regex mailbox = new Regex(gibberish, RegexOptions.ExplicitCapture);

Mac · Answer

Voici le PHP que j'utilise. J'ai choisi cette solution dans un esprit "les faux positifs valent mieux que les faux négatifs", comme l'a déclaré un autre intervenant ici ET en ce qui concerne le maintien du temps de réponse et la surcharge du serveur ... inutile de gaspiller les ressources du serveur avec une expression régulière lorsque cela éliminera l'erreur utilisateur la plus simple. Vous pouvez toujours suivre cela en envoyant un email de test si vous le souhaitez.

function validateEmail($email) { return (bool) stripos($email,'@'); }

AZ_ · Answer

Selon la norme officielle RFC 2822 regex email valide est

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|$$\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?: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]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\[\x01-\x09\x0b\x0c\x0e-\x7f])+)$$)

si vous voulez l'utiliser en Java c'est vraiment très facile

import Java.util.regex.*; class regexSample { public static void main(String args[]) { //Input the string for validation String email = "xyz@hotmail.com"; //Set the email pattern string Pattern p = Pattern.compile(" (?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|" +"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|$$\x01-\x09\x0b\x0c\x0e-\x7f])*\")" + "@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?: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]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\[\x01-\x09\x0b\x0c\x0e-\x7f])+)$$"); //Match the given string with the pattern Matcher m = p.matcher(email); //check whether match is found boolean matchFound = m.matches(); if (matchFound) System.out.println("Valid Email Id."); else System.out.println("Invalid Email Id."); } }

MichaelRushton · Answer

Norme RFC 5322:

Autorise la partie locale, la partie locale, la partie locale, la chaîne locale, la chaîne localisée-atome, obsolète (mélange de points et de chaînes), le domaine de nom de domaine, (littéralement, IPv4, IPv6 et l'adresse IPv6 mappée IPv4), et CFWS (imbriqué).

'/^(?!(?>(?1)"?(?>\$$ -~]|[^"])"?(?1)){255,})(?!(?>(?1)"?(?>\\[ -~]|[^"])"?(?1)){65,}@)((?>(?>(?>((?>(?>(?>\x0D\x0A)?[\t ])+|(?>[\t ]*\x0D\x0A)?[\t ]+)?)(\((?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-\'*-\[$$-\x7F]|\$$\x00-\x7F]|(?3)))*(?2)\)))+(?2))|(?2))?)([!#-\'*+/-9=?^-~-]+|"(?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-!#-\[$$-\x7F]|\$$\x00-\x7F]))*(?2)")(?>(?1)\.(?1)(?4))*(?1)@(?!(?1)[a-z0-9-]{64,})(?1)(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)(?>(?1)\.(?!(?1)[a-z0-9-]{64,})(?1)(?5)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?6)){7}|(?!(?:.*[a-f0-9][:$$]){8,})((?6)(?>:(?6)){0,6})?::(?7)?))|(?>(?>IPv6:(?>(?6)(?>:(?6)){5}:|(?!(?:.*[a-f0-9]:){6,})(?8)?::(?>((?6)(?>:(?6)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?>\.(?9)){3}))\])(?1)$/isD'

RFC 5321 standard:

Autorise le domaine littéral de domaine de la partie locale, de la chaîne citée, du nom de domaine et des adresses (IPv4, IPv6 et IPv4 mappées IPv6).

'/^(?!(?>"?(?>\$$ -~]|[^"])"?){255,})(?!"?(?>\\[ -~]|[^"]){65,}"?@)(?>([!#-\'*+/-9=?^-~-]+)(?>\.(?1))*|"(?>[ !#-\[$$-~]|\$$ -~])*")@(?!.*[^.]{64,})(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)(?>\.(?2)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?3)){7}|(?!(?:.*[a-f0-9][:$$]){8,})((?3)(?>:(?3)){0,6})?::(?4)?))|(?>(?>IPv6:(?>(?3)(?>:(?3)){5}:|(?!(?:.*[a-f0-9]:){6,})(?5)?::(?>((?3)(?>:(?3)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?>\.(?6)){3}))\])$/iD'

De base:

Autorise le domaine de la partie locale et du nom de domaine à points atomiques (nécessitant au moins deux étiquettes de nom de domaine, le TLD étant limité à 2 à 6 caractères alphabétiques).

"/^(?!.{255,})(?!.{65,}@)([!#-'*+/-9=?^-~-]+)(?>\.(?1))*@(?!.*[^.]{64,})(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?\.){1,126}[a-z]{2,6}$/iD"

Murthy Jeedigunta · Answer

public bool ValidateEmail(string sEmail) { if (sEmail == null) { return false; } int nFirstAT = sEmail.IndexOf('@'); int nLastAT = sEmail.LastIndexOf('@'); if ((nFirstAT > 0) && (nLastAT == nFirstAT) && (nFirstAT < (sEmail.Length - 1))) { return (Regex.IsMatch(sEmail, @"^[a-z|0-9|A-Z]*([_][a-z|0-9|A-Z]+)*([.][a-z|0-9|A-Z]+)*([.][a-z|0-9|A-Z]+)*(([_][a-z|0-9|A-Z]+)*)?@[a-z][a-z|0-9|A-Z]*\.([a-z][a-z|0-9|A-Z]*(\.[a-z][a-z|0-9|A-Z]*)?)$")); } else { return false; } }

Joseph Yee · Answer

Étrange que vous "ne puissiez" pas autoriser les TLD à 4 caractères. Vous interdisez aux personnes de .info et .name , et la limitation de la longueur s'arrête .travel et .museum , mais oui, elles sont moins courantes que les caractères TLD TLD à 3 caractères.

Vous devez également autoriser les alphabets majuscules. Les systèmes de messagerie normaliseront la partie locale et la partie de domaine.

Pour votre regex de partie de domaine, le nom de domaine ne peut pas commencer par "-" et ne peut pas se terminer par "-". Dash ne peut rester qu'entre.

Si vous avez utilisé la bibliothèque PEAR, vérifiez leur fonction de messagerie (vous avez oublié le nom/la bibliothèque exacts). Vous pouvez valider une adresse électronique en appelant une fonction, qui la valide conformément à la définition de la RFC822.

Prasad · Answer

Si vous acceptez les valeurs vides (qui ne sont pas des emails incorrects) et que vous utilisez PHP 5.2+, je vous suggérerais:

static public function checkEmail($email, $ignore_empty = false) { if($ignore_empty && (is_null($email) || $email == '')) return true; return filter_var($email, FILTER_VALIDATE_EMAIL); }

TombMedia · Answer

Cela fait un moment que j'utilise cette version retouchée de votre regex et cela ne m'a pas laissé trop de surprises. ~~Je n'ai encore jamais rencontré d'apostrophe dans un courrier électronique, de sorte qu'il ne valide pas~~. Il valide les Jean+François@anydomain.museum et 试@例子.测试.مثال.آزمایشی mais n'abuse pas étrangement de ces caractères non alphanumériques .+@you.com.

(?!^[.+&'_-]*@.*$)(^[_\w\d+&'-]+(\.[_\w\d+&'-]*)*@[\w\d-]+(\.[\w\d-]+)*\.(([\d]{1,3})|([\w]{2,}))$)

Il prend en charge les adresses IP you@192.168.1.1 mais je ne l’ai pas encore suffisamment affiné pour traiter des plages IP erronées telles que 999.999.999.1.

~~Il prend également en charge tous les TLD de plus de 3 caractères, ce qui stoppe asdf@asdf.asdf, ce qui, je pense, laisse passer.~~ J'ai été battu, il y a trop de tlds sur 3 personnages.

Je sais qu'acrosman a abandonné sa regex mais cette saveur perdure.

auco · Answer

Je sais que cette question concerne RegEx, mais je suppose que 90% des développeurs qui lisent ces solutions tentent de valider une adresse électronique dans un formulaire HTML affiché dans un navigateur.

Si tel est le cas, je vous conseillerais de vérifier le nouvel élément de formulaire HTML5 <input type="email">:

HTML5:

 <input type="email" required />

CSS3:

 input:required { background-color: rgba(255,0,0,0.2); } input:focus:invalid { box-shadow: 0 0 1em red; border-color: red; } input:focus:valid { box-shadow: 0 0 1em green; border-color: green; }

http://jsfiddle.net/mYRe7/1

Cela présente quelques avantages:

Validation automatique, aucune solution personnalisée requise: simple et facile à mettre en œuvre
Pas de JavaScript, pas de problème si JS a été désactivé
Aucun serveur n'a à calculer quoi que ce soit pour cela
L'utilisateur a un retour immédiat
Ancien navigateur devrait automatiquement revenir au type de saisie "texte"
Les navigateurs mobiles peuvent afficher un clavier spécialisé (@ -Keyboard)
Les commentaires de validation de formulaire sont très faciles avec CSS3

L'inconvénient apparent est peut-être l'absence de validation pour les anciens navigateurs, mais cela changera avec le temps. Je préférerais cela à n'importe lequel de ces chefs-d'œuvre insensés de RegEx.

regarde aussi:

Suhaib Janjua · Answer

J'utilise toujours l'expression régulière ci-dessous pour valider l'adresse e-mail. C'est la meilleure regex que j'ai jamais vue pour valider une adresse email.

"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z";

Cette expression régulière que j'utilise toujours dans mon code Asp.NET et j'en suis assez satisfaite.

utiliser cette référence d'assemblage

using System.Text.RegularExpressions;

et essayez le code suivant, car il est simple et faites le travail pour vous.

private bool IsValidEmail(string email) { bool isValid = false; const string pattern = @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z"; isValid = email != "" && Regex.IsMatch(email, pattern); // an alternative of the above line is also given and commented // //if (email == "") { // isValid = false; //} else { // // address provided so use the IsMatch Method // // of the Regular Expression object // isValid = Regex.IsMatch(email, pattern); //} return isValid; }

cette fonction valide la chaîne de courrier électronique. Si la chaîne de courrier électronique est null, elle renvoie false, si elle n'est pas au format correct, elle renvoie false Il ne renvoie vrai que si le format de l'email est valide.

Simon_Weaver · Answer

À peu près tous les RegEx que j'ai vus - y compris certains utilisés par Microsoft - ne permettront pas aux courriels valides email suivants: simon-@hotmail.com

Je viens d'avoir un vrai client avec une adresse email dans ce format qui ne pouvait pas passer de commande.

Voici ce sur quoi je me suis installé:

Un regex minimal qui n'aura pas de faux négatifs. Vous pouvez également utiliser le constructeur MailAddress avec quelques vérifications supplémentaires (voir ci-dessous):
Vérification des fautes de frappe courantes .cmo ou .gmial.com et demande de confirmation Are you sure this is your correct email address. It looks like there may be a mistake. Permet à l'utilisateur d'accepter ce qu'il a tapé s'il est sûr.
Traiter les rebonds lorsque le courrier est effectivement envoyé et les vérifier manuellement pour vérifier les erreurs évidentes.

 try { var email = new MailAddress(str); if (email.Host.EndsWith(".cmo")) { return EmailValidation.PossibleTypo; } if (!email.Host.EndsWith(".") && email.Host.Contains(".")) { return EmailValidation.OK; } } catch { return EmailValidation.Invalid; }

Nazmul Hasan · Answer

c'est l'un des regex pour l'email

^((([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])))\.?$

Dimitris Andreou · Answer

Je ne crois pas que l'affirmation faite par bortzmeyer, ci-dessus, selon laquelle "la grammaire (spécifiée dans le RFC 5322) est trop compliquée pour cela" (doit être traitée par une expression régulière).

Voici la grammaire: (from http://tools.ietf.org/html/rfc5322#section-3.4.1 )

addr-spec = local-part "@" domain local-part = dot-atom / quoted-string / obs-local-part domain = dot-atom / domain-literal / obs-domain domain-literal = [CFWS] "[" *([FWS] dtext) [FWS] "]" [CFWS] dtext = %d33-90 / ; Printable US-ASCII %d94-126 / ; characters not including obs-dtext ; "[", "]", or "\"

En supposant que les points, les chaînes de guillemets, les parties de local et de domaine obs sont des langages normaux, il s’agit d’une grammaire très simple. Il vous suffit de remplacer la partie locale et le domaine de la production addr-spec par leurs productions respectives. Vous disposez ainsi d'un langage standard directement traduisible en expression régulière.

Coder12345 · Answer

J'utilise la validation en plusieurs étapes. Comme il n’existe pas de moyen idéal pour valider une adresse électronique, il est impossible de la créer. Cependant, vous pouvez au moins informer l’utilisateur que celui-ci fait quelque chose de mal. Voici mon approche.

1) Je valide d’abord avec la regex très basique qui vérifie si le courrier électronique contient exactement un signe @ et qu’il n’est pas vide avant ou après ce signe. par exemple. /^[^@\s]+@[^@\s]+$/

2a) si le premier validateur ne passe pas (et pour la plupart des adresses il devrait l'être bien que ce ne soit pas parfait), avertissez alors l'utilisateur que l'email est invalide et ne lui permettent pas de continuer l'entrée

2b) s'il passe, alors validez-le avec une expression rationnelle plus stricte - ce qui pourrait interdire les courriels valides. S'il ne réussit pas, l'utilisateur est averti d'une erreur possible mais est autorisé à continuer. Contrairement à l'étape (1) où l'utilisateur n'est pas autorisé à continuer car c'est une erreur évidente.

En d'autres termes, la première validation libérale consiste simplement à supprimer les erreurs évidentes et à la traiter comme une "erreur". Les gens tapent une adresse vide, une adresse sans le signe @, etc. Cela devrait être traité comme une erreur. La seconde est plus stricte mais traitée comme un "avertissement" et l'utilisateur est autorisé à continuer l'entrée mais averti de vérifier au moins s'il a saisi une entrée valide. La clé ici est dans l'approche erreur/avertissement - l'erreur étant quelque chose qui ne peut pas être un email valide dans 99% des cas.

Bien entendu, vous pouvez ajuster ce qui rend une première expression rationnelle plus libérale et une seconde plus stricte.

En fonction de vos besoins, l’approche ci-dessus peut vous convenir.

Mohit Gupta · Answer

AS par ma compréhension la plus probable couvrira par ..

/^([a-z0-9_-]+)(@[a-z0-9-]+)(\.[a-z]+|\.[a-z]+\.[a-z]+)?$/is

FlameStorm · Answer

Pour moi, le bon moyen de vérifier les emails est:

Vérifiez que le symbole @ existe et avant et après il y a quelques symboles non @: /^[^@]+@[^@]+$/
Essayez d'envoyer un email à cette adresse avec un "code d'activation".
Lorsque l'utilisateur "activera" son adresse e-mail, nous verrons que tout va bien.

Bien sûr, vous pouvez afficher un avertissement ou une info-bulle en frontal lorsque l'utilisateur a tapé un courrier électronique "étrange" pour l'aider à éviter les erreurs courantes, comme par exemple, aucun point dans une partie de domaine ou des espaces de nom sans guillemets, etc. Mais vous devez accepter l'adresse "hello @ world" si l'utilisateur le souhaite vraiment.

En outre, vous devez vous rappeler que l'adresse électronique standard était et peut évoluer, vous ne pouvez donc pas taper une seule expression rationnelle "standard-valide" une fois pour toutes. Et vous devez vous rappeler que certains serveurs Internet concrets peuvent échouer avec certains détails du standard commun et fonctionnent en fait avec leur propre "standard modifié".

Donc, il suffit de vérifier @, d'indiquer à l'utilisateur sur le frontend et d'envoyer des courriels de vérification à une adresse donnée.

Cees Timmerman · Answer

J'utilise encore:

^[A-Za-z0-9._+\-\']+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}$

Mais avec IPv6 et Unicode à venir, peut-être:

^\w[^@\s]*@[^@\s]{2,}$

est le meilleur. Gmail autorise déjà les points séquentiels, mais Microsoft Exchange Server 2007 les refuse.

SIslam · Answer

Je n'en ai trouvé aucun qui traite du nom de domaine de premier niveau, mais il faut en tenir compte.

Donc, pour moi, après avoir travaillé

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[A-Z]{2}AAA|AARP|ABB|ABBOTT|ABOGADO|AC|ACADEMY|ACCENTURE|ACCOUNTANT|ACCOUNTANTS|ACO|ACTIVE|ACTOR|AD|ADAC|ADS|ADULT|AE|AEG|AERO|AF|AFL|AG|AGENCY|AI|AIG|AIRFORCE|AIRTEL|AL|ALIBABA|ALIPAY|ALLFINANZ|ALSACE|AM|AMICA|AMSTERDAM|ANALYTICS|Android|AO|APARTMENTS|APP|Apple|AQ|AQUARELLE|AR|ARAMCO|ARCHI|ARMY|ARPA|ARTE|AS|ASIA|ASSOCIATES|AT|ATTORNEY|AU|AUCTION|AUDI|AUDIO|AUTHOR|AUTO|AUTOS|AW|AX|AXA|AZ|Azure|BA|BAIDU|BAND|BANK|BAR|BARCELONA|BARCLAYCARD|BARCLAYS|BARGAINS|BAUHAUS|BAYERN|BB|BBC|BBVA|BCN|BD|BE|BEATS|BEER|BENTLEY|BERLIN|BEST|BET|BF|BG|BH|BHARTI|BI|BIBLE|BID|BIKE|BING|BINGO|BIO|BIZ|BJ|BLACK|BLACKFRIDAY|BLOOMBERG|BLUE|BM|BMS|BMW|BN|BNL|BNPPARIBAS|BO|BOATS|BOEHRINGER|BOM|BOND|BOO|BOOK|BOOTS|BOSCH|BOSTIK|BOT|BOUTIQUE|BR|BRADESCO|BRIDGESTONE|BROADWAY|BROKER|BROTHER|BRUSSELS|BS|BT|BUDAPEST|BUGATTI|BUILD|BUILDERS|BUSINESS|BUY|BUZZ|BV|BW|BY|BZ|BZH|CA|CAB|CAFE|CAL|CALL|CAMERA|CAMP|CANCERRESEARCH|Canon|CAPETOWN|CAPITAL|CAR|CARAVAN|CARDS|CARE|CAREER|CAREERS|CARS|CARTIER|CASA|CASH|CASINO|CAT|CATERING|CBA|CBN|CC|CD|CEB|CENTER|CEO|CERN|CF|CFA|CFD|CG|CH|CHANEL|CHANNEL|CHAT|CHEAP|CHLOE|CHRISTMAS|CHROME|CHURCH|CI|CIPRIANI|CIRCLE|Cisco|CITIC|CITY|CITYEATS|CK|CL|CLAIMS|CLEANING|CLICK|CLINIC|CLINIQUE|CLOTHING|CLOUD|CLUB|CLUBMED|CM|CN|CO|COACH|CODES|COFFEE|COLLEGE|COLOGNE|COM|COMMBANK|COMMUNITY|COMPANY|COMPARE|COMPUTER|COMSEC|CONDOS|CONSTRUCTION|CONSULTING|CONTACT|CONTRACTORS|COOKING|COOL|COOP|CORSICA|COUNTRY|COUPONS|COURSES|CR|CREDIT|CREDITCARD|CREDITUNION|CRICKET|CROWN|CRS|CRUISES|CSC|CU|CUISINELLA|CV|CW|CX|CY|CYMRU|CYOU|CZ|DABUR|DAD|DANCE|DATE|DATING|DATSUN|DAY|DCLK|DE|DEALER|DEALS|DEGREE|DELIVERY|Dell|DELTA|DEMOCRAT|DENTAL|DENTIST|DESI|DESIGN|DEV|DIAMONDS|DIET|DIGITAL|DIRECT|DIRECTORY|DISCOUNT|DJ|DK|DM|DNP|DO|DOCS|DOG|DOHA|DOMAINS|DOOSAN|DOWNLOAD|DRIVE|DUBAI|DURBAN|DVAG|DZ|EARTH|EAT|EC|EDEKA|EDU|EDUCATION|EE|EG|EMAIL|EMERCK|ENERGY|ENGINEER|ENGINEERING|ENTERPRISES|EPSON|EQUIPMENT|ER|ERNI|ES|ESQ|ESTATE|ET|EU|EUROVISION|EUS|EVENTS|EVERBANK|EXCHANGE|EXPERT|EXPOSED|EXPRESS|FAGE|FAIL|FAIRWINDS|FAITH|FAMILY|FAN|FANS|FARM|FASHION|FAST|FEEDBACK|FERRERO|FI|FILM|FINAL|FINANCE|FINANCIAL|FIRESTONE|FIRMDALE|FISH|FISHING|FIT|FITNESS|FJ|FK|FLIGHTS|FLORIST|FLOWERS|FLSMIDTH|FLY|FM|FO|FOO|FOOTBALL|FORD|FOREX|FORSALE|FORUM|FOUNDATION|FOX|FR|FRESENIUS|FRL|FROGANS|FUND|FURNITURE|FUTBOL|FYI|GA|GAL|GALLERY|GAME|GARDEN|GB|GBIZ|Gd|GDN|GE|GEA|GENT|GENTING|GF|GG|GGEE|GH|GI|GIFT|GIFTS|GIVES|GIVING|GL|GLASS|GLE|GLOBAL|GLOBO|GM|GMAIL|GMO|GMX|GN|GOLD|GOLDPOINT|GOLF|GOO|GOOG|GOOGLE|GOP|GOT|GOV|GP|GQ|GR|GRAINGER|GRAPHICS|GRATIS|GREEN|GRIPE|GROUP|GS|GT|GU|GUCCI|GUGE|GUIDE|GUITARS|GURU|GW|GY|HAMBURG|HANGOUT|HAUS|HEALTH|HEALTHCARE|HELP|HELSINKI|HERE|HERMES|HIPHOP|HITACHI|HIV|HK|HM|HN|HOCKEY|HOLDINGS|HOLIDAY|HOMEDEPOT|HOMES|HONDA|HORSE|Host|HOSTING|HOTELES|HOTMAIL|HOUSE|HOW|HR|HSBC|HT|HU|HYUNDAI|IBM|ICBC|ICE|ICU|ID|IE|IFM|IINET|IL|IM|IMMO|IMMOBILIEN|IN|INDUSTRIES|INFINITI|INFO|ING|INK|INSTITUTE|INSURANCE|INSURE|INT|INTERNATIONAL|INVESTMENTS|IO|IPIRANGA|IQ|IR|IRISH|IS|ISELECT|IST|ISTANBUL|IT|ITAU|IWC|JAGUAR|Java|JCB|JE|JETZT|JEWELRY|JLC|JLL|JM|JMP|JO|JOBS|JOBURG|JOT|JOY|JP|JPRS|JUEGOS|KAUFEN|KDDI|KE|KFH|KG|KH|KI|KIA|KIM|KINDER|KITCHEN|KIWI|KM|KN|KOELN|KOMATSU|KP|KPN|KR|KRD|KRED|KW|KY|KYOTO|KZ|LA|LACAIXA|LAMBORGHINI|LAMER|LANCASTER|LAND|LANDROVER|LANXESS|LASALLE|LAT|LATROBE|LAW|LAWYER|LB|LC|LDS|LEASE|LECLERC|LEGAL|LEXUS|LGBT|LI|LIAISON|LIDL|LIFE|LIFEINSURANCE|LIFESTYLE|LIGHTING|LIKE|LIMITED|LIMO|LINCOLN|LINDE|LINK|LIVE|LIVING|LIXIL|LK|LOAN|LOANS|LOL|LONDON|LOTTE|LOTTO|LOVE|LR|LS|LT|LTD|LTDA|LU|LUPIN|LUXE|LUXURY|LV|LY|MA|MADRID|MAIF|MAISON|MAKEUP|MAN|MANAGEMENT|MANGO|MARKET|MARKETING|MARKETS|MARRIOTT|MBA|MC|MD|ME|MED|MEDIA|MEET|MELBOURNE|MEME|MEMORIAL|MEN|MENU|MEO|MG|MH|MIAMI|Microsoft|MIL|MINI|MK|ML|MM|MMA|MN|MO|MOBI|MOBILY|MODA|MOE|MOI|MOM|MONASH|MONEY|MONTBLANC|MORMON|MORTGAGE|MOSCOW|MOTORCYCLES|MOV|MOVIE|MOVISTAR|MP|MQ|MR|MS|MT|MTN|MTPC|MTR|MU|MUSEUM|MUTUELLE|MV|MW|MX|MY|MZ|NA|NADEX|NAGOYA|NAME|NAVY|NC|NE|NEC|NET|NETBANK|NETWORK|NEUSTAR|NEW|NEWS|NEXUS|NF|NG|NGO|NHK|NI|NICO|NINJA|NISSAN|NL|NO|NOKIA|NORTON|NOWRUZ|NP|NR|NRA|NRW|NTT|NU|NYC|NZ|OBI|OFFICE|OKINAWA|OM|OMEGA|ONE|ONG|ONL|ONLINE|OOO|Oracle|ORANGE|ORG|ORGANIC|ORIGINS|OSAKA|OTSUKA|OVH|PA|PAGE|PAMPEREDCHEF|PANERAI|PARIS|PARS|PARTNERS|PARTS|PARTY|PE|PET|PF|PG|PH|PHARMACY|PHILIPS|PHOTO|PHOTOGRAPHY|PHOTOS|PHYSIO|PIAGET|PICS|PICTET|PICTURES|PID|PIN|PING|PINK|PIZZA|PK|PL|PLACE|PLAY|PlayStation|PLUMBING|PLUS|PM|PN|POHL|POKER|PORN|POST|PR|PRAXI|PRESS|PRO|PROD|PRODUCTIONS|PROF|PROMO|PROPERTIES|PROPERTY|PROTECTION|PS|PT|PUB|PW|PY|QA|QPON|QUEBEC|RACING|RE|READ|REALTOR|REALTY|RECIPES|RED|REDSTONE|REDUMBRELLA|REHAB|REISE|REISEN|REIT|REN|RENT|RENTALS|REPAIR|REPORT|REPUBLICAN|REST|RESTAURANT|REVIEW|REVIEWS|REXROTH|RICH|RICOH|RIO|RIP|RO|ROCHER|ROCKS|RODEO|ROOM|RS|RSVP|RU|RUHR|RUN|RW|RWE|RYUKYU|SA|SAARLAND|SAFE|SAFETY|SAKURA|SALE|SALON|SAMSUNG|SANDVIK|SANDVIKCOROMANT|SANOFI|SAP|SAPO|SARL|SAS|SAXO|SB|SBS|SC|SCA|SCB|SCHAEFFLER|SCHMIDT|SCHOLARSHIPS|SCHOOL|SCHULE|SCHWARZ|SCIENCE|SCOR|SCOT|SD|SE|SEAT|SECURITY|SEEK|SELECT|SENER|SERVICES|SEVEN|SEW|SEX|SEXY|SFR|SG|SH|SHARP|Shell|SHIA|SHIKSHA|SHOES|SHOW|SHRIRAM|SI|SINGLES|SITE|SJ|SK|SKI|SKIN|SKY|SKYPE|SL|SM|SMILE|SN|SNCF|SO|SOCCER|SOCIAL|SOFTBANK|SOFTWARE|SOHU|SOLAR|SOLUTIONS|SONY|SOY|SPACE|SPIEGEL|SPREADBETTING|SR|SRL|ST|STADA|STAR|STARHUB|STATEFARM|STATOIL|STC|STCGROUP|STOCKHOLM|STORAGE|STUDIO|STUDY|STYLE|SU|SUCKS|SUPPLIES|SUPPLY|SUPPORT|SURF|SURGERY|SUZUKI|SV|SWATCH|SWISS|SX|SY|SYDNEY|SYMANTEC|SYSTEMS|SZ|TAB|TAIPEI|TAOBAO|TATAMOTORS|TATAR|TATTOO|TAX|TAXI|TC|TCI|TD|TEAM|TECH|TECHNOLOGY|TEL|TELEFONICA|TEMASEK|TENNIS|TF|TG|TH|THD|THEATER|THEATRE|TICKETS|TIENDA|TIFFANY|TIPS|TIRES|TIROL|TJ|TK|TL|TM|TMALL|TN|TO|TODAY|TOKYO|TOOLS|TOP|TORAY|Toshiba|TOURS|TOWN|TOYOTA|TOYS|TR|TRADE|TRADING|TRAINING|TRAVEL|TRAVELERS|TRAVELERSINSURANCE|TRUST|TRV|TT|TUBE|TUI|TUSHU|TV|TW|TZ|UA|UBS|UG|UK|UNIVERSITY|UNO|UOL|US|UY|UZ|VA|VACATIONS|VANA|VC|VE|VEGAS|VENTURES|VERISIGN|VERSICHERUNG|VET|VG|VI|VIAJES|VIDEO|VILLAS|VIN|VIP|VIRGIN|VISION|Vista|VISTAPRINT|VIVA|VLAANDEREN|VN|VODKA|VOLKSWAGEN|VOTE|VOTING|VOTO|VOYAGE|VU|WALES|WALTER|WANG|WANGGOU|WATCH|WATCHES|WEATHER|WEBCAM|WEBER|WEBSITE|WED|WEDDING|WEIR|WF|WHOSWHO|WIEN|WIKI|WILLIAMHILL|WIN|WINDOWS|WINE|WME|WORK|WORKS|WORLD|WS|WTC|WTF|XBOX|XEROX|XIN|XN--11B4C3D|XN--1QQW23A|XN--30RR7Y|XN--3BST00M|XN--3DS443G|XN--3E0B707E|XN--3PXU8K|XN--42C2D9A|XN--45BRJ9C|XN--45Q11C|XN--4GBRIM|XN--55QW42G|XN--55QX5D|XN--6FRZ82G|XN--6QQ986B3XL|XN--80ADXHKS|XN--80AO21A|XN--80ASEHDB|XN--80ASWG|XN--90A3AC|XN--90AIS|XN--9DBQ2A|XN--9ET52U|XN--B4W605FERD|XN--C1AVG|XN--C2BR7G|XN--CG4BKI|XN--CLCHC0EA0B2G2A9GCD|XN--CZR694B|XN--CZRS0T|XN--CZRU2D|XN--D1ACJ3B|XN--D1ALF|XN--ECKVDTC9D|XN--EFVY88H|XN--ESTV75G|XN--FHBEI|XN--FIQ228C5HS|XN--FIQ64B|XN--FIQS8S|XN--FIQZ9S|XN--FJQ720A|XN--FLW351E|XN--FPCRJ9C3D|XN--FZC2C9E2C|XN--G2XX48C|XN--GECRJ9C|XN--H2BRJ9C|XN--HXT814E|XN--I1B6B1A6A2E|XN--IMR513N|XN--IO0A7I|XN--J1AEF|XN--J1AMH|XN--J6W193G|XN--JLQ61U9W7B|XN--KCRX77D1X4A|XN--KPRW13D|XN--KPRY57D|XN--KPU716F|XN--KPUT3I|XN--L1ACC|XN--LGBBAT1AD8J|XN--MGB9AWBF|XN--MGBA3A3EJT|XN--MGBA3A4F16A|XN--MGBAAM7A8H|XN--MGBAB2BD|XN--MGBAYH7GPA|XN--MGBB9FBPOB|XN--MGBBH1A71E|XN--MGBC0A9AZCG|XN--MGBERP4A5D4AR|XN--MGBPL2FH|XN--MGBT3DHD|XN--MGBTX2B|XN--MGBX4CD0AB|XN--MK1BU44C|XN--MXTQ1M|XN--NGBC5AZD|XN--NGBE9E0A|XN--NODE|XN--NQV7F|XN--NQV7FS00EMA|XN--NYQY26A|XN--O3CW4H|XN--OGBPF8FL|XN--P1ACF|XN--P1AI|XN--PBT977C|XN--PGBS0DH|XN--PSSY2U|XN--Q9JYB4C|XN--QCKA1PMC|XN--QXAM|XN--RHQV96G|XN--S9BRJ9C|XN--SES554G|XN--T60B56A|XN--TCKWE|XN--UNUP4Y|XN--VERMGENSBERATER-CTB|XN--VERMGENSBERATUNG-PWB|XN--VHQUV|XN--VUQ861B|XN--WGBH1C|XN--WGBL6A|XN--XHQ521B|XN--XKC2AL3HYE2A|XN--XKC2DL3A5EE0H|XN--Y9A3AQ|XN--YFRO4I67O|XN--YGBI2AMMX|XN--ZFR164B|XPERIA|XXX|XYZ|YACHTS|YAMAXUN|YANDEX|YE|YODOBASHI|YOGA|YOKOHAMA|YOUTUBE|YT|ZA|ZARA|ZERO|Zip|ZM|ZONE|ZUERICH|ZW)\b

Que des emails facilement jetés comme 3c296rD3HNEE@d139c.a51, Sd@sd.dox etc

Le nom de domaine peut être modifié si nécessaire, par exemple. domaine de pays spécifique, etc.

David Levy · Answer

Il y a maintenant beaucoup plus (1000) de TLD. La plupart des réponses ici doivent être rejetées car elles ne sont plus correctes - cette question devrait potentiellement avoir une deuxième édition.

N'hésitez pas à visiter une discussion plus récente sur un autre post ... .

Ondřej Šotek · Answer

Pour PHP, j'utilise un validateur d'adresses e-mail de Nette Framework - http://api.nette.org/2.3.3/source-Utils.Validators.php.htp # 234-247 .

/* public static */ function isEmail($value) { $atom = "[-a-z0-9!#$%&'*+/=?^_`{|}~]"; // RFC 5322 unquoted characters in local-part $localPart = "(?:\"(?:[ !\x23-\x5B\x5D-\x7E]*|\\[ -~])+\"|$atom+(?:\.$atom+)*)"; // quoted or unquoted $alpha = "a-z\x80-\xFF"; // superset of IDN $domain = "[0-9$alpha](?:[-0-9$alpha]{0,61}[0-9$alpha])?"; // RFC 1034 one domain component $topDomain = "[$alpha](?:[-0-9$alpha]{0,17}[$alpha])?"; return (bool) preg_match("(^$localPart@(?:$domain\.)+$topDomain\z)i", $value); }

cbp · Answer

Nous avons utilisé http://www.aspnetmx.com/ avec un certain succès depuis quelques années maintenant. Vous pouvez choisir le niveau que vous souhaitez valider (par exemple, vérification de la syntaxe, recherche du domaine, des enregistrements mx ou de l’e-mail réel).

Pour les formulaires frontaux, nous vérifions généralement que le domaine existe et que la syntaxe est correcte, puis nous effectuons une vérification plus stricte pour nettoyer notre base de données avant de procéder à des envois groupés.

Prassd Nidode · Answer

Élément de liste

J'utilise cette fonction

function checkmail($value){ $value = trim($value); if( stristr($value,"@") && stristr($value,".") && (strrpos($value, ".") - stripos($value, "@") > 2) && (stripos($value, "@") > 1) && (strlen($value) - strrpos($value, ".") < 6) && (strlen($value) - strrpos($value, ".") > 2) && ($value == preg_replace('/[ ]/', '', $value)) && ($value == preg_replace('/[^A-Za-z0-9\-_.@!*]/', '', $value)) ){ }else{ return "Invalid Mail-Id"; } }

syp_dino · Answer

J'ai trouvé Bel article , qui dit que le meilleur moyen de valider une adresse électronique est l'expression régulière: /.+@.+\..+/i

Hans-Peter St&#246;rr · Answer

Je ne recommanderais pas du tout d'utiliser une expression rationnelle - les adresses électroniques sont trop compliquées pour cela. C’est un problème courant, je suppose donc que de nombreuses bibliothèques contiennent un validateur - si vous utilisez Java, le EmailValidator of Apache commons validator en est un bon.

grosser · Answer

Cette règle correspond à ce que notre serveur postfix n'a pas pu envoyer.

autorise les lettres, les chiffres, -, _, +,., &, /,!

non -foo@bar.com

non asd@-bar.com

/^([a-z0-9\+\._\/&!][-a-z0-9\+\._\/&!]*)@(([a-z0-9][-a-z0-9]*\.)([-a-z0-9]+\.)*[a-z]{2,})$/i

FLY · Answer

hmm étrange de ne pas voir cette réponse déjà dans les réponses. Voici celle que j'ai construite ... Ce n'est pas une version pare-balles mais elle est "simple" et vérifie presque tout.

[\w+-]+(?:\.[\w+-]+)*@[\w+-]+(?:\.[\w+-]+)*(?:\.[a-zA-Z]{2,4})

Je pense qu'une explication est en place afin que vous puissiez la modifier si vous le souhaitez:

( e ) [\w+-]+ correspond à a-z, A à Z, _, +, - au moins une fois

( m ) (?:\.[\w+-]+)* correspond à a-z, A-Z, _, +, - à zéro ou plus, mais il faut commencer par a. (point)

@ = @

( i ) [\w+-]+ correspond à a-z, A à Z, _, +, - au moins une fois

( l ) (?:\.[\w+-]+)* correspond à a-z, A-Z, _, +, - à zéro ou plus, mais il faut commencer par a. (point)

( com ) (?:\.[a-zA-Z]{2,4}) correspond à a-z, A-Z 2 à 4 fois en commençant par a. (point)

donner e(.m)@i(.l).com où (.m) et (.l) sont facultatifs, mais peut également être répété plusieurs fois ... Je pense que cela valide toutes les adresses électroniques valides, mais bloque les potentiels invalides sans utiliser une expression régulière trop complexe qui ne sera pas nécessaire dans la plupart des cas.

remarquez que ceci autorisera +@-.com mais c’est le compromis pour garder les choses simples.

Jay Zeng · Answer

Personne n'a mentionné la question de la localisation (i18), et si vous avez des clients venant du monde entier? Vous aurez ensuite besoin de sous-catégoriser votre regex par pays/région, ce que j'ai vu des développeurs finir par construire un grand dictionnaire/config. La détection du paramètre de langue du navigateur des utilisateurs peut constituer un bon point de départ.

McGaz · Answer

Les expressions rationnelles publiées dans ce fil de discussion sont obsolètes à cause des nouveaux domaines génériques de premier niveau (gTLD) qui arrivent (par exemple .london, .basketball,.). Pour valider une adresse e-mail, il y a deux réponses (cela serait pertinent pour la grande majorité).

Comme le dit la réponse principale - n'utilisez pas d'expression régulière, validez-la simplement en envoyant un courrier électronique à l'adresse (Catch exceptions pour les adresses non valides)
Utilisez une expression rationnelle très générique pour vous assurer au moins qu'ils utilisent une structure de courrier électronique {something}@{something}.{something}. Cela ne sert à rien de choisir une expression rationnelle détaillée, car vous ne les capturerez pas toutes. Un nouveau lot sera créé dans quelques années et vous devrez mettre à jour votre expression régulière à nouveau.

J'ai décidé d'utiliser l'expression régulière car, malheureusement, certains utilisateurs ne lisent pas les formulaires et placent les mauvaises données dans les mauvais champs. Cela les alertera au moins lorsqu'ils essaieront d'insérer dans le champ de saisie un message qui ne constitue pas un courrier électronique, ce qui vous permettra de gagner du temps pour aider les utilisateurs à résoudre leurs problèmes de courrier électronique.

(.+)@(.+){2,}\.(.+){2,}

Dave Black · Answer

Selon RFC 2821 et RFC 2822 , la partie locale d'une adresse électronique peut utiliser n'importe lequel des caractères ASCII suivants:

Lettres majuscules et minuscules
Les chiffres 0 à 9
Les caractères,! # $% & '* + -/=? ^ _ `{|} ~
Le personnage "." à condition que ce ne soit pas le premier ou le dernier caractère de la partie locale.

Allumettes:

a&d@somedomain.com
a*d@somedomain.com
a/d@somedomain.com

Non-matchs:

.abc @ somedomain.com
abc. @ somedomain.com
a> b@somedomain.com

Pour ceux qui sont conformes aux normes RFC 2821 et 2822, vous pouvez utiliser:

^((([!#$%&'*+\-/=?^_`{|}~\w])|([!#$%&'*+\-/=?^_`{|}~\w][!#$%&'*+\-/=?^_`{|}~\.\w]{0,}[!#$%&'*+\-/=?^_`{|}~\w]))[@]\w+([-.]\w+)*\.\w+([-.]\w+)*)$

Email - Conforme aux RFC 2821 et 2822

sunleo · Answer

Java Mail API fait de la magie pour nous.

try { InternetAddress internetAddress = new InternetAddress(email); internetAddress.validate(); return true; } catch(Exception ex) { return false; }

Je l'ai eu de ici

Alexey Ossikine · Answer

Si vous souhaitez améliorer une expression rationnelle fonctionnant raisonnablement bien pendant plusieurs années, la réponse dépend de l'objectif que vous souhaitez exactement atteindre: quels types d'adresses e-mail ont échoué. Il est très difficile d'ajuster les expressions rationnelles des e-mails, et je n'ai pas encore trouvé de solution parfaite.

Si votre application implique quelque chose de très technique (ou interne aux organisations), alors vous devrez peut-être prendre en charge les adresses IP au lieu des noms de domaine ou des commentaires dans la partie "locale" de l'adresse e-mail.
Si votre application est multinationale, je me concentrerais sur le support Unicode/UTF8.

La réponse principale à votre question est actuellement liée à une "expression régulière entièrement conforme à la norme RFC 822". Cependant, malgré la complexité de cette expression rationnelle et son souci présumé du détail dans les règles RFC, il échoue complètement en ce qui concerne la prise en charge Unicode.

Les expressions rationnelles que j'ai écrites pour la plupart de mes applications sont axées sur le support Unicode, ainsi que sur raisonnablement la bonne conformité aux normes RFC:

/^(?!\.)((?!.*\.{2})[a-zA-Z0-9\u0080-\u00FF\u0100-\u017F\u0180-\u024F\u0250-\u02AF\u0300-\u036F\u0370-\u03FF\u0400-\u04FF\u0500-\u052F\u0530-\u058F\u0590-\u05FF\u0600-\u06FF\u0700-\u074F\u0750-\u077F\u0780-\u07BF\u07C0-\u07FF\u0900-\u097F\u0980-\u09FF\u0A00-\u0A7F\u0A80-\u0AFF\u0B00-\u0B7F\u0B80-\u0BFF\u0C00-\u0C7F\u0C80-\u0CFF\u0D00-\u0D7F\u0D80-\u0DFF\u0E00-\u0E7F\u0E80-\u0EFF\u0F00-\u0FFF\u1000-\u109F\u10A0-\u10FF\u1100-\u11FF\u1200-\u137F\u1380-\u139F\u13A0-\u13FF\u1400-\u167F\u1680-\u169F\u16A0-\u16FF\u1700-\u171F\u1720-\u173F\u1740-\u175F\u1760-\u177F\u1780-\u17FF\u1800-\u18AF\u1900-\u194F\u1950-\u197F\u1980-\u19DF\u19E0-\u19FF\u1A00-\u1A1F\u1B00-\u1B7F\u1D00-\u1D7F\u1D80-\u1DBF\u1DC0-\u1DFF\u1E00-\u1EFF\u1F00-\u1FFFu20D0-\u20FF\u2100-\u214F\u2C00-\u2C5F\u2C60-\u2C7F\u2C80-\u2CFF\u2D00-\u2D2F\u2D30-\u2D7F\u2D80-\u2DDF\u2F00-\u2FDF\u2FF0-\u2FFF\u3040-\u309F\u30A0-\u30FF\u3100-\u312F\u3130-\u318F\u3190-\u319F\u31C0-\u31EF\u31F0-\u31FF\u3200-\u32FF\u3300-\u33FF\u3400-\u4DBF\u4DC0-\u4DFF\u4E00-\u9FFF\uA000-\uA48F\uA490-\uA4CF\uA700-\uA71F\uA800-\uA82F\uA840-\uA87F\uAC00-\uD7AF\uF900-\uFAFF\.!#$%&'*+-/=?^_`{|}~\-\d]+)@(?!\.)([a-zA-Z0-9\u0080-\u00FF\u0100-\u017F\u0180-\u024F\u0250-\u02AF\u0300-\u036F\u0370-\u03FF\u0400-\u04FF\u0500-\u052F\u0530-\u058F\u0590-\u05FF\u0600-\u06FF\u0700-\u074F\u0750-\u077F\u0780-\u07BF\u07C0-\u07FF\u0900-\u097F\u0980-\u09FF\u0A00-\u0A7F\u0A80-\u0AFF\u0B00-\u0B7F\u0B80-\u0BFF\u0C00-\u0C7F\u0C80-\u0CFF\u0D00-\u0D7F\u0D80-\u0DFF\u0E00-\u0E7F\u0E80-\u0EFF\u0F00-\u0FFF\u1000-\u109F\u10A0-\u10FF\u1100-\u11FF\u1200-\u137F\u1380-\u139F\u13A0-\u13FF\u1400-\u167F\u1680-\u169F\u16A0-\u16FF\u1700-\u171F\u1720-\u173F\u1740-\u175F\u1760-\u177F\u1780-\u17FF\u1800-\u18AF\u1900-\u194F\u1950-\u197F\u1980-\u19DF\u19E0-\u19FF\u1A00-\u1A1F\u1B00-\u1B7F\u1D00-\u1D7F\u1D80-\u1DBF\u1DC0-\u1DFF\u1E00-\u1EFF\u1F00-\u1FFF\u20D0-\u20FF\u2100-\u214F\u2C00-\u2C5F\u2C60-\u2C7F\u2C80-\u2CFF\u2D00-\u2D2F\u2D30-\u2D7F\u2D80-\u2DDF\u2F00-\u2FDF\u2FF0-\u2FFF\u3040-\u309F\u30A0-\u30FF\u3100-\u312F\u3130-\u318F\u3190-\u319F\u31C0-\u31EF\u31F0-\u31FF\u3200-\u32FF\u3300-\u33FF\u3400-\u4DBF\u4DC0-\u4DFF\u4E00-\u9FFF\uA000-\uA48F\uA490-\uA4CF\uA700-\uA71F\uA800-\uA82F\uA840-\uA87F\uAC00-\uD7AF\uF900-\uFAFF\-\.\d]+)((\.([a-zA-Z\u0080-\u00FF\u0100-\u017F\u0180-\u024F\u0250-\u02AF\u0300-\u036F\u0370-\u03FF\u0400-\u04FF\u0500-\u052F\u0530-\u058F\u0590-\u05FF\u0600-\u06FF\u0700-\u074F\u0750-\u077F\u0780-\u07BF\u07C0-\u07FF\u0900-\u097F\u0980-\u09FF\u0A00-\u0A7F\u0A80-\u0AFF\u0B00-\u0B7F\u0B80-\u0BFF\u0C00-\u0C7F\u0C80-\u0CFF\u0D00-\u0D7F\u0D80-\u0DFF\u0E00-\u0E7F\u0E80-\u0EFF\u0F00-\u0FFF\u1000-\u109F\u10A0-\u10FF\u1100-\u11FF\u1200-\u137F\u1380-\u139F\u13A0-\u13FF\u1400-\u167F\u1680-\u169F\u16A0-\u16FF\u1700-\u171F\u1720-\u173F\u1740-\u175F\u1760-\u177F\u1780-\u17FF\u1800-\u18AF\u1900-\u194F\u1950-\u197F\u1980-\u19DF\u19E0-\u19FF\u1A00-\u1A1F\u1B00-\u1B7F\u1D00-\u1D7F\u1D80-\u1DBF\u1DC0-\u1DFF\u1E00-\u1EFF\u1F00-\u1FFF\u20D0-\u20FF\u2100-\u214F\u2C00-\u2C5F\u2C60-\u2C7F\u2C80-\u2CFF\u2D00-\u2D2F\u2D30-\u2D7F\u2D80-\u2DDF\u2F00-\u2FDF\u2FF0-\u2FFF\u3040-\u309F\u30A0-\u30FF\u3100-\u312F\u3130-\u318F\u3190-\u319F\u31C0-\u31EF\u31F0-\u31FF\u3200-\u32FF\u3300-\u33FF\u3400-\u4DBF\u4DC0-\u4DFF\u4E00-\u9FFF\uA000-\uA48F\uA490-\uA4CF\uA700-\uA71F\uA800-\uA82F\uA840-\uA87F\uAC00-\uD7AF\uF900-\uFAFF]){2,63})+)$/i

J'éviterai de copier-coller les réponses complètes, je vais donc simplement associer ceci à une réponse similaire à celle que j'ai fournie ici: Comment valider un email unicode?

Une démo en direct est également disponible pour la regex ci-dessus à l’adresse: http://jsfiddle.net/aossikine/qCLVH/3/

Fragment · Answer

Je dois mentionner que cela a presque été ajouté le nouveau domaine "yandex". E-mails possibles: test@job.yandex. Et aussi les lettres majuscules supportées, donc une version légèrement modifiée de la solution acrosman est:

^[_a-zA-Z0-9-]+(\.[_a-zA-Z0-9-]+)*@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*(\.[a-zA-Z]{2,6})$

Joeytje50 · Answer

Une regex qui fait exactement ce que les normes disent est permis, d'après ce que j'ai vu à leur sujet, est la suivante:

/^(?!(^[.-].*|.*[.-]@|.*\.{2,}.*)|^.{254}.+@)([a-z\xC0-\xFF0-9!#$%&'*+\/=?^_`{|}~.-]+@)(?!.{253}.+$)((?!-.*|.*-\.)([a-z0-9-]{1,63}\.)+[a-z]{2,63}|(([01]?[0-9]{2}|2([0-4][0-9]|5[0-5])|[0-9])\.){3}([01]?[0-9]{2}|2([0-4][0-9]|5[0-5])|[0-9]))$/gim

Démo / Analyse Debuggex ( interactive )

Séparer:

^(?!(^[.-].*|.*[.-]@|.*\.{2,}.*)|^.{254}.+@) ([a-z\xC0-\xFF0-9!#$%&'*+\/=?^_`{|}~.-]+@) (?!.{253}.+$) ( (?!-.*|.*-\.) ([a-z0-9-]{1,63}\.)+ [a-z]{2,63} | (([01]?[0-9]{2}|2([0-4][0-9]|5[0-5])|[0-9])\.){3} ([01]?[0-9]{2}|2([0-4][0-9]|5[0-5])|[0-9]) )$

Une analyse:

(?!(^[.-].*|.*[.-]@|.*\.{2,}.*)|^.{254}.+@)

Lookahead négatif pour une adresse commençant par ., se terminant par un, et contenant .. , ou dépassant la longueur maximale de 254 caractères

([a-z\xC0-\xFF0-9!#$%&'*+\/=?^_`{|}~.-]+@)

correspondant à 1 ou plus des caractères autorisés , avec l'aspect négatif qui s'y applique

(?!.{253}.+$)

Lookahead négatif pour la partie de nom de domaine, le limitant à 253 caractères au total

(?!-.*|.*-\.)

Un préfixe négatif pour chacun des noms de domaine, qui ne permettent pas commençant ou se terminant par .

([a-z0-9-]{1,63}\.)+

correspondance de groupe simple pour les caractères autorisés dans un nom de domaine, limités à 63 caractères chacun

[a-zA-Z]{2,63}

correspondance de groupe simple pour le domaine de premier niveau autorisé, qui actuellement toujours est limité aux lettres uniquement, mais inclut des TLD de plus de 4 lettres .

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

l'alternative pour les noms de domaine: cela correspond aux 3 premiers chiffres d'une adresse IP avec un . derrière celle-ci, puis au quatrième chiffre de l'adresse IP sans . derrière.

zıəs uɐɟəʇs · Answer

Comme déjà mentionné, vous ne pouvez pas valider un email avec une expression régulière. Cependant, voici ce que nous utilisons actuellement pour nous assurer que la saisie de l'utilisateur n'est pas totalement fausse (oublier le TLD, etc.).

Cette expression rationnelle autorisera les domaines IDN et les caractères spéciaux (comme les trémas) avant et après le signe @.

/^[\w.+-_]+@[^.][\w.-]*\.[\w-]{2,63}$/iu

Giri · Answer

La plateforme de blogs la plus populaire au monde, WordPress, utilise cette fonction pour valider l'adresse e-mail.

Mais ils le font en plusieurs étapes.

Vous n’avez plus à vous inquiéter lorsque vous utilisez la regex mentionnée dans cette fonction.

Voici la fonction ..

/** * Verifies that an email is valid. * * Does not grok i18n domains. Not RFC compliant. * * @since 0.71 * * @param string $email Email address to verify. * @param boolean $deprecated Deprecated. * @return string|bool Either false or the valid email address. */ function is_email( $email, $deprecated = false ) { if ( ! empty( $deprecated ) ) _deprecated_argument( __FUNCTION__, '3.0' ); // Test for the minimum length the email can be if ( strlen( $email ) < 3 ) { return apply_filters( 'is_email', false, $email, 'email_too_short' ); } // Test for an @ character after the first position if ( strpos( $email, '@', 1 ) === false ) { return apply_filters( 'is_email', false, $email, 'email_no_at' ); } // Split out the local and domain parts list( $local, $domain ) = explode( '@', $email, 2 ); // LOCAL PART // Test for invalid characters if ( !preg_match( '/^[a-zA-Z0-9!#$%&\'*+/=?^_`{|}~\.-]+$/', $local ) ) { return apply_filters( 'is_email', false, $email, 'local_invalid_chars' ); } // DOMAIN PART // Test for sequences of periods if ( preg_match( '/\.{2,}/', $domain ) ) { return apply_filters( 'is_email', false, $email, 'domain_period_sequence' ); } // Test for leading and trailing periods and whitespace if ( trim( $domain, " 	

\0\x0B." ) !== $domain ) { return apply_filters( 'is_email', false, $email, 'domain_period_limits' ); } // Split the domain into subs $subs = explode( '.', $domain ); // Assume the domain will have at least two subs if ( 2 > count( $subs ) ) { return apply_filters( 'is_email', false, $email, 'domain_no_periods' ); } // Loop through each sub foreach ( $subs as $sub ) { // Test for leading and trailing hyphens and whitespace if ( trim( $sub, " 	

\0\x0B-" ) !== $sub ) { return apply_filters( 'is_email', false, $email, 'sub_hyphen_limits' ); } // Test for invalid characters if ( !preg_match('/^[a-z0-9-]+$/i', $sub ) ) { return apply_filters( 'is_email', false, $email, 'sub_invalid_chars' ); } } // Congratulations your email made it! return apply_filters( 'is_email', $email, $email, null ); }

Prasad Bhosale · Answer

Voici l'expression régulière pour valider l'adresse e-mail.

^.+@\w+(\.\w+)+$

mirabilos · Answer

J’ai eu le même désir: demander une vérification rapide de la syntaxe des adresses e-mail sans exagérer (la réponse Mail::RFC822::Address qui est évidemment la réponse correcte) pour un utilitaire d’envoi par e-mail . J'y suis allé avec ceci (je suis une personne de POSIX RE, je n'utilise donc pas \d et autres de PCRE, car ils me rendent les choses moins lisibles):

preg_match("_^[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*@[0-9A-Za-z]([-0-9A-Za-z]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([-0-9A-Za-z]{0,61}[0-9A-Za-z])?)*\$_", $adr)

Ceci est correct selon RFC mais exclut explicitement les formulaires obsolètes ainsi que les adresses IP directes (IP et Legacy IP), ce qu'un utilisateur du groupe cible de cet utilitaire (généralement: les personnes qui nous dérangent dans #sendmail sur IRC) ne voudrait normalement pas ou besoin de toute façon.

Les IDN (noms de domaine internationalisés) sont explicitement non dans le champ d'application de l'e-mail: des adresses telles que "foo@cäcilienchor-bonn.de" doit être écrit "foo @ xn - ccilienchor-bonn -vnb.de ”à la place (ceci inclut mailto: liens en HTML et tout ce qui est amusant), seule l'interface graphique est autorisée à afficher (et à accepter, puis à convertir) de tels noms à l'utilisateur.

Hany Sakr · Answer

Nice, j'ai converti le code en Java pour correspondre au compilateur

String pattern ="(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\$$\x01-\x09\x0b\x0c\x0e-\x7f])*\")@(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-zA-Z0-9-]*[a-zA-Z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)$$)";

mrswadge · Answer

I trouvé une expression rationnelle } conforme à la norme RFC 2822. Norme précédente à la norme RFC 5322. Cette expression régulière semble fonctionner assez bien et couvrira la plupart des cas. Cependant, la norme RFC 5322 devenant la norme, certaines trous qui doivent être bouchés.

^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|$$\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?: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]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\[\x01-\x09\x0b\x0c\x0e-\x7f])+)$$)$

La documentation indique que vous ne devez pas utiliser l'expression régulière ci-dessus, mais plutôt privilégier cette version, qui est un peu plus gérable.

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?

J'ai remarqué que c'est sensible à la casse, alors j'ai apporté une modification à cet atterrissage.

^[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$

Rajneesh071 · Answer

RegEx valide selon w3 org et wikipedia

[A-Z0-9a-z.!#$%&'*+-/=?^_`{|}~]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4}

par exemple. !#$%&'*+-/=?^_`.{|Buch~@example.com

Savas Adar · Answer

Je l'utilise

^(([^<>()\.,;:\s@"]+(\.[^<>()\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$

sln · Answer

regex email (RFC5322)

(?im)^(?=.{1,64}@)(?:("[^"\]*(?:\.[^"\]*)*"@)|((?:[0-9a-z](?:\.(?!\.)|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)?[0-9a-z]@))(?=.{1,255}$)(?:($$(?:\d{1,3}\.){3}\d{1,3}$$)|((?:(?=.{1,63}\.)[0-9a-z][-\w]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9])|((?=.{1,63}$)[0-9a-z][-\w]*))$

Démo https://regex101.com/r/ObS3QZ/1

 # (?im)^(?=.{1,64}@)(?:("[^"\]*(?:\.[^"\]*)*"@)|((?:[0-9a-z](?:\.(?!\.)|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)?[0-9a-z]@))(?=.{1,255}$)(?:($$(?:\d{1,3}\.){3}\d{1,3}$$)|((?:(?=.{1,63}\.)[0-9a-z][-\w]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9])|((?=.{1,63}$)[0-9a-z][-\w]*))$ # Note - remove all comments '(comments)' before runninig this regex # Find $[^)]*$ replace with nothing (?im) # Case insensitive ^ # BOS # Local part (?= .{1,64} @ ) # 64 max chars (?: ( # (1 start), Quoted " [^"\]* (?: \ . [^"\]* )* " @ ) # (1 end) | # or, ( # (2 start), Non-quoted (?: [0-9a-z] (?: \. (?! \. ) | # or, [-!#\$%&'\*\+/=\?\^`\{\}\|~\w] )* )? [0-9a-z] @ ) # (2 end) ) # Domain part (?= .{1,255} $ ) # 255 max chars (?: ( # (3 start), IP $$ (?: \d{1,3} \. ){3} \d{1,3} $$ ) # (3 end) | # or, ( # (4 start), Others (?: # Labels (63 max chars each) (?= .{1,63} \. ) [0-9a-z] [-\w]* [0-9a-z]* \. )+ [a-z0-9] [\-a-z0-9]{0,22} [a-z0-9] ) # (4 end) | # or, ( # (5 start), Localdomain (?= .{1,63} $ ) [0-9a-z] [-\w]* ) # (5 end) ) $ # EOS

Ramesh Kotkar · Answer

Vous pouvez utiliser les expressions régulières suivantes pour n’importe quelle adresse électronique.

^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(($$[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$$)|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$

Pour PHP

 function checkEmailValidation($email) { $expression='/^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(($$[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$$)|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/'; if(preg_match($expression, $email)) { return true; }else { return false; } }

Pour javascript

 function checkEmailValidation(email) { var pattern='/^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(($$[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$$)|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/'; if(pattern.test(email)) { return true; }else { return false; } }

Francisco Tom&#233; Costa · Answer

^[_a-zA-Z0-9-]+(\.[_a-zA-Z0-9-]+)*@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*\.(([0-9]{1,3})|([a-zA-Z]{2,3})|(aero|coop|info|museum|name))$

Cela correspond à 99,99% des adresses électroniques, y compris à certaines des extensions de domaine de premier niveau les plus récentes, telles que les informations, le musée, le nom, etc. Il permet également les e-mails liés directement aux adresses IP.

partoftheorigin · Answer

Écrire une expression régulière pour toutes les choses demandera beaucoup d'effort. Au lieu de cela, vous pouvez utiliser le package pyIsEmail .

Le texte ci-dessous provient du site pyIsEmail .

pyIsEmail est une approche simple pour vérifier si cette adresse e-mail fournie par l'utilisateur peut être réelle.

Les expressions régulières sont peu coûteuses à écrire, mais nécessitent souvent une maintenance lorsque de nouveaux domaines de premier niveau apparaissent ou ne sont pas conformes aux fonctionnalités d’adressage d’e-mails redevenues à la mode. pyIsEmail vous permet de valider une adresse électronique - et même de vérifier le domaine, si vous le souhaitez - d'un simple appel, ce qui rend votre code plus lisible et plus rapide à écrire. Lorsque vous voulez savoir pourquoi une adresse e-mail ne se valide pas, ils vous fournissent même un diagnostic.

Usage

Pour une utilisation plus simple, importez et utilisez la fonction is_email:

from pyisemail import is_email address = "test@example.com" bool_result = is_email(address) detailed_result = is_email(address, diagnose=True)

Vous pouvez également vérifier si le domaine utilisé dans l'e-mail est un domaine valide et s'il possède ou non un enregistrement MX valide:

from pyisemail import is_email address = "test@example.com" bool_result_with_dns = is_email(address, check_dns=True) detailed_result_with_dns = is_email(address, check_dns=True, diagnose=True)

Ce sont des indicateurs principaux de la possibilité qu'une adresse e-mail puisse être émise sur ce domaine. Cependant, une réponse valide ne garantit pas que le courrier existe, mais peut exister.

Outre les fonctionnalités de base is_email, vous pouvez également utiliser les validateurs eux-mêmes. Vérifiez le document source du validateur pour voir comment cela fonctionne.