Comment valider une adresse e-mail en JavaScript

Existe-t-il une expression régulière pour valider une adresse e-mail en JavaScript?

L'utilisation d' expressions régulières est probablement la meilleure façon. Vous pouvez voir un tas de tests ici (tirés du chrome )

function validateEmail(email) {
    const 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 unicode:

const 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 devrait également être validé côté serveur.

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

function validateEmail(email) {
  const 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() {
  const $result = $("#result");
  const 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>

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:

anystring@anystring.anystring

L'expression régulière:

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

Exemple de fonction JavaScript:

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

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

La norme officielle est connue sous le nom de RFC 2822 . Il décrit la syntaxe à laquelle les adresses e-mail valides doivent adhérer. Vous pouvez ( mais vous ne devriez pas - lire la suite ) 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 RFC 2822 si nous omettons la syntaxe en utilisant des guillemets doubles 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])?

Une autre modification 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 commeasdf@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])?\.)+(?:[A-Z]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\b

Ainsi, même en suivant les normes officielles, il y a encore des compromis à 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.

_{Emphase mine}

Wow, il y a beaucoup de complexité ici. Si tout ce que vous voulez faire 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 en grande partie correct, c'est à cela que sert 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 accepté 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, positivement sûr que ce que l'utilisateur a entré est en fait un e-mail est d'envoyer réellement un e-mail et de voir ce qui se passe. A part ça, tout n'est que 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>

jsFiddleLien

De la spécification HTML5 :

Une adresse de messagerie valide est une chaîne qui correspond à la emailproduction 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 un violation délibérée de la RFC 5322, qui définit une syntaxe pour les adresses électroniques qui est à la fois trop stricte (avant le caractère "@"), trop vague (après le caractère "@") et trop laxiste (autorisant les commentaires , les espaces blancs et les chaînes entre guillemets d'une manière que la plupart des utilisateurs ne connaissent pas) pour être 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. üñîçøðé@example.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 personnages internationaux très importants, tout en appliquant le format de base everything@anything.anything. Cela bloquera les espaces qui sont 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 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 rassemblé un exemple dans le violon http://jsfiddle.net/boldewyn/2b6d5/ . Combiné avec la détection des fonctionnalités et la validation à nu de Squirtle's Answer , il vous libère du massacre d'expression régulière et ne fonctionne pas sur les anciens navigateurs.

Il s'agit de la bonne version du 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);
}

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

emailAddress.match( / some_regex /);

Voici une expression régulière RFC22 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)>)$

Toutes les adresses e-mail contiennent un symbole «at» (c'est-à-dire @). 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 RFC-syntaxiquement valide, cela ne vous dirait pas s'il appartient à la personne qui l'a fourni. C'est ça qui compte vraiment.

Pour tester cela, envoyez un message de validation.

Une validation correcte de l'adresse e-mail conformément aux RFC n'est pas quelque chose qui peut être obtenu avec une expression régulière à une ligne. Un article avec la meilleure solution que j'ai trouvée en 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 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érifiez la validation sur le serveur. Dans cet esprit, 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 e-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 last .car @ne peut pas faire partie du nom du serveur (pour autant que je sache).

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

• str.indexOf('@@') == -1: Il ne devrait pas y avoir d' @@adresse. Même s'il @apparaît comme le dernier caractère du nom d'utilisateur de l'e-mail, il doit être cité, il "devrait donc être compris entre celui-ci @et le dernier @de 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;}

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 à laquelle TOUTES les adresses électroniques DOIVENT adhérer. Et je ne sais pas pourquoi vous vous embêtez avec quelque chose de "plus simple" ... vous allez quand même le copier et le coller;)

Souvent, lorsque je stocke des adresses e-mail dans la base de données, je les mets en minuscules et, dans la pratique, les expressions régulières peuvent généralement être marquées insensibles à la casse. Dans ces cas, cela 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 de son utilisation en JavaScript (avec le drapeau insensible ià la casse à 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') );

Remarque :
Techniquement, certains e-mails peuvent inclure des guillemets dans la section précédant le @symbole avec des caractères d'échappement à l'intérieur des guillemets (de sorte que votre utilisateur de messagerie peut ê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 la vraie norme RFC 2822 et omis ici.

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

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 l'adresse e-mail Wikipedia .

Et vous pouvez voir le résultat ici .

Vous ne devez pas utiliser d'expressions régulières pour valider une chaîne d'entrée pour 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 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 ...

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.

Il est difficile d'obtenir un validateur d'e-mails 100% correct. Le seul véritable moyen de le corriger serait d'envoyer un e-mail de test au compte. Cela dit, il existe quelques vérifications de base qui 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 regexptexte comme ceci:

if (reg.test(/@/))

Ensuite, vérifiez qu'un point vient après le @signe et assurez-vous qu'il y a des caractères entre le @s et le point.

Voici comment le validateur de nœuds 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])\]))$/

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 Regex 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

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 soit en fait deux problèmes distincts:

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

Par exemple, bien que l'adresse example@example.cccpasse le regex, ce n'est pas un e-mail valide, car ce cccn'est pas un domaine de premier niveau par IANA.

2- S'assurer que l'e-mail existe réellement: Pour ce faire, la seule option est d'envoyer un e-mail aux utilisateurs .

Regex pour la validation de l'adresse e-mail

[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 une très bonne discussion sur l'utilisation des expressions régulières pour valider les adresses e-mail; " Comparaison des adresses e-mail de validation des expressions régulières "

Voici l'expression top actuelle, compatible JavaScript, à des fins 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

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

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

Mais, bien sûr, cela ignore l'internationalisation.

Contrairement à Squirtle , 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 ça:

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

Ma connaissance des expressions régulières n'est pas très bonne. C'est pourquoi je vérifie d'abord la syntaxe générale avec une simple expression régulière et vérifie ensuite des 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 des espaces (en particulier 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>

Je cherchais une Regex dans JS qui passe tous les cas de test d'adresse e-mail:

• email@example.com Email valide

• firstname.lastname@example.com L'email contient un point dans le champ d'adresse

• email@subdomain.example.com L'e-mail contient un point avec un sous-domaine

• firstname+lastname@example.com Le signe plus est considéré comme un caractère valide

• email@192.0.2.123 Le domaine est une adresse IP valide

• email@[192.0.2.123] Le crochet autour de l'adresse IP est considéré comme valide

• “email”@example.com Les citations concernant le courrier électronique sont considérées comme valides

• 1234567890@example.com Les chiffres de l'adresse sont valides

• email@domain-one.example Le tiret dans le nom de domaine est valide

• _______@example.com Le soulignement dans le champ d'adresse est valide

• email@example.name .name est un nom de domaine de premier niveau valide

• email@example.co.jpLe point dans le nom de domaine de premier niveau est également considéré comme valide (en utilisant co.jpcomme exemple ici)

• firstname-lastname@example.com Le tiret dans le champ d'adresse est valide

Et c'est parti :

http://regexr.com/3f07j

OU regex:

Regex = /(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@[*[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+]*/

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})?$/

Ce que je poste ici au cas où il serait défectueux - bien qu'il ait toujours été parfait pour mes besoins.