En utilisant une expression régulière pour valider une adresse e-mail

Question

Au fil des années, j'ai lentement élaboré une expression régulière qui permet de valider la PLUPART des adresses e-mail correctement, en supposant qu'ils n'utilisez pas une adresse IP que le serveur de la partie. Actuellement, l'expression est:

^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,4})$

- Je l'utiliser dans plusieurs programmes de PHP, et il fonctionne la plupart du temps. Cependant, de temps à autre, je suis contacté par quelqu'un qui ait des problèmes avec un site qui l'utilise, et je finis par avoir à faire quelques ajustements (plus récemment, j'ai réalisé que je n'étais pas en permettant à 4 caractères Tld).

Quelle est la meilleure expression régulière vous avez ou avez vu pour la validation des e-mails?

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

Answer 1

Il n'est pas simple expression régulière pour ce problème: voir cette RFC‑822–conforme regex, qui est tout sauf simple. (Il a été écrit avant les jours de modèles grammaticaux.) La grammaire spécifié dans la RFC 5322 est trop compliqué pour des primitifs expressions régulières, bien que le plus sophistiqué de modèles grammaticaux en Perl, PCRE, et PHP peut tout gérer à analyser correctement les RFC 5322 sans accroc. Python et C# doit également être en mesure de le gérer, mais ils utilisent une syntaxe différente de ces trois premiers.

Toutefois, si vous êtes obligé d'utiliser l'un des nombreux moins puissant pattern-matching langues, alors il est préférable d'utiliser un vrai analyseur. Mais comprenez que la validation par la RFC vous dit absolument rien quant à savoir si la personne saisie de l'adresse est son vrai propriétaire. Signer des autres jusqu'à des listes de diffusion de cette façon tout le temps. Fixation qui nécessite un amateur de validation des acquis qui implique l'envoi de cette adresse un message qui comporte une confirmation jeton destiné à être entrés dans la même page web a l'adresse.

C'est la seule façon de savoir que vous avez obtenu l'adresse de la personne à l'entrée, qui est pourquoi la plupart des listes de diffusion maintenant utiliser ce mécanisme pour confirmer signe-ups. Après tout, n'importe qui peut mettre bas president@whitehouse.gov, et qui va même analyser juridique, mais il n'est pas susceptible d'être la personne à l'autre extrémité.

Pour PHP, vous devriez ne pas utiliser le modèle donné dans la validation d'un E-Mail avec PHP, la bonne Façon de qui je cite:

Il y a danger que l'usage courant et généralisé bâclée codage établir un standard de facto pour les adresses e-mail, qui est plus restrictive que celle de l'enregistrement formel de la norme.

Ce n'est pas mieux que tous les autres non-RFC modèles. Il n'est même pas assez intelligent pour gérer la RFC 822, sans parler de la RFC 5322. Ce un, cependant, est.

Si vous voulez obtenir la fantaisie et pédant, de mettre en œuvre un état complet du moteur. Une expression régulière peut seulement agir comme un rudimentaire filtre. Le problème avec les expressions régulières, c'est que dire à quelqu'un que parfaitement leur adresse e-mail valide est pas valide (faux positif) parce que votre expression régulière ne peut pas gérer c'est juste grossier et impoli à partir de la perspective de l'utilisateur. Un moteur d'état pour le but à la fois de valider et corriger les adresses e-mail qui seraient autrement considérés comme non valides comme il démonte l'e-mail en fonction de chaque RFC. Cela permet potentiellement plus agréable, comme

L'adresse e-mail spécifiée 'monemail@de l'adresse,de la com' n'est pas valide. Vouliez-vous dire 'myemail@address.com'?

Voir également la Validation des Adresses e-Mail, y compris les commentaires. Ou la Comparaison de l'E-mail de la Validation des Expressions Régulières.

Debuggex Démo

Answer 2

Cette question est posée à beaucoup de choses, mais je pense que vous devriez recul et demandez-vous pourquoi vous voulez valider les adresses email du point de vue syntaxique? Quel est l'avantage vraiment?

• Il ne sera pas attraper les erreurs communes.
• Il n'empêche pas les gens d'entrer dans des invalides ou des adresses e-mail, ou d'entrer une autre adresse.

Si vous souhaitez valider qu'un email est correct, vous n'avez pas le choix que d'envoyer un e-mail de confirmation et demandez à l'utilisateur de répondre à cela. Dans de nombreux cas, vous allez avoir à envoyer un mail de confirmation de toute façon pour des raisons de sécurité ou pour des raisons d'éthique (si vous ne pouvez pas par exemple de signer quelqu'un pour un service contre leur volonté).

Answer 3

Tout dépend de comment précis que vous voulez être. Dans mon cas, où j’essaie juste de garder des choses comme « bob @ aol.com » ou « steve » ou « mary@aolcom », j’utilise

Bien sûr, il correspondra à des choses qui ne sont pas des adresses email valides, mais il s’agit de jouer la règle 90/10.

Answer 4

Cela dépend de ce que tu veux dire par le meilleur: Si vous parlez au sujet de la capture de chaque adresse de courriel valide, utilisez les éléments suivants:

(?:(?:\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 êtes à la recherche de quelque chose de plus simple mais qui va prendre la plupart des adresses e-mail valides essayez quelque chose comme:

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

EDIT: À partir du lien:

Cette expression régulière seulement de valider les adresses qui ont eu des commentaires dépouillé et remplacés par des espaces (ce qui est fait par le module).

Answer 5

[Mise à JOUR] j'ai collationné tout ce que je sais au sujet de l'email de validation d'adresse ici: http://isemail.infoqui, maintenant, non seulement valide, mais aussi les diagnostics des problèmes avec les adresses e-mail. Je suis d'accord avec beaucoup de commentaires ici que la validation n'est qu'une partie de la réponse, voir mon essai à http://isemail.info/about.

is_email() le reste, autant que je sache, le seul programme de validation qui va vous dire définitivement si une chaîne donnée est une adresse de courriel valide ou pas. J'ai télécharger une nouvelle version http://isemail.info/about

J'ai collationné cas de test à partir Cal Henderson, Dave Enfant, Phil Haack, Doug Lovell, RFC5322 et RFC 3696. 275 test s'adresse à tous. J'ai couru tous ces tests à l'encontre de toutes les validateurs que j'ai pu trouver.

Je vais essayer de garder cette page à jour que les gens à améliorer leur validateurs. Grâce à Cal, Michael, David, Paul et Phil pour leur aide et leur coopération dans l'élaboration de ces tests et à la critique constructive de mon propre programme de validation.

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