Quels caractères sont autorisés dans une adresse e-mail?

Je ne demande pas de validation complète par e-mail.

Je veux juste savoir quels sont les caractères autorisés user-nameet les serverparties de l'adresse e-mail. Cela peut être simplifié à l'extrême, peut-être que les adresses e-mail peuvent prendre d'autres formes, mais je m'en fiche. Je pose des questions sur ce simple formulaire: user-name@server(par exemple wild.wezyr@best-server-ever.com) et les caractères autorisés dans les deux parties.

Voir RFC 5322: Format de message Internet et, dans une moindre mesure, RFC 5321: Simple Mail Transfer Protocol .

La RFC 822 couvre également les adresses e-mail, mais elle traite principalement de sa structure:

 addr-spec   =  local-part "@" domain        ; global address     
 local-part  =  word *("." word)             ; uninterpreted
                                             ; case-preserved

 domain      =  sub-domain *("." sub-domain)     
 sub-domain  =  domain-ref / domain-literal     
 domain-ref  =  atom                         ; symbolic reference

Et comme d'habitude, Wikipedia a un article décent sur les adresses e-mail :

La partie locale de l'adresse e-mail peut utiliser l'un de ces caractères ASCII:

• lettres latines majuscules et minuscules Avers Zet avers z;
• chiffres 0à 9;
• caractères spéciaux !#$%&'*+-/=?^_`{|}~;
• point ., à condition qu'il ne soit pas le premier ou le dernier caractère à moins d'être cité, et à condition qu'il n'apparaisse pas consécutivement à moins d'être cité (par exemple, John..Doe@example.comn'est pas autorisé mais "John..Doe"@example.comest autorisé);
• l'espace et les "(),:;<>@[\]caractères sont autorisés avec des restrictions (ils ne sont autorisés qu'à l'intérieur d'une chaîne entre guillemets, comme décrit dans le paragraphe ci-dessous, et en outre, une barre oblique inverse ou un guillemet double doit être précédé d'une barre oblique inverse);
• les commentaires sont autorisés avec des parenthèses à chaque extrémité de la partie locale; par exemple john.smith(comment)@example.comet (comment)john.smith@example.comsont tous deux équivalents à john.smith@example.com.

En plus des caractères ASCII, à partir de 2012, vous pouvez utiliser les caractères internationaux ciU+007F - dessus , encodés en UTF-8 comme décrit dans la spécification RFC 6532 et expliqué sur Wikipédia . Notez qu'à partir de 2019, ces normes sont toujours marquées comme proposées, mais sont déployées lentement. Les changements dans cette spécification ont essentiellement ajouté des caractères internationaux en tant que caractères alphanumériques valides (atext) sans affecter les règles sur les caractères spéciaux autorisés et restreints comme !#et @:.

Pour la validation, voir Utilisation d'une expression régulière pour valider une adresse e-mail .

La domainpièce est définie comme suit :

Les normes Internet (demande de commentaires) pour les protocoles stipulent que les étiquettes de nom d'hôte de composant ne peuvent contenir que les lettres ASCII à atravers z(de manière non sensible à la casse), les chiffres à 0travers 9et le tiret ( -). La spécification d'origine des noms d'hôtes dans la RFC 952 , stipulait que les étiquettes ne pouvaient pas commencer par un chiffre ou par un trait d'union et ne devaient pas se terminer par un trait d'union. Cependant, une spécification ultérieure ( RFC 1123 ) a permis aux étiquettes de nom d'hôte de commencer par des chiffres. Aucun autre symbole, caractère de ponctuation ou espace vide n'est autorisé.

Fais attention! Il y a beaucoup de pourriture des connaissances dans ce fil (des choses qui étaient vraies et qui ne le sont plus).

Pour éviter les rejets faussement positifs des adresses e-mail réelles dans le monde actuel et futur, et de n'importe où dans le monde, vous devez connaître au moins le concept de haut niveau de la RFC 3490 , "Internationalisation des noms de domaine dans les applications (IDNA)". Je sais que les gens aux États-Unis et en A ne sont souvent pas au courant de cela, mais il est déjà largement utilisé et en augmentation rapide dans le monde (principalement les parties non dominées par l'anglais).

L'essentiel est que vous pouvez désormais utiliser des adresses comme mason @ 日本 .com et wildwezyr@fahrvergnügen.net. Non, ce n'est pas encore compatible avec tout ce qui existe (comme beaucoup l'ont regretté ci-dessus, même les adresses simples de style qmail + ident sont souvent rejetées à tort). Mais il y a un RFC, il y a une spécification, il est maintenant soutenu par l'IETF et l'ICANN, et - plus important encore - il y a un nombre important et croissant d'implémentations soutenant cette amélioration qui sont actuellement en service.

Je ne savais pas grand-chose sur ce développement moi-même jusqu'à ce que je retourne au Japon et que je commence à voir des adresses e-mail comme hei @ や る .ca et des URL Amazon comme celle-ci:

http://www.amazon.co.jp/ エ レ ク ト ロ ニ ク ス - デ ジ タ ル カ メ ラ - ポ ー タ ブ ル オ ー デ ィ オ / b / ref = topnav_storetab_e? ie = UTF8 & node = 3210981

Je sais que vous ne voulez pas de liens vers des spécifications, mais si vous vous fiez uniquement aux connaissances obsolètes des pirates sur les forums Internet, votre validateur de messagerie finira par rejeter les adresses e-mail que les utilisateurs non anglophones s'attendent de plus en plus à travailler. Pour ces utilisateurs, une telle validation sera tout aussi ennuyeuse que la forme banale mortelle que nous détestons tous, celle qui ne peut pas gérer un + ou un nom de domaine en trois parties ou autre.

Donc, je ne dis pas que ce n'est pas un problème, mais la liste complète des caractères "autorisés dans certaines conditions / tout / aucun" est (presque) tous les caractères dans toutes les langues. Si vous souhaitez "accepter toutes les adresses e-mail valides (et beaucoup aussi non valides)", vous devez prendre en compte l'IDN, ce qui rend fondamentalement une approche basée sur les caractères inutile (désolé), sauf si vous convertissez d' abord les adresses e-mail internationalisées en Punycode .

Après cela, vous pouvez suivre (la plupart) les conseils ci-dessus.

Le format de l'adresse e-mail est le suivant: local-part@domain-part (max. 64 @ 255 caractères, plus 256 au total).

Le local-partet domain-partpourrait avoir un ensemble différent de caractères autorisés, mais ce n'est pas tout, car il y a plus de règles.

En général, la partie locale peut avoir ces caractères ASCII:

• minuscules lettres latines: abcdefghijklmnopqrstuvwxyz,
• majuscules lettres latines: ABCDEFGHIJKLMNOPQRSTUVWXYZ,
• chiffres: 0123456789,
• caractères spéciaux: !#$%&'*+-/=?^_`{|}~,
• point: .(pas le premier ou le dernier caractère ou répété sauf si cité),
• ponctuations spatiales telles que: "(),:;<>@[\](avec certaines restrictions),
• commentaires: ()(sont autorisés entre parenthèses, par exemple (comment)john.smith@example.com).

Partie du domaine:

• minuscules lettres latines: abcdefghijklmnopqrstuvwxyz,
• majuscules lettres latines: ABCDEFGHIJKLMNOPQRSTUVWXYZ,
• chiffres: 0123456789,
• trait d'union: -(pas le premier ou le dernier caractère),
• peut contenir une adresse IP entourée de crochets: jsmith@[192.168.2.1]ou jsmith@[IPv6:2001:db8::1].

Ces adresses e-mail sont valides:

• prettyandsimple@example.com
• very.common@example.com
• disposable.style.email.with+symbol@example.com
• other.email-with-dash@example.com
• x@example.com (partie locale d'une lettre)
• "much.more unusual"@example.com
• "very.unusual.@.unusual.com"@example.com
• "very.(),:;<>[]\".VERY.\"very@\ \"very\".unusual"@strange.example.com
• example-indeed@strange-example.com
• admin@mailserver1 (nom de domaine local sans domaine de premier niveau)
• #!$%&'*+-/=?^_`{}|~@example.org
• "()<>[]:,;@\\"!#$%&'-/=?^_`{}| ~.a"@example.org
• " "@example.org (espace entre les guillemets)
• example@localhost (envoyé par localhost)
• example@s.solutions(voir la liste des domaines de premier niveau Internet )
• user@com
• user@localserver
• user@[IPv6:2001:db8::1]

Et ces exemples de non valide:

• Abc.example.com(pas de @caractère)
• A@b@c@example.com(un seul @est autorisé en dehors des guillemets)
• a"b(c)d,e:f;gi[j\k]l@example.com (aucun des caractères spéciaux de cette partie locale n'est autorisé en dehors des guillemets)
• just"not"right@example.com (les chaînes entre guillemets doivent être séparées par des points ou le seul élément constituant la partie locale)
• this is"not\allowed@example.com (les espaces, les guillemets et les barres obliques inverses ne peuvent exister que dans les chaînes entre guillemets et précédés d'une barre oblique inverse)
• this\ still\"not\allowed@example.com (même s'ils sont échappés (précédés d'une barre oblique inverse), les espaces, les guillemets et les barres obliques inverses doivent toujours être contenus par des guillemets)
• john..doe@example.com(double point avant @); (avec mise en garde: Gmail laisse passer cela)
• john.doe@example..com(double point après @)
• une adresse valide avec un espace de tête
• une adresse valide avec un espace de fin

Source: adresse e-mail sur Wikipedia

RFC2822 regex de Perl pour valider les e-mails:

(?:(?:\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*)

Le regexp complet pour les adresses RFC2822 n'était que de 3,7k.

Voir aussi: RFC 822 Email Address Parser en PHP .

Les définitions officielles des adresses e-mail sont les suivantes:

• RFC 5322 (sections 3.2.3 et 3.4.1, obsolètes RFC 2822), RFC 5321, RFC 3696,
• RFC 6531 (caractères autorisés).

En relation:

• Le vrai pouvoir des expressions régulières

Wikipedia a un bon article à ce sujet , et les spécifications officielles sont ici . De Wikipdia:

La partie locale de l'adresse e-mail peut utiliser l'un de ces caractères ASCII:

• Lettres anglaises majuscules et minuscules (az, AZ)
• Chiffres 0 à 9
• Personnages ! # $% & '* + - / =? ^ _ `{| } ~
• Personnage . (point, point, point final) à condition qu'il ne s'agisse pas du premier ou du dernier caractère, et à condition également qu'il n'apparaisse pas deux fois ou plus consécutivement.

De plus, les chaînes entre guillemets (par exemple: "John Doe" @ example.com) sont autorisées, autorisant ainsi des caractères qui seraient autrement interdits, mais ils n'apparaissent pas dans la pratique courante. La RFC 5321 prévient également qu '"un hôte qui s'attend à recevoir du courrier DEVRAIT éviter de définir des boîtes aux lettres où la partie locale requiert (ou utilise) le formulaire de chaîne entre guillemets".

Google fait une chose intéressante avec ses adresses gmail.com. Les adresses gmail.com n'autorisent que les lettres (az), les chiffres et les points (qui sont ignorés).

par exemple, pikachu@gmail.com est identique à pi.kachu@gmail.com, et les deux adresses e-mail seront envoyées à la même boîte aux lettres. PIKACHU@gmail.com est également livré dans la même boîte aux lettres.

Donc, pour répondre à la question, cela dépend parfois de l'implémenteur de la quantité de normes RFC qu'ils souhaitent suivre. Le style d'adresse gmail.com de Google est compatible avec les normes. Ils le font de cette façon pour éviter toute confusion où différentes personnes prendraient des adresses e-mail similaires, par exemple

*** gmail.com accepting rules ***
d.oy.smith@gmail.com   (accepted)
d_oy_smith@gmail.com   (bounce and account can never be created)
doysmith@gmail.com     (accepted)
D.Oy'Smith@gmail.com   (bounce and account can never be created)

Le lien wikipedia est une bonne référence sur ce que les adresses e-mail permettent généralement. http://en.wikipedia.org/wiki/Email_address

Vous pouvez commencer à partir d'un article wikipedia :

• Lettres anglaises majuscules et minuscules (az, AZ)
• Chiffres 0 à 9
• Personnages ! # $% & '* + - / =? ^ _ `{| } ~
• Personnage . (point, point, point final) à condition qu'il ne s'agisse pas du premier ou du dernier caractère, et à condition également qu'il n'apparaisse pas deux fois ou plus consécutivement.

Nom:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!#$%&'*+-/=?^_`{|}~.

Serveur:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-.

Vérifiez @ et. puis envoyez un e-mail pour qu'ils vérifient.

Je ne peux toujours pas utiliser mon adresse e-mail .name sur 20% des sites sur Internet parce que quelqu'un a raté sa validation par e-mail ou parce qu'elle est antérieure à la validité des nouvelles adresses.

La réponse courte est qu'il y a 2 réponses. Il y a une norme pour ce que vous devez faire. c'est-à-dire un comportement sage qui vous évitera des ennuis. Il existe une autre norme (beaucoup plus large) pour le comportement que vous devez accepter sans problème. Cette dualité fonctionne pour l'envoi et l'acceptation de courriels mais a une large application dans la vie.

Pour un bon guide des adresses que vous créez; voir: http://www.remote.org/jochen/mail/info/chars.html

Pour filtrer les e-mails valides, transmettez simplement tout ce qui est suffisamment compréhensible pour voir la prochaine étape. Ou commencez à lire un tas de RFC, attention, voici des dragons.

Une bonne lecture à ce sujet .

Extrait:

These are all valid email addresses!

"Abc\@def"@example.com
"Fred Bloggs"@example.com
"Joe\\Blow"@example.com
"Abc@def"@example.com
customer/department=shipping@example.com
\$A12345@example.com
!def!xyz%abc@example.com
_somename@example.com

La réponse acceptée fait référence à un article de Wikipédia lors de la discussion de la partie locale valide d'une adresse e-mail, mais Wikipédia n'est pas une autorité à ce sujet.

IETF RFC 3696 est une autorité en la matière et doit être consultée à la section 3. Restrictions sur les adresses e-mail à la page 5:

Les adresses électroniques contemporaines consistent en une "partie locale" séparée d'une "partie de domaine" (un nom de domaine complet) par un signe at ("@"). La syntaxe de la partie domaine correspond à celle de la section précédente. Les préoccupations identifiées dans cette section concernant le filtrage et les listes de noms s'appliquent également aux noms de domaine utilisés dans un contexte de messagerie. Le nom de domaine peut également être remplacé par une adresse IP entre crochets, mais ce formulaire est fortement déconseillé, sauf à des fins de test et de dépannage.

La partie locale peut apparaître en utilisant les conventions de citation décrites ci-dessous. Les formulaires cités sont rarement utilisés dans la pratique, mais sont nécessaires à des fins légitimes. Par conséquent, ils ne doivent pas être rejetés dans les routines de filtrage, mais doivent plutôt être transmis au système de messagerie pour évaluation par l'hôte de destination.

La règle exacte est que tout caractère ASCII, y compris les caractères de contrôle, peut apparaître entre guillemets ou dans une chaîne entre guillemets. Lorsque la citation est nécessaire, le caractère barre oblique inverse est utilisé pour citer le caractère suivant. Par exemple

  Abc\@def@example.com

est une forme valide d'adresse e-mail. Des espaces vides peuvent également apparaître, comme dans

  Fred\ Bloggs@example.com

Le caractère barre oblique inverse peut également être utilisé pour se citer, par exemple,

  Joe.\\Blow@example.com

Outre les guillemets utilisant le caractère barre oblique inverse, des caractères de guillemet double conventionnels peuvent être utilisés pour entourer les chaînes. Par exemple

  "Abc@def"@example.com

  "Fred Bloggs"@example.com

sont des formes alternatives des deux premiers exemples ci-dessus. Ces formulaires cités sont rarement recommandés et sont rares dans la pratique, mais, comme indiqué ci-dessus, ils doivent être pris en charge par les applications qui traitent les adresses e-mail. En particulier, les formes citées apparaissent souvent dans le contexte d'adresses associées à des transitions à partir d'autres systèmes et contextes; ces exigences transitoires existent toujours et, comme un système qui accepte une adresse e-mail fournie par l'utilisateur ne peut pas "savoir" si cette adresse est associée à un système hérité, les formulaires d'adresse doivent être acceptés et transmis dans l'environnement de messagerie.

Sans guillemets, les parties locales peuvent être constituées de n'importe quelle combinaison de
caractères alphabétiques, de chiffres ou de l'un des caractères spéciaux

  ! # $ % & ' * + - / = ?  ^ _ ` . { | } ~

La période (".") peut également apparaître, mais ne peut pas être utilisée pour démarrer ou terminer la partie locale, ni deux périodes consécutives ou plus. Autrement dit, tout caractère graphique (impression) ASCII autre que le signe at ("@"), la barre oblique inverse, les guillemets doubles, les virgules ou les crochets peuvent apparaître sans guillemets. Si l'un de cette liste de caractères exclus doit apparaître, ils doivent être cités. Des formes telles que

  user+mailbox@example.com

  customer/department=shipping@example.com

  $A12345@example.com

  !def!xyz%abc@example.com

  _somename@example.com

sont valides et sont vus assez régulièrement, mais tous les caractères énumérés ci-dessus sont autorisés.

Comme d'autres l'ont fait, je soumets une expression régulière qui fonctionne à la fois pour PHP et JavaScript pour valider les adresses e-mail:

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

Comme on peut le trouver dans ce lien Wikipedia

La partie locale de l'adresse e-mail peut utiliser l'un de ces caractères ASCII:

• lettres latines majuscules et minuscules Avers Zet avers z;

• chiffres 0à 9;

• caractères spéciaux !#$%&'*+-/=?^_`{|}~;

• point ., à condition qu'il ne soit pas le premier ou le dernier caractère à moins d'être cité, et à condition qu'il n'apparaisse pas consécutivement à moins d'être cité (par exemple, John..Doe@example.comn'est pas autorisé mais "John..Doe"@example.comest autorisé);

• l'espace et les "(),:;<>@[\]caractères sont autorisés avec des restrictions (ils ne sont autorisés qu'à l'intérieur d'une chaîne entre guillemets, comme décrit dans le paragraphe ci-dessous, et en outre, une barre oblique inverse ou un guillemet double doit être précédé d'une barre oblique inverse);

• les commentaires sont autorisés avec des parenthèses à chaque extrémité de la partie locale; par exemple john.smith(comment)@example.comet (comment)john.smith@example.comsont tous deux équivalents à john.smith@example.com.

En plus des caractères ASCII ci-dessus, les caractères internationaux supérieurs à U + 007F, codés en UTF-8, sont autorisés par la RFC 6531 , bien que les systèmes de messagerie puissent restreindre les caractères à utiliser lors de l'attribution de parties locales.

Une chaîne entre guillemets peut exister en tant qu'entité séparée par des points dans la partie locale, ou elle peut exister lorsque les guillemets les plus à l'extérieur sont les caractères les plus à l'extérieur de la partie locale (par exemple, abc."defghi".xyz@example.comou "abcdefghixyz"@example.comsont autorisés. Inversement, ce abc"defghi"xyz@example.comn'est pas le cas, ni l'un ni l'autre abc\"def\"ghi@example.com). Cependant, les chaînes et les caractères cités ne sont pas couramment utilisés. La RFC 5321 prévient également qu '"un hôte qui s'attend à recevoir du courrier DEVRAIT éviter de définir des boîtes aux lettres où la partie locale requiert (ou utilise) le formulaire de chaîne entre guillemets".

La partie locale postmasterest traitée spécialement, elle ne respecte pas la casse et doit être transmise à l'administrateur de messagerie du domaine. Techniquement, toutes les autres parties locales sont sensibles à la casse jsmith@example.comet JSmith@example.comspécifient donc différentes boîtes aux lettres; cependant, de nombreuses organisations traitent les lettres majuscules et minuscules comme équivalentes.

Malgré le large éventail de caractères spéciaux techniquement valables; les organisations, les services de messagerie, les serveurs de messagerie et les clients de messagerie dans la pratique ne les acceptent souvent pas tous. Par exemple, Windows Live Hotmail autorise uniquement la création d'adresses e-mail à l'aide des caractères alphanumériques, des points ( .), des traits de soulignement ( _) et des tirets ( -). Le conseil commun est d'éviter d'utiliser certains caractères spéciaux pour éviter le risque d'e-mails rejetés.

La réponse est (presque) ALL(ASCII 7 bits).
Si les règles d'inclusion sont "... autorisées sous certaines conditions / toutes / aucune ..."

En examinant simplement l'une des nombreuses règles d'inclusion possibles pour le texte autorisé dans la partie "texte de domaine" de la RFC 5322 en haut de la page 17, nous trouvons:

dtext          =   %d33-90 /          ; Printable US-ASCII
                   %d94-126 /         ;  characters not including
                   obs-dtext          ;  "[", "]", or "\"

les trois seuls caractères manquants dans cette description sont utilisés dans le domaine littéral [], pour former une paire entre guillemets \, et le caractère d'espace blanc (% d32). Avec cela, toute la plage 32-126 (décimale) est utilisée. Une exigence similaire apparaît comme "qtext" et "ctext". De nombreux caractères de contrôle sont également autorisés / utilisés. Une liste de ces caractères de contrôle apparaît à la page 31 section 4.1 de la RFC 5322 en tant que obs-NO-WS-CTL.

obs-NO-WS-CTL  =   %d1-8 /            ; US-ASCII control
                   %d11 /             ;  characters that do not
                   %d12 /             ;  include the carriage
                   %d14-31 /          ;  return, line feed, and
                   %d127              ;  white space characters

Tous ces caractères de contrôle sont autorisés comme indiqué au début de la section 3.5:

.... MAY be used, the use of US-ASCII control characters (values
     1 through 8, 11, 12, and 14 through 31) is discouraged ....

Et une telle règle d'inclusion est donc "trop ​​large". Ou, dans un autre sens, la règle attendue est "trop ​​simpliste".

Par souci de simplicité, je désinfecte la soumission en supprimant tout le texte entre guillemets doubles et les guillemets environnants associés avant la validation, en mettant le kibosh sur les soumissions d'adresse e-mail en fonction de ce qui n'est pas autorisé. Juste parce que quelqu'un peut avoir le John .. "Le * $ hizzle * Bizzle" .. L'adresse Doe@wwhat.com ne signifie pas que je dois l'autoriser dans mon système. Nous vivons dans le futur où il faudra peut-être moins de temps pour obtenir une adresse e-mail gratuite que pour faire un bon travail en essuyant vos fesses. Et ce n'est pas comme si les critères de courrier électronique n'étaient pas collés juste à côté de l'entrée indiquant ce qui est et ce qui n'est pas autorisé.

Je désinfecte également ce qui n'est pas spécifiquement autorisé par divers RFC après que le matériel cité est supprimé. La liste des caractères et modèles spécifiquement interdits semble être une liste beaucoup plus courte à tester.

Interdit:

    local part starts with a period ( .account@host.com )
    local part ends with a period   ( account.@host.com )
    two or more periods in series   ( lots..of...dots@host.com )
    &’`*|/                          ( some&thing`bad@host.com )
    more than one @                 ( which@one@host.com )
    :%                              ( mo:characters%mo:problems@host.com )

Dans l'exemple donné:

John.."The*$hizzle*Bizzle"..Doe@whatever.com --> John..Doe@whatever.com

John..Doe@whatever.com --> John.Doe@whatever.com

L'envoi d'un e-mail de confirmation au résultat restant lors d'une tentative d'ajout ou de modification de l'adresse e-mail est un bon moyen de voir si votre code peut gérer l'adresse e-mail soumise. Si l'e-mail réussit la validation après autant de cycles de désinfection que nécessaire, lancez cette confirmation. Si une demande revient du lien de confirmation, le nouvel e-mail peut être déplacé du statut de purgatoire ou de stockage || temporaire || pour devenir un véritable e-mail stocké de première classe.

Une notification d'échec ou de réussite du changement d'adresse e-mail peut être envoyée à l'ancienne adresse e-mail si vous voulez être prévenant. Les configurations de compte non confirmées peuvent tomber du système en tant que tentatives infructueuses entièrement après un laps de temps raisonnable.

Je n'autorise pas les e-mails stinkhole sur mon système, peut-être que c'est simplement jeter de l'argent. Mais, 99,9% du temps, les gens font juste ce qu'il faut et ont un e-mail qui ne repousse pas les limites de conformité au bord du gouffre en utilisant des scénarios de compatibilité avec les cas limites. Faites attention aux DDoS regex, c'est un endroit où vous pouvez avoir des ennuis. Et cela est lié à la troisième chose que je fais, je mets une limite à la durée pendant laquelle je suis prêt à traiter un seul e-mail. Si elle doit ralentir ma machine pour être validée, elle ne dépasse pas la logique du point de terminaison de mon API de données entrantes.

Edit: Cette réponse a continué à être teintée d'être "mauvaise", et peut-être qu'elle le méritait. Peut-être que c'est encore mauvais, peut-être pas.

Dans mon PHP, j'utilise cette vérification

<?php
if (preg_match(
'/^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+@(?:(?:(?:[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_]?)|(?:\[(?:(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\]))$/',
"tim'qqq@gmail.com"        
)){
    echo "legit email";
} else {
    echo "NOT legit email";
}
?>

essayez-le vous-même http://phpfiddle.org/main/code/9av6-d10r

J'ai créé cette expression régulière selon les directives RFC:

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

Gmail n'autorisera que le signe + en tant que caractère spécial et dans certains cas (.), Mais aucun autre caractère spécial n'est autorisé sur Gmail. Les RFC indiquent que vous pouvez utiliser des caractères spéciaux, mais vous devez éviter d'envoyer des messages à Gmail avec des caractères spéciaux.