Design & Développement web - Le topic des canards qui mangent des cookies

[elkoo]

/^(([^<>()[\]\\.,;:\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,}))$/.test(email);

Même pas J'ai pas trouvé la version suivant la dernière norme qui comprend l'internationalisation (avec lettres accentuées par exemple) mais c'est plus ça (en php):

<?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*)
?>

C'est pour ça que la meilleur solution passe par un lien de vérification envoyé à l'adresse indiquée par l'utilisateur, ainsi une vérification légère par expression régulière est suffisante.

Edit :

Mhh... Ça fait pas 200 cents lignes ça !

On s'en rapproche là

[Møgluglu]

Et que du coup, au lieu d'écrire "a ? b : c" (l'opérateur ternaire), on peut écrire "a && b || c" (à condition que b soit non-null et différent de 0)

Tu as commencé à préparer une soumission à l'OCCC, récemment ?

Note que c'est pas forcément équivalent pour le compilo. S'il n'arrive pas à prouver que b est faux, il va générer une arête de l'évaluation de b vers l'évaluation de c. Ça fera un graphe en losange. Et là, !!OMG11§§, ça veut dire que le graphe de flot de contrôle n'est plus structuré. Große malhör !

(Pour pas être hors-sujet, je crois me souvenir d'un benchmark Javascript qui avait un return au milieu d'une boucle et dont on s'étonnait que les perfs soient pathétiques sous un browser Microsoft quelconque. Les CFG non structurés, c'est le mal.)

[Tomaka17]

C'est pour ça que la meilleur solution passe par un lien de vérification envoyé à l'adresse indiquée par l'utilisateur, ainsi une vérification légère par expression régulière est suffisante.

Ce sont deux choses différentes.

L'expression régulière est là pour indiquer à l'utilisateur qu'il a fait une typo dans son adresse.
Si tu veux vérifier que l'utilisateur est propriétaire de l'adresse qu'il indique, il faut lui envoyer un email.

---------- Post added at 11h50 ---------- Previous post was at 11h46 ----------

Tu as commencé à préparer une soumission à l'OCCC, récemment ?

Note que c'est pas forcément équivalent pour le compilo. S'il n'arrive pas à prouver que b est faux, il va générer une arête de l'évaluation de b vers l'évaluation de c. Ça fera un graphe en losange. Et là, !!OMG11§§, ça veut dire que le graphe de contrôle de flot n'est plus structuré. Große malheur !

(Pour pas être hors-sujet, je crois me souvenir d'un benchmark Javascript qui avait un return au milieu d'une boucle et dont on s'étonnait que les perfs soient pathétiques sous un browser Microsoft quelconque. Les CFG non structurés, c'est le mal.)

En fait c'est surtout à cause d'AngularJS que j'ai utilisé cette technique.

Angular tu lui dis par exemple: ce <span> doit toujours contenir la valeur "var1 + var2". Le mini interpréteur d'Angular va alors déterminer que tu as une dépendance avec var1 et var2, et donc à chaque fois que tu modifies var1 ou var2, il va devoir mettre à jour le contenu du <span>.
Le problème c'est qu'Angular ne supporte pas l'opérateur ternaire, du coup tu es obligé d'utiliser ce trick && ||, qui lui fonctionne.

[Monsieur Odd]

Même pas J'ai pas trouvé la version suivant la dernière norme qui comprend l'internationalisation (avec lettres accentuées par exemple) mais c'est plus ça (en php):

<?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*)
?>

C'est pour ça que la meilleur solution passe par un lien de vérification envoyé à l'adresse indiquée par l'utilisateur, ainsi une vérification légère par expression régulière est suffisante.

Edit :
On s'en rapproche là

RFC mail ?

[Møgluglu]

(Pour pas être hors-sujet, je crois me souvenir d'un benchmark Javascript qui avait un return au milieu d'une boucle et dont on s'étonnait que les perfs soient pathétiques sous un browser Microsoft quelconque. Les CFG non structurés, c'est le mal.)

Retrouvé : http://www.developerfusion.com/news/...g-allegations/
Bon, c'était pas exactement une histoire de code non-structuré, plutôt de dépendance de contrôle faisant foirer l'élimination de code mort (http://blogs.msdn.com/b/ie/archive/2...evelopers.aspx).

Le problème c'est qu'Angular ne supporte pas l'opérateur ternaire, du coup tu es obligé d'utiliser ce trick && ||, qui lui fonctionne.

Comme quoi, les dévs sur les vraies machines, on n'a pas le monopole des trucs crades.

[tenshu]

Comme quoi, les dévs sur les vraies machines, on n'a pas le monopole des trucs crades.

On parle bien de javascript ?

[elkoo]

Ce sont deux choses différentes.

L'expression régulière est là pour indiquer à l'utilisateur qu'il a fait une typo dans son adresse.
Si tu veux vérifier que l'utilisateur est propriétaire de l'adresse qu'il indique, il faut lui envoyer un email.

Absolument! C'était bien le sens de mon intervention, mais j'ai manqué de précision, un peu comme une blague à la Møgluglu.
Ceci dit tu veux dire quoi par "mec qui fait une typo", un designer? C'est vrai qu'ils sont étranges ceux là.
:mec qui comprend vraiment rien:

[Skiant]

Absolument! C'était bien le sens de mon intervention, mais j'ai manqué de précision, un peu comme une blague à la Møgluglu.
Ceci dit tu veux dire quoi par "mec qui fait une typo", un designer? C'est vrai qu'ils sont étranges ceux là.
:mec qui comprend vraiment rien:

"typo" en anglais = "coquille" en français.

/JELB

[elkoo]

"typo" en anglais = "coquille" en français.

/JELB

C'est définitif, j'adore ce topic

[rOut]

Mais Tomaka, tu ne peux pas remplacer :

(a ? 0 : coin(a))

par :

(a && 0 || coin(a))

Et certes dans ce cas c'est simple mais comme le dis Mogluglu, si tu as deux fonctions dont tu ne sais pas trop ce qu'elles vont retourner :

(a ? nioc(a) : coin(a))

n'est pas non plus équivalent à :

(a && nioc(a) || coin(a))

Ca si nioc(a) s'évalue par hasard à faux, tu vas retourner coin(a) à la place alors que le premier code aurait bien retourné nioc(a). Et puis je pense même que ce que tu vas retourner c'est la conversion en booléen du résultat et pas ce qu'on retourné les fonctions.

[Tomaka17]

Oui j'ai dit à la base : à condition que b soit différent de 0 et tout.
En revanche tu as tort quand tu dis "Et puis je pense même que ce que tu vas retourner c'est la conversion en booléen du résultat et pas ce qu'on retourné les fonctions.", car c'est justement ça l'intérêt du truc.

De toutes façons comme dit j'utilise ça pour Angular. Si je mettais des fonctions, autant utiliser une fonction qui fasse l'opérateur ternaire aussi.
Là ce sont pour des cas simples, comme : liste.size >= 2 && "éléments" || "élément"

[Møgluglu]

(a && nioc(a) || coin(a))

Ca si nioc(a) s'évalue par hasard à faux, tu vas retourner coin(a) à la place alors que le premier code aurait bien retourné nioc(a).

Bah, si c'est que ça le problème, suffit d'utiliser l'opérateur true non-documenté du C :

(a && ~!nioc(a) || coin(a))

liste.size >= 2 && "éléments" || "élément"

1

[Tomaka17]

1

En fait vous avez pas suivi

Si liste.size est inférieur à 2, l'intérpréteur voit ça comme un false, du coup il sait que le && est forcément false. Il reste juste le || à calculer, et comme ce qui est à gauche est false, pour gagner du temps il renvoie ce qui est à droite, puisque c'est ça qui va déterminer le résultat final. Du coup il renvoie "élément".

Si liste.size est supérieur à 2, l'interpréteur voit ça comme un true, et du coup la valeur finale du && c'est égal à "éléments". Il voit que "éléments" est true, du coup le || est de toutes façons vrai, et le || renvoie non pas true mais "éléments".

C'est la magie des langages interprétés.

[tompalmer]

How tomaka sees us

[Møgluglu]

C'est la magie des langages interprétés.

OK, le type de a || b, c'est a ? typeof(a) : typeof(b), et pour && c'est le contraire. Sounds legit.
Par contre tu peux pas employer l'opérateur ~! là.

Cette façon de prendre les pires hacks de C et Fortran pour les ériger en concepts de base dans les langages "modernes", je trouve ça sublime.

[Anon26492]

C'est quoi le langage moderne ici ?
JavaScript ?

[tenshu]

C'est quoi le langage moderne ici ?
JavaScript ?

Elle a 7H de retard ta blague

[Anon26492]

Les bonnes blagues sont répétables

[MrBeaner]

do {
 document.write (blague);
} while (blague == "bonne");

:iknowkungfu:

[rOut]

while((console.log(blague),blague) == "bonne");

[Anon26492]

function Lol(blague, auteur, qualite) {
  this.blague  = blague;
  this.auteur  = auteur;
  this.qualite = qualite;
}

Lol.prototype.bla= function () {
  return "Le/La "+this.blague+" de "+this.auteur+" est "+this.qualite;
};

var mine  = new Lol("blague", "mdt", "bonne"),
    yours = new Lol("code", "tenshu ", "moche");

console.log( mine.bla()+", "+yours.bla() );

Eat this !

[tenshu]

Méchant

[Tomaka17]

Les gens qui font de la POO avec javascript

[rOut]

Genre 99% des gens qui font du javascript de nos jours quoi.

[war-p]

C'est pas comme si le langage avait été pensé pour... le premier péquenau venu

[Tomaka17]

Non mais, vous savez au moins que quand vous faites "new X" en javascript, c'est simplement un appel de la fonction X ? C'est une pure bidouille !

Javascript c'est pratiquement un langage fonctionnel et ils ont rajouté des bidouilles pour faire orienté-objets parce que c'était à la mode à l'époque.

[Møgluglu]

C'est pas comme si le langage avait été pensé pour programmer.

J'ai bien rempli les pointillés ?
Edit: salow.

OCaml c'est pratiquement un langage fonctionnel et ils ont rajouté des bidouilles pour faire orienté-objets parce que c'était à la mode à l'époque.

Fixed aussi.

[rOut]

Fixed aussi.

Ca va, personne ne fait de l'OCaml.

[tenshu]

Non mais, vous savez au moins que quand vous faites "new X" en javascript, c'est simplement un appel de la fonction X ? C'est une pure bidouille !

Ca falloir que tu t'y habitues, le JS est là pour rester.
Avec ses qualités et tout pleins de défauts pas beaux.

[war-p]

Ca va, personne ne fait de l'OCaml.

Si... :vapleurerdansuncoin: