Comment valider une adresse email en JavaScript ?

StackOverflow https://stackoverflow.com/questions/46155

Question

Comment valider une adresse email en JavaScript ?

Était-ce utile?

La solution

En utilisant expressions régulières est probablement la meilleure façon.Vous pouvez voir un tas de tests ici (pris à partir de chrome)

function validateEmail(email) {
    var re = /^(([^<>()\[\]\\.,;:\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,}))$/;
    return re.test(String(email).toLowerCase());
}

Voici l'exemple d'une expression régulière qui accepte l'Unicode :

var re = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;

Mais gardez à l’esprit qu’il ne faut pas se fier uniquement à la validation JavaScript.JavaScript peut facilement être désactivé.Cela doit également être validé côté serveur.

Voici un exemple de ce qui précède en action :

function validateEmail(email) {
  var re = /^(([^<>()[\]\\.,;:\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,}))$/;
  return re.test(email);
}

function validate() {
  var $result = $("#result");
  var email = $("#email").val();
  $result.text("");

  if (validateEmail(email)) {
    $result.text(email + " is valid :)");
    $result.css("color", "green");
  } else {
    $result.text(email + " is not valid :(");
    $result.css("color", "red");
  }
  return false;
}

$("#validate").on("click", validate);
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<form>
  <p>Enter an email address:</p>
  <input id='email'>
  <button type='submit' id='validate'>Validate!</button>
</form>

<h2 id='result'></h2>

Autres conseils

Juste pour être complet, ici vous avez une autre expression régulière conforme à la RFC 2822

La norme officielle est connue sous le nom de RFC2822.Il décrit la syntaxe à laquelle les adresses e-mail valides doivent adhérer.Tu peux (mais tu ne devrais pas — continuer à lire) implémentez-le avec cette expression régulière :

(?:[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])+)\])

(...) Nous obtenons une implémentation plus pratique de la RFC 2822 si nous omettons la syntaxe utilisant des guillemets doubles et des crochets. Il correspondra toujours à 99,99 % de toutes les adresses e-mail réellement utilisées aujourd’hui.

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

Un autre changement que vous pourriez apporter consiste à autoriser tout domaine de premier niveau de code de pays à deux lettres, et uniquement des domaines de premier niveau génériques spécifiques. Cette expression régulière filtre les adresses e-mail factices telles que asdf@adsf.adsf.Toi devra le mettre à jour à mesure que de nouveaux domaines de premier niveau seront ajoutés.

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[A-Z]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\b

Ainsi, même en suivant les normes officielles, des compromis restent à faire. Ne copiez pas aveuglément les expressions régulières des bibliothèques en ligne ou des forums de discussion.Testez-les toujours sur vos propres données et avec vos propres applications.

C'est moi qui souligne

J'ai légèrement modifié la réponse de Jaymon pour les personnes qui souhaitent une validation très simple sous la forme de :

n'importe quelle chaîne @ n'importe quelle chaîne. n'importe quelle chaîne

L'expression régulière :

/\S+@\S+\.\S+/

Exemple de fonction JavaScript :

function validateEmail(email) 
{
    var re = /\S+@\S+\.\S+/;
    return re.test(email);
}

Wow, il y a beaucoup de complexité ici.Si tout ce que vous voulez faire est simplement détecter les erreurs de syntaxe les plus évidentes, je ferais quelque chose comme ceci :

^\S+@\S+$

Il détecte généralement les erreurs les plus évidentes commises par l'utilisateur et garantit que le formulaire est en grande partie correct, ce qui est l'essence même de la validation JavaScript.

Il y a quelque chose que vous devez comprendre à la seconde où vous décidez d'utiliser une expression régulière pour valider les e-mails : Ce n'est probablement pas une bonne idée.Une fois que vous avez compris cela, il existe de nombreuses implémentations qui peuvent vous aider à mi-chemin, cet article les résume bien.

En bref, cependant, la seule façon d'être absolument sûr que ce que l'utilisateur a saisi est bien un e-mail est d'envoyer un e-mail et de voir ce qui se passe.A part ça, ce ne sont que des suppositions.

HTML5 lui-même a une validation par e-mail.Si votre navigateur prend en charge HTML5, vous pouvez utiliser le code suivant.

<form><input type="email" placeholder="me@example.com" required>
    <input type="submit">
</form>

jsFiddle lien

Du Spécification HTML5:

UN Adresse e-mail valable est une chaîne qui correspond au email production de l'ABNF suivant, dont le jeu de caractères est Unicode.

email   = 1*( atext / "." ) "@" label *( "." label )
label   = let-dig [ [ ldh-str ] let-dig ]  ; limited to a length of 63 characters by RFC 1034 section 3.5
atext   = < as defined in RFC 5322 section 3.2.3 >
let-dig = < as defined in RFC 1034 section 3.5 >
ldh-str = < as defined in RFC 1034 section 3.5 >

Cette exigence est une violation délibérée de la RFC 5322, qui définit une syntaxe pour les adresses e-mail à la fois trop stricte (avant le caractère "@"), trop vague (après le caractère "@") et trop laxiste (autorisant les commentaires, les espaces et les guillemets). chaînes d'une manière peu familière à la plupart des utilisateurs) pour être d'une utilité pratique ici.

L'expression régulière compatible JavaScript et Perl suivante 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])?)*$/

J'ai trouvé que c'était la meilleure solution :

/^[^\s@]+@[^\s@]+\.[^\s@]+$/

Il autorise les formats suivants :

1.  prettyandsimple@example.com
2.  very.common@example.com
3.  disposable.style.email.with+symbol@example.com
4.  other.email-with-dash@example.com
9.  #!$%&'*+-/=?^_`{}|~@example.org
6.  "()[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.a"@example.org
7.  " "@example.org (space between the quotes)
8.  üñîçøðé@example.com (Unicode characters in local part)
9.  üñîçøðé@üñîçøðé.com (Unicode characters in domain part)
10. Pelé@example.com (Latin)
11. δοκιμή@παράδειγμα.δοκιμή (Greek)
12. 我買@屋企.香港 (Chinese)
13. 甲斐@黒川.日本 (Japanese)
14. чебурашка@ящик-с-апельсинами.рф (Cyrillic)

Il est clairement polyvalent et autorise les caractères internationaux les plus importants, tout en appliquant le format de base any@anything.anything.Cela bloquera les espaces techniquement autorisés par RFC, mais ils sont si rares que je suis heureux de le faire.

Dans les navigateurs modernes, vous pouvez vous appuyer sur la réponse de @Sushil avec du JavaScript pur et le DOMAINE:

function validateEmail(value) {
  var input = document.createElement('input');

  input.type = 'email';
  input.required = true;
  input.value = value;

  return typeof input.checkValidity === 'function' ? input.checkValidity() : /\S+@\S+\.\S+/.test(value);
}

J'ai rassemblé un exemple au violon http://jsfiddle.net/boldewyn/2b6d5/.Combiné avec la détection de fonctionnalités et la validation simple de Réponse de Squirtle, il vous libère du massacre des expressions régulières et ne gêne pas les anciens navigateurs.

JavaScript peut correspondre à une expression régulière :

emailAddress.match( / some_regex /);

Voici un RFC22 expression régulière pour les e-mails :

^((?>[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+\x20*|"((?=[\x01-\x7f])[^"\\]|\\[\x01-\x7f])*
"\x20*)*(?<angle><))?((?!\.)(?>\.?[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+)+|"((?=[\x01-\x
7f])[^"\\]|\\[\x01-\x7f])*")@(((?!-)[a-zA-Z\d\-]+(?<!-)\.)+[a-zA-Z]{2,}|\[(((?(?<
!\[)\.)(25[0-5]|2[0-4]\d|[01]?\d?\d)){4}|[a-zA-Z\d\-]*[a-zA-Z\d]:((?=[\x01-\x7f])
[^\\\[\]]|\\[\x01-\x7f])+)\])(?(angle)>)$

Il s'agit de la version correcte de la RFC822.

function checkEmail(emailAddress) {
  var sQtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]';
  var sDtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]';
  var sAtom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+';
  var sQuotedPair = '\\x5c[\\x00-\\x7f]';
  var sDomainLiteral = '\\x5b(' + sDtext + '|' + sQuotedPair + ')*\\x5d';
  var sQuotedString = '\\x22(' + sQtext + '|' + sQuotedPair + ')*\\x22';
  var sDomain_ref = sAtom;
  var sSubDomain = '(' + sDomain_ref + '|' + sDomainLiteral + ')';
  var sWord = '(' + sAtom + '|' + sQuotedString + ')';
  var sDomain = sSubDomain + '(\\x2e' + sSubDomain + ')*';
  var sLocalPart = sWord + '(\\x2e' + sWord + ')*';
  var sAddrSpec = sLocalPart + '\\x40' + sDomain; // complete RFC822 email address spec
  var sValidEmail = '^' + sAddrSpec + '$'; // as whole string

  var reValidEmail = new RegExp(sValidEmail);

  return reValidEmail.test(emailAddress);
}

Toutes les adresses e-mail contiennent un « at » (c'est-à-dire@) symbole.Testez cette condition nécessaire :

email.indexOf("@") > 0

Ne vous embêtez pas avec quelque chose de plus compliqué.Même si vous pouviez parfaitement déterminer si un e-mail est syntaxiquement valide selon la RFC, cela ne vous dirait pas s'il appartient à la personne qui l'a fourni.C'est ce qui compte vraiment.

Pour tester cela, envoyez un message de validation.

La validation correcte de l'adresse e-mail conformément aux RFC n'est pas quelque chose qui peut être réalisé avec une expression régulière à une seule ligne.Un article avec la meilleure solution que j'ai trouvée en PHP est Qu'est-ce qu'une adresse email valide ?.Évidemment, il a été porté sur Java. Je pense que la fonction est trop complexe pour être portée et utilisée en JavaScript. Port JavaScript/node.js : https://www.npmjs.com/package/email-addresses.

Une bonne pratique consiste à valider vos données sur le client, mais à revérifier la validation sur le serveur.Dans cette optique, vous pouvez simplement vérifier si une chaîne ressemble à une adresse e-mail valide sur le client et effectuer une vérification stricte sur le serveur.

Voici la fonction JavaScript que j'utilise pour vérifier si une chaîne ressemble à une adresse mail valide :

function looksLikeMail(str) {
    var lastAtPos = str.lastIndexOf('@');
    var lastDotPos = str.lastIndexOf('.');
    return (lastAtPos < lastDotPos && lastAtPos > 0 && str.indexOf('@@') == -1 && lastDotPos > 2 && (str.length - lastDotPos) > 2);
}

Explication:

  • lastAtPos < lastDotPos:Dernier @ devrait être avant-dernier . depuis @ ne peut pas faire partie du nom du serveur (pour autant que je sache).

  • lastAtPos > 0:Il devrait y avoir quelque chose (le nom d'utilisateur de l'e-mail) avant le dernier @.

  • str.indexOf('@@') == -1:Il ne devrait y avoir aucun @@ dans l'adresse.Même si @ apparaît comme dernier caractère du nom d'utilisateur de l'e-mail, il doit être cité ainsi " serait entre ça @ et le dernier @ dans l'adresse.

  • lastDotPos > 2:Il doit y avoir au moins trois caractères avant le dernier point, par exemple a@b.com.

  • (str.length - lastDotPos) > 2:Il doit y avoir suffisamment de caractères après le dernier point pour former un domaine à deux caractères.Je ne sais pas si les crochets sont nécessaires.

Cela a été volé à http://codesnippets.joyent.com/posts/show/1917

email = $('email');
filter = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
if (filter.test(email.value)) {
  // Yay! valid
  return true;
}
else
  {return false;}

J'ai vraiment hâte de résoudre ce problème.J'ai donc modifié l'expression régulière de validation des e-mails ci-dessus

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

  • Modifié
    /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+[^<>()\.,;:\s@\"]{2,})$/

passer les exemples dans Adresse e-mail Wikipédia.

Et vous pouvez voir le résultat dans ici.

enter image description here

Faites ceci :

[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])?

Pourquoi? C'est basé sur RFC2822, qui est une norme à laquelle TOUTES les adresses e-mail DOIVENT adhérer.Et je ne sais pas pourquoi vous vous embêteriez avec quelque chose de "plus simple"...tu vas le copier et le coller de toute façon ;)

Souvent, lors du stockage des adresses e-mail dans la base de données, je les mets en minuscules et, en pratique, les expressions régulières peuvent généralement être marquées comme insensibles à la casse.Dans ces cas, c'est légèrement plus court :

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

Voici un exemple d'utilisation en JavaScript (avec l'indicateur insensible à la casse i à la fin).

var emailCheck=/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;
console.log( emailCheck.test('some.body@domain.co.uk') );

Note:
Techniquement, certains e-mails peuvent inclure des citations dans la section précédant le @ symbole avec des caractères d'échappement à l'intérieur des guillemets (afin que votre utilisateur de messagerie puisse être désagréable et contenir des éléments comme @ et "..." à condition que ce soit écrit entre guillemets).PERSONNE NE FAIT JAMAIS CELA !C'est obsolète.Mais, il EST inclus dans le vrai RFC2822 standard, et omis ici.

Plus d'informations: http://www.regular-expressions.info/email.html

Vous ne devez pas utiliser d'expressions régulières pour valider une chaîne d'entrée afin de vérifier s'il s'agit d'un e-mail.C'est trop compliqué et ne couvrirait pas tous les cas.

Maintenant que vous ne pouvez couvrir que 90 % des cas, écrivez quelque chose comme :

function isPossiblyValidEmail(txt) {
   return txt.length > 5 && txt.indexOf('@')>0;
}

Vous pouvez l'affiner.Par exemple, « aaa@ » est valide.Mais dans l’ensemble, vous comprenez l’essentiel.Et ne vous laissez pas emporter...Une solution simple à 90 % vaut mieux qu’une solution à 100 % qui ne fonctionne pas.

Le monde a besoin d'un code plus simple...

Vérifiez simplement si l’adresse e-mail saisie est valide ou n’utilise pas HTML.

<input type="email"/>

Il n'est pas nécessaire d'écrire une fonction pour la validation.

C'est ainsi validateur de nœud le fait-il :

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

Il est difficile d'obtenir un validateur d'e-mails correct à 100 %.Le seul véritable moyen de corriger la situation serait d'envoyer un e-mail de test au compte.Cela dit, quelques vérifications de base peuvent vous aider à vous assurer que vous obtenez quelque chose de raisonnable.

Quelques points à améliorer :

Au lieu de nouveau RegExp, essayez simplement d'écrire le regexp dehors comme ceci :

if (reg.test(/@/))

Deuxièmement, vérifiez qu'il y a des règles après le @ signe et assurez-vous qu'il y a des caractères entre les @s et périodes.

Utilisez ce code dans votre fonction de validation :

var emailID = document.forms["formName"]["form element id"].value;
atpos = emailID.indexOf("@");
dotpos = emailID.lastIndexOf(".");
if (atpos < 1 || ( dotpos - atpos < 2 ))
{
    alert("Please enter correct email ID")
    return false;
}

Sinon, vous pouvez utiliser jQuery.Les règles internes définissent :

eMailId: {
    required: true,
    email: true
}

Mise à jour des expressions régulières 2018 !essaye ça

let val = 'email@domain.com';
if(/^[a-z0-9][a-z0-9-_\.]+@([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[a-z]{2,10})?$/.test(val)) {
   console.log('passed');
}

version dactylographiée terminée

//
export const emailValid = (val:string):boolean => /^[a-z0-9][a-z0-9-_\.]+@([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[a-z]{2,10})?$/.test(val);

Plus d'informations https://git.io/vhEfc

Meilleure expression régulière conforme à la RFC5322

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

Une solution qui ne vérifie pas l’existence du TLD est incomplète.

Presque toutes les réponses à ces questions suggèrent d'utiliser Regex pour valider les adresses e-mail.Je pense que Regex n'est bon que pour une validation rudimentaire.Il semble que la vérification de la validation des adresses e-mail pose en réalité deux problèmes distincts :

1- Validation du format email : S'assurer que l'e-mail est conforme au format et au modèle d'e-mail de la RFC 5322 et si le TLD existe réellement.Une liste de tous les TLD valides peut être trouvée ici.

Par exemple, même si l'adresse example@example.ccc transmettra l'expression régulière, ce n'est pas un email valide, car ccc n'est pas un domaine de premier niveau par l'IANA.

2- S'assurer que l'email existe réellement : Pour faire cela, la seule option est pour envoyer un email aux utilisateurs.

Apparemment, c'est ça :

/^([\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

Pris à partir de http://fightingforalostcause.net/misc/2006/compare-email-regex.php le 1er octobre 2010.

Mais bien sûr, c’est ignorer l’internationalisation.

Contrairement à écureuil, voici une solution complexe, mais elle fait un excellent travail de validation correcte des e-mails :

function isEmail(email) { 
    return /^((([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.test(email);
}

Utilisez comme ceci :

if (isEmail('youremail@yourdomain.com')){ console.log('This is email is valid'); }

Voici une très bonne discussion sur l'utilisation d'expressions régulières pour valider les adresses e-mail ;"Comparaison des adresses e-mail et validation des expressions régulières"

Voici la principale expression actuelle, compatible avec JavaScript, à titre de référence :

/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+)*\.(aero|arpa|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org|pro|travel|mobi|[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i

Ma connaissance de expressions régulières n'est pas si bon que ça.C'est pourquoi je vérifie d'abord la syntaxe générale avec une simple expression régulière et vérifie ensuite les options plus spécifiques avec d'autres fonctions.Ce n'est peut-être pas la meilleure solution technique, mais de cette façon, je suis beaucoup plus flexible et plus rapide.

Les erreurs les plus courantes que j'ai rencontrées sont les espaces (surtout au début et à la fin) et parfois un double point.

function check_email(val){
    if(!val.match(/\S+@\S+\.\S+/)){ // Jaymon's / Squirtle's solution
        // Do something
        return false;
    }
    if( val.indexOf(' ')!=-1 || val.indexOf('..')!=-1){
        // Do something
        return false;
    }
    return true;
}

check_email('check@thiscom'); // Returns false
check_email('check@this..com'); // Returns false
check_email(' check@this.com'); // Returns false
check_email('check@this.com'); // Returns true

<form name="validation" onSubmit="return checkbae()">
    Please input a valid email address:<br />

    <input type="text" size=18 name="emailcheck">
    <input type="submit" value="Submit">
</form>

<script language="JavaScript1.2">
    var testresults
    function checkemail(){
        var str = document.validation.emailcheck.value
        var filter = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i
        if (filter.test(str))
            testresults = true
        else {
            alert("Please input a valid email address!")
            testresults = false
        }
        return (testresults)
    }
</script>

<script>
    function checkbae(){
        if (document.layers || document.getElementById || document.all)
            return checkemail()
        else
            return true
    }
</script>

L'expression régulière fournie par Microsoft dans ASP.NET MVC est

/^[\w-]+(\.[\w-]+)*@([a-z0-9-]+(\.[a-z0-9-]+)*?\.[a-z]{2,6}|(\d{1,3}\.){3}\d{1,3})(:\d{4})?$/

Que je poste ici au cas où il serait défectueux - même s'il a toujours été parfait pour mes besoins.

Syntaxe de courrier standard de Wikipédia :

https://en.wikipedia.org/wiki/Email_address#Examples https://fr.wikipedia.org/wiki/Adresse_%C3%A9lectronique#Syntaxe_exacte

function validMail(mail)
{
    return /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+([^<>()\.,;:\s@\"]{2,}|[\d\.]+))$/.test(mail);
}

// VALID MAILS

validMail('Abc@example.com') // Return true
validMail('Abc@example.com.') // Return true
validMail('Abc@10.42.0.1') // Return true
validMail('user@localserver') // Return true
validMail('Abc.123@example.com') // Return true
validMail('user+mailbox/department=shipping@example.com') // Return true
validMail('"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com') // Return true
validMail('!#$%&\'*+-/=?^_`.{|}~@example.com') // Return true
validMail('"()<>[]:,;@\\\"!#$%&\'-/=?^_`{}| ~.a"@example.org') // Return true
validMail('"Abc@def"@example.com') // Return true
validMail('"Fred Bloggs"@example.com') // Return true
validMail('"Joe.\\Blow"@example.com') // Return true
validMail('Loïc.Accentué@voilà.fr') // Return true
validMail('" "@example.org') // Return true
validMail('user@[IPv6:2001:DB8::1]') // Return true

// INVALID MAILS

validMail('Abc.example.com') // Return false
validMail('A@b@c@example.com') // Return false
validMail('a"b(c)d,e:f;g<h>i[j\k]l@example.com') // Return false
validMail('just"not"right@example.com') // Return false
validMail('this is"not\allowed@example.com') // Return false
validMail('this\ still\"not\\allowed@example.com') // Return false
validMail('john..doe@example.com') // Return false
validMail('john.doe@example..com') // Return false

Montrez ce test : https://regex101.com/r/LHJ9gU/1

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top