Comment valider une adresse email en JavaScript?

Comment une adresse e-mail peut-elle être validée en JavaScript?

Utiliser des expressions régulières est probablement le meilleur moyen. Vous pouvez voir un tas de tests ici (pris du 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(Ssortingng(email).toLowerCase()); } 

Voici l’exemple de l’expression régulière qui accepte unicode:

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

Mais gardez à l’esprit qu’il ne faut pas compter uniquement sur la validation JavaScript. JavaScript peut facilement être désactivé. Cela devrait é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").bind("click", validate); 
  

Enter an email address:

Pour être complet, vous avez ici une autre regex conforme à la RFC 2822

La norme officielle est connue sous le nom de RFC 2822 . Il décrit la syntaxe à laquelle les adresses électroniques valides doivent adhérer. Vous pouvez ( mais vous ne devriez pas – lire ) l’implémenter 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 en utilisant des guillemets et des crochets. Il correspondra toujours à 99,99% de toutes les adresses e-mail actuellement utilisées.

[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 pouvez apporter est d’autoriser tout domaine de premier niveau à code à deux lettres et seulement certains domaines génériques de premier niveau. Cette regex filtre les adresses e-mail fictives comme asdf@adsf.adsf . Vous devrez 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])?\.)+(?:[AZ]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\b

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

Accent mis à moi

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:

anyssortingng@anyssortingng.anyssortingng

L’expression régulière:

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

Exemple de fonction JavaScript:

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

Il y a quelque chose que vous devez comprendre au moment où vous décidez d’utiliser une expression régulière pour valider les emails: ce n’est probablement pas une bonne idée . Une fois que vous avez compris cela, il y a beaucoup d’implémentations là-bas qui peuvent vous mener à mi-chemin, cet article les résume bien.

En résumé, cependant, le seul moyen d’être absolument sûr est que ce que l’utilisateur a entré est en fait un courrier électronique qui consiste à envoyer un courrier électronique et à voir ce qui se passe. A part ça, tout n’est que des suppositions.

Wow, il y a beaucoup de complexité ici. Si tout ce que vous voulez faire, c’est d’attraper 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 correct, ce qui est la raison d’être de la validation JavaScript.

HTML5 lui-même a la validation de courrier électronique. Si votre navigateur prend en charge HTML5, vous pouvez utiliser le code suivant.

 

Lien jsFiddle

A partir de la spécification HTML5 :

Une adresse de messagerie valide est une chaîne qui correspond à la production de email 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 volontaire de la RFC 5322, qui définit une syntaxe pour les adresses de messagerie simultanément trop ssortingcte (avant le caractère “@”), trop vague (après le caractère “@”) et trop laxiste (permettant des commentaires , les caractères d’espacement, et les chaînes de caractères citées dans des manières peu familières à la plupart des utilisateurs) sont utiles 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 permet les formats suivants:

 1. prettyandsimple@example.com
 2. very.common@example.com
 3. jetable.style.email.with+symbol@example.com
 4. other.email-with-dash@example.com
 9. #!$%&'*+-/=?^_`{}|~@example.org
 6. "() []:,; @ \\\"! # $% & '* + - / =? ^ _ `{} |  ~ .a "@ example.org
 7. "" @ example.org (espace entre les guillemets)
 8. üñîçøðé@exemple.com (caractères Unicode dans la partie locale)
 9. üñîçøðé@üñîçøðé.com (caractères Unicode dans la partie domaine)
 10. Pelé@example.com (latin)
 11. δοκιμή@παράδειγμα.δοκιμή (grec)
 12. 我 買 @ 屋企. 香港 (chinois)
 13. 甲 斐 @ 黒 川. 日本 (japonais)
 14. чебурашка@ящик-с-апельсинами.рф (cyrillique)

Il est clairement polyvalent et autorise les caractères internationaux les plus importants, tout en respectant le format élémentaire 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 JavaScript et le DOM :

 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 mis en place un exemple dans le violon http://jsfiddle.net/boldewyn/2b6d5/ . Combiné à la détection de fonctionnalités et à la validation de base de Squirtle’s Answer , il vous libère du massacre par expression régulière et ne se fige pas sur les anciens navigateurs.

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

 emailAddress.match( / some_regex /); 

Voici une expression régulière RFC22 pour les emails:

 ^((?>[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+\x20*|"((?=[\x01-\x7f])[^"\\]|\\[\x01-\x7f])* "\x20*)*(?< ))?((?!\.)(?>\.?[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)>)$ 

Ceci est la version correcte de 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 sQuotedSsortingng = '\\x22(' + sQtext + '|' + sQuotedPair + ')*\\x22'; var sDomain_ref = sAtom; var sSubDomain = '(' + sDomain_ref + '|' + sDomainLiteral + ')'; var sWord = '(' + sAtom + '|' + sQuotedSsortingng + ')'; 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 ssortingng var reValidEmail = new RegExp(sValidEmail); return reValidEmail.test(emailAddress); } 

Une validation correcte de l’adresse électronique en conformité avec les RFC ne peut pas être réalisée avec une expression régulière à une seule ligne. Un article avec la meilleure solution que j’ai trouvé dans PHP est Qu’est-ce qu’une adresse e-mail valide? . De toute évidence, il a été porté sur Java. Je pense que la fonction est trop complexe pour être scope et utilisée dans JavaScript.

Une bonne pratique consiste à valider vos données sur le client, mais à vérifier la validation sur le serveur. Dans cette optique, vous pouvez simplement vérifier si une chaîne ressemble à une adresse électronique valide sur le client et effectuer une vérification ssortingcte 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 : Last @ devrait être avant dernier . car @ 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 messagerie) avant le dernier @ .

  • str.indexOf('@@') == -1 : Il ne devrait y avoir aucun @@ dans l'adresse. Même si @ apparaît comme le dernier caractère du nom d'utilisateur, il doit être indiqué de manière à ce qu'il soit "entre @ et le dernier @ de l'adresse".

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

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

Toutes les adresses électroniques contiennent un symbole “at” (ie @). 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 email est RFC-syntaxiquement valide, cela ne vous dirait pas s’il appartient à la personne qui l’a fourni. C’est ce qui compte vraiment.

Pour le tester, envoyez un message de validation.

Cela a été volé de 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;} 

Je suis vraiment impatient de résoudre ce problème. J’ai donc modifié l’expression régulière de validation d’e-mail 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,})$/

pour passer les exemples dans l’adresse e-mail Wikipedia .

Et vous pouvez voir le résultat ici .

entrer la description de l'image ici

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? Il est basé sur la RFC 2822 , qui est une norme TOUS les adresses électroniques DOIVENT adhérer.

Souvent, lorsque vous stockez des adresses e-mail dans la firebase database, je les convertis en minuscules et, en pratique, les expressions rationnelles peuvent généralement être 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 courriels peuvent inclure des guillemets dans la section avant le symbole @ avec des caractères d’échappement dans les guillemets (votre utilisateur de messagerie peut donc être désagréable et contenir des éléments comme @ et "..." tant qu’il est écrit entre guillemets). Personne ne le fait jamais! C’est obsolète Mais, il est inclus dans le vrai standard RFC 2822 , et omis ici.

Plus d’infos: http://www.regular-expressions.info/email.html

Vous ne devez pas utiliser des expressions régulières pour valider une chaîne de saisie pour vérifier s’il s’agit d’un courrier électronique. 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 obtenez 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 …

Il suffit de vérifier si l’adresse e-mail entrée est valide ou ne pas utiliser HTML.

  

Il n’y a pas besoin d’écrire une fonction pour la validation.

Voici comment le validateur de noeud le fait:

 /^(?:[\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-mail à 100% correct. Le seul moyen réel de le faire est d’envoyer un email de test au compte. Cela dit, il y a quelques vérifications de base qui peuvent vous aider à obtenir quelque chose de raisonnable.

Quelques choses à améliorer:

Au lieu du nouveau RegExp , essayez d’écrire le regexp comme ceci:

 if (reg.test(/@/)) 

Deuxièmement, assurez-vous qu’une période suit le signe @ et assurez-vous qu’il y a des caractères entre les @ et les périodes.

Apparemment c’est ça:

 /^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[az])\.)+[az]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$/i 

Tiré de http://fightingforalostcause.net/misc/2006/compare-email-regex.php le 1er octobre 2010.

Mais, bien sûr, cela ne tient pas compte de l’internationalisation.

In contrast to squirtle , here is a complex solution, but it does a mighty fine job of validating emails properly:

 function isEmail(email) { return /^((([az]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([az]|\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)))@((([az]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([az]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([az]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([az]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([az]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([az]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([az]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([az]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i.test(email); } 

Use like so:

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

Use this code inside your validator function:

 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; } 

Else you can use jQuery . Inside rules define:

 eMailId: { required: true, email: true } 

A solution that does not check the existence of the TLD is incomplete.

Almost all answers to this questions suggest using Regex to validate emails addresses. I think Regex is only good for a rudimentary validation. It seems that the checking validation of email addresses is actually two separate problems:

1- Validation of email format: Making sure if the email complies with the format and pattern of emails in RFC 5322 and if the TLD actually exists. A list of all valid TLDs can be found here .

For example, although the address example@example.ccc will pass the regex, it is not a valid email, because ccc is not a top-level domain by IANA.

2- Making sure the email actually exists: For doing this, the only option is to send the users an email .

Best regex ever which confirms with the 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])+

Here is a very good discussion about using regular expressions to validate email addresses; ” Comparing E-mail Address Validating Regular Expressions ”

Here is the current top expression, that is JavaScript compatible, for reference purposes:

 /^[-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|[az][az])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i 

My knowledge of regular expressions is not that good. That’s why I check the general syntax with a simple regular expression first and check more specific options with other functions afterwards. This may not be not the best technical solution, but this way I’m way more flexible and faster.

The most common errors I’ve come across are spaces (especially at the beginning and end) and occasionally a double dot.

 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 
 
Please input a valid email address:

Regex update 2018! essaye ça

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

typscript version complete

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

more info https://git.io/vhEfc

The regular expression provided by Microsoft within ASP.NET MVC is

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

Which I post here in case it’s flawed – though it’s always been perfect for my needs.

Wikipedia standard mail syntax :

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;gi[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 

Show this test : https://regex101.com/r/LHJ9gU/1