Notice: session_start() [function.session-start]: ps_files_cleanup_dir: opendir(/var/lib/php5) failed: Permission denied (13) in /home/expreg/mvc/main.php on line 43
Contrôle syntaxique d'une adresse email sur ExpReg

Général

Les PCRE

Les POSIX

Pratique

Linux

Spécial php

Les billets de fred

Contrôle syntaxique d'une adresse email

Vous savez tous ce qu'est une adresse email et sous quelle forme elle se présente.
Qui a dit non ?
Exemple d'une adresse email : info@expreg.com

Un peu d'histoire !

Pourquoi cette syntaxe avec le fameux @ ?

L'adresse email, sous la forme que nous lui connaissons, est née en 1972.

C'est l'ingénieur Ray Tomlinson qui a mis au point le premier programme de messagerie électronique (alors qu'il travaillait sur des projets du gouvernement américain qui ont donné naissance à Internet).
Il a eu l'idée de composer chaque adresse e-mail de deux éléments:

le nom de la personne et le nom de l'ordinateur.
Il fallait bien évidement séparer ces deux noms, mais avec quoi, avec quel caractère ? Il ne fallait pas que ce soit un caractère pouvant se trouver dans un nom de personne ou de société.

Un caractère se trouvait sur toutes les machines à écrire, mais n'était que très peu utilisé.
Le @ ou "commercial at" en anglais. Ce caractère que l'on trouvait dans les documents commerciaux anglo-saxons, signifie littéralement "au prix de".

Chez nous, on appelle généralement ce caractère "arobase".

Construction d'une adresse email

Cohérence et lisibilité

Une adresse email cohérente, lisible et mémorisable est toujours construite sur le modèle de user@host.

Bien qu'une multitude d'hébergeurs offrant le service gratuit d'email acceptent des emails que je qualifierais de "farfelues" ou "bancales", souvenez-vous qu'une adresse email simple est à préconiser dans tous les cas de figure.

La partie composant l'user, ne doit contenir que des chiffres/lettres ainsi que les caractères tels que l'underscore (_), le tiret (-) ou le point(.)
La partie user doit commencer uniquement par un caractère alphanumérique

Vient ensuite l'arobase @

Chacun sait qu'un nom de domaine ne peut contenir rien d'autre que des lettres/chiffres et le tiret (-).
En se basant sur cette syntaxe, la partie composant l'host ne pourra donc contenir que des chiffres/lettres et le tiret(-).
Néanmoins, il nous faut tenir compte des sous-domaines qui peuvent précéder le domaine principal en étant séparé de celui-çi par un point.

Vient ensuite l'extension dont les plus courantes en international sont .com, .net, .org.
Il en existe d'autres, ainsi que toutes les extensions propres aux pays, tels que .be pour la Belgique, .fr pour la France, .it pour l'Italie, .de pour l'Allemagne, etc...

En savoir un peu plus :
>>> SELFHTML

Vérification d'une adresse email

Passoire ou pas ?

Comme dit un peu plus haut, des hébergeurs tels que caramail, hotmail et bien d'autres acceptent des adresses email totalement farfelues du genre :

mon_nom______@hotmail.com ou mon---_.._---nom@caramail.com

Avouez que c'est sympa à retenir une adresse email avec 25 underscores ou tiret à la suite.
M'enfin, si ce genre de gamineries en amusent plus d'un, je ne vais les priver de leur plaisir.
Donc, pour gérer ces inepties, il leur suffira de créer une regex dite "passoire".
A la limite, même pas besoin de regex, un strpos(); sur l'arobase est amplement suffisant.

Bon redevenons sérieux !
Dans le cadre de diversses programmations, j'ai été amener à réaliser des contrôles sur ces adresses email.
Pas assez restrictif et on tombe dans la caramail mania, trop restrictif, on en zappe beaucoup trop.
Je me suis donc attelé à créer un motif qui, sur des emails cohérentes et sensées, fait bien son travail.

J'ai permis l'extension de domaine sur 6 caractères pour autoriser les types .museum Le voici :


<?php
if(!preg_match('`^[[:alnum:]]([-_.]?[[:alnum:]_?])*@[[:alnum:]]([-.]?[[:alnum:]])+\.([a-z]{2,6})$`',
$chaine))
{
echo 'pas bon';
}
else
{
echo 'bon';
}
?>

Une petite amélioration de la regex précédente s'impose afin d'éviter la possibilité de doublon de signe du genre -_
Le tour est joué en sortant l'underscore de la parenthèse et en le plaçant juste avant l'arobase, ce qui nous donne, maintenant, une regex qui tient vraiment la route face à des emails farfelues, mais qui, il faut le dire sont acceptées sur des sites comme caramail ou hotmail.
<?php
$chaine='truc-chose_machin_@expreg.com';
if(!preg_match('`^[[:alnum:]]([-_.]?[[:alnum:]])+_?@[[:alnum:]]([-.]?[[:alnum:]])+\.[a-z]{2,6}$`',$chaine))
{
echo 'pas bon';
}
else
{
echo 'bon';
}
?>


Vous trouverez un peu partout sur le web, d'autres modèles de vérification d'email, que vous pourrez bien évidement utiliser.
Le regex présentée ici offre juste l'avantage d'éviter les trucs farfelus, dénués de bons sens.

Il est impossible de parler d'email sans vous parler de la norme RFC822. Les règles de syntaxe d'une email valide sont régies par cette norme qui excusez-moi de l'expression est quelques peu (je suis sympa) saugrenue.

Sont autorisés quasiment tous les types de caractères, tels que |/*-$#^`&´%£_=+?{!§}

Voici un lien vous permettant de passer à un validator une email farfelue qui a beaucoup de chance d'être acceptée.   >>> Validator d'email à la norme RFC822

Vous voulez voir un truc de fou ?

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

Gloups ! Euuuuuh oui... je vous comprend, un truc à vomir !
Mais, si on s'en réfère à la norme RFC822, voilà à quoi devrait normalement ressembler votre regex pour accepter toutes les emails considérées comme valides.
C'est un truc de ouf je ne vous le fait pas dire.
ADAM Benjamin 2008 | Admin