Comment valider une adresse e-mail en JavaScript

Comment valider une adresse e-mail en JavaScript

Expression régulière pour valider l'adresse e-mail en javascript?

Montrez la meilleure réponse

veuillez bien faire, trop de sites Web n'aiment pas mon adresse e-mail "firstName@secondName.name", tous les domaines de premier niveau ne terminent pas 2 ou 3 lettres.

Le fait que la faible correspondance de modèles de Javascript ne soit pas en mesure de valider entièrement une adresse de messagerie compatible RFC ne signifie pas que vous ne pouvez jamais résoudre ce problème avec un seul modèle. En fait, vous pouvez, et voici deux solutions qui le font.

Tout support pour l'utilisation de chèques regex pour les e-mails, je suis contre à 100%. J'en ai assez qu'on me dise que mon adresse e-mail "foo+bar@gmail.com" n'est pas valide. La meilleure option est de demander à l'utilisateur de taper son e-mail deux fois et si vous DEVEZ utiliser un vérificateur d'expressions régulières, puis de dire à l'utilisateur que son adresse e-mail ne semble pas être valide et de lui demander s'il est sûr de l'avoir tapé droite. Allez même jusqu'à signaler CE QUI n'a pas été vérifié lors de la vérification d'expression régulière, mais ne les empêchez PAS de soumettre le formulaire.

Avatar WoJ

@ Soundfx4: cela devrait être LA réponse, et accepté comme tel. Tester l'exactitude d'une adresse est une chose stupide à faire - la meilleure façon de frustrer les clients. Je demande que l'adresse soit tapée deux fois et laisse entendre qu'il y a des problèmes possibles (@ , ;com , etc. manquants) et laisse l'utilisateur les corriger s'il le souhaite (et accepte tout ils m'envoient)

Je suis totalement d'accord avec la réponse donnée par WoJ. Le format d'une adresse e-mail valide est beaucoup trop complexe pour être vérifié avec une simple expression régulière. La seule façon d'être certain que l'adresse est valide est de l'essayer.

pattern = "[a-zA-Z0-9 ._% + -] + @ (?: [a-zA-Z0-9 -] + \.) + [a-zA-Z] {2,4} ‌ "Ne me semble pas si mal (le '4' aurait dû être mis à jour il y a des années). Mais je suis d'accord que dire aux gens qu'ils ne connaissent pas leur propre adresse est mauvais. Pas aussi mauvais que de me dire que je ne connais pas mon propre nom, ce qui s'est également produit!

Avez-vous vraiment besoin de Javascript pour ce faire (ce que vous ne devriez pas faire)? Bien qu'il y ait eu deux erreurs dans l'expression, il me semble qu'une méthode beaucoup plus simple a été mentionnée dans stackoverflow.com/questions/52030222/…

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

emailAddress.match( / some_regex /);
 

Voici une 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)>)$
 

Le nœud ne semble pas pouvoir compiler cette expression régulière

Avatar Ry-

@Kato: Il utilise des extensions incompatibles, notamment (?> pour arrêter le retour en arrière et (?<angle><)…(?(angle)>) pour éviter de fournir un | long.

L'utilisation des expressions régulières est probablement le meilleur moyen. Vous pouvez voir un tas de tests ici (tiré 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 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 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").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>  

Avatar Jon

Quelqu'un pourrait-il expliquer à quoi cela va et ne va pas correspondre? (Compte tenu de certaines des réponses supplémentaires ci-dessous.) Il serait bon de connaître un peu plus d'informations afin de déterminer la «solution» à utiliser pour un projet.

+1: La seule chose que cela ne laisse pas passer, ce sont les adresses IP plutôt que les domaines. Il accepte les domaines commençant ou se terminant par un tiret, et les domaines de plus de 64 caractères, mais à part cela, cela fait un assez bon travail. À votre santé.

Cette expression régulière élimine les e-mails valides et en cours d'utilisation. Ne pas utiliser. Google pour "RFC822" ou "RFC2822" pour obtenir une expression régulière appropriée.

@Randall: Pouvez-vous donner un exemple d'adresse e-mail que cela ne laissera pas passer?

Cela fonctionne bien pour moi, bien que j'obtienne une erreur de compilation («[») lors de son utilisation avec Appcelerator. Cependant, cela ne semble pas du tout poser de problème avec la validation.

Notez que tous les IDN devront être punis avant que cette expression régulière ne les accepte; tout IDN de niveau supérieur valide sera rejeté même sous forme de punycode (car le préfixe xn- ne correspondra pas à [a-zA-Z] ).

Pourquoi sur la ligne var re = ... ESLint dit: Échappé ']', échappé '[', les espaces sont difficiles à compter, utilisez {2}?

Il existe un cas de test complet des adresses e-mail à isemail.info/_system/is_email/test/?all ... (voir isemail.info pour plus de détails).

Il y a une section sur la validation RFC2822 au bas de cette page: regular-expressions.info/email. html

Avatar P.M

a.ert#@example.com passe :-)

Cela n'accepte même pas les exemples de la RFC 822. Dans certains cas simples, cela ne correspond pas à a \ @ b @ c.com, a(b)@c.com. Voir le RFC pour plus. Voici une expression régulière qui ne rejettera aucune adresse valide [^ @] + @ [^ @] + \. [^ @] + Et protège contre les erreurs courantes.

@BenRoberts n @ ai - adresse e-mail valide, en cours d'utilisation, elle échoue

@GoodPerson J'ai juste essayé d'envoyer un e-mail à n @ ai pour lui dire qu'il a une adresse e-mail sympa. Mais hélas, gmail ne m'a pas laissé faire. Je soupçonne que celui qui a de plus gros problèmes de communication avec les autres par e-mail que la validation javascript de mon site! Mais merci d'avoir relevé le défi.

Je me demande pourquoi lorsque j'ai entré lname_fname#@yahoo.com, il a accepté l'e-mail? Signification '#' est autorisé?

C'est une solution qui semble bonne avec la plupart des anglophones natifs, mais elle échoue au test de la Turquie (voir Joel Spolsky). La plupart des lettres Unicode sont autorisées, et par exemple en Argentine, des adresses telles que "ñoñó1234@server.com" sont parfaitement normales. joelonsoftware.com/articles/Unicode.html

le trait de soulignement (_) devrait être validé à la première place, je suppose.

Des exemples d'adresses e-mail valides marquées comme non valides sont postbox @ com et user @ [IPv6: 2001: db8: 1ff :: a0b: dbd0] voir en.wikipedia.org/wiki/Email_address#Valid_email_addresses

@Ben c'est la méthode générique intégrée dans une expression régulière. developer.mozilla.org/en-US/ docs / Web / JavaScript / Référence /…

Cela passe pour ı@a.aa (ce premier caractère est bizarre), qui a récemment foiré notre système.

@rossipedia exemple d'adresses e-mail valides qu'il n'analyse pas? par exemple: !#$%&'*+-/=?^_`{}|~@example.org , ou postbox@com , ou " "@example.org tiré de wikipedia

Pour toutes les personnes qui disent que c'est "assez bien": regardez, vous pensez simplement mal à ce problème. C'est bon. C'est un choix que vous pouvez faire pour vos utilisateurs. Je ne suis pas en colère contre ça. Mais, vous savez, techniquement parlant, vous avez manifestement et prouvablement tort.

c'est cassé pour nhjh@d.vn.hjhhhkkk :(

Vous ne pouvez pas valider les adresses e-mail, point final. Le seul qui peut valider une adresse e-mail est le fournisseur de l'adresse e-mail. Par exemple, cette réponse indique que ces adresses e-mail: %2@gmail.com, "%2"@gmail.com, "a..b"@gmail.com, "a_b"@gmail.com, _@gmail.com, 1@gmail.com , 1_example@something.gmail.com sont toutes valides, mais Gmail n'autorisera jamais aucune de ces adresses e-mail. Vous devez le faire en acceptant l'adresse e-mail et en envoyant un e-mail à cette adresse e-mail, avec un code / lien que l'utilisateur doit visiter pour confirmer la validité.

Pour plus d'informations sur ce à quoi il correspond correctement, consultez la liste suivante emailtester.pieterhordijk.com/test -pattern / MTA4

@BenRoberts MyFakeEmail@dnedomain.com n'existe pas. Et pourtant, l'expression régulière le laissera passer.

Selon wikipedia, l'unicode peut également exister dans le nom de domaine. var re = ...|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; doit être var re = ...|(([^<>()[\]\\.,;:\s@\"]+\.)+[a-zA-Z]{2,}))$/;

Cela valide: "foo@10.0.0.0.com"

Il existe des facteurs autres que RFC822 pour déterminer ce que peut être une adresse e-mail - par exemple, a@a est RFC822 valide, mais les domaines `` sans point '' sont interdits par l'ICANN, elle doit donc être considérée comme invalide.

Si vous devez l'utiliser avec l'API HTML5 Pattern au lieu d'utiliser type="email" , vous devrez coder les guillemets comme par exemple. <input pattern="^(([^<>()[\]\\.,;:\s@\&quot;]+(\.[^<>()[\]\\.,;:\s@‌​\&quot;]+)*)|(\&quot‌​;.+\&quot;))@((\[[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,})‌​)$" id="email" name="email" type="text">

De nos jours, Javascript peut être exécuté sur un serveur, donc pour ceux qui pensent que cela n'est pertinent que pour la validation côté client, vous vous trompez. Et à ceux qui disent qu'il n'est pas possible de valider un email je crois que vous manquez le point de validation en général. VOUS N'ÉCRIREZ JAMAIS la validation d'un formulaire pour vous assurer que tout est parfait à 100% pour deux raisons principales: 1. Cela prendrait plus de temps qu'il n'en vaudrait la peine d'écrire la logique et 2. Il y aura toujours un cas limite où les mauvaises données pourrait être soumis. La raison pour laquelle nous validons est d'encourager la bonne soumission des données et d'éviter les erreurs.

cela échoue pour «ajey@gmail.comsadasd»

Attention, ce n'est pas valide: re.test("username+something@gmail.com")

Également non valide: test@something.melbourne et autres nouveaux TLD.

김지후 @ 삼성. 닷컴 ne fonctionnera pas ici, ni aucune des nouvelles adresses non latines.

ceci n'est pas valide pour test + google.com devrait être: 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,})) $ /;

Maintenant que nous avons des domaines comme .ninja .photography et ainsi de suite, j'ajouterais {2,} à la dernière vérification: /^((\\w- diplomatique+(?:\.[\w- diplomatique+)*)@ ((?: [\ w -] + \.) * \ w [\ w -] {0,66}) \. ([az] ‌ {2,} (?: \. [az] {2} )?) ‌ $ / i

Le test @BenRoberts \\\ @ mailinator.com est laissé de côté par cette expression régulière :(

@Brian - le pauvre gars est également laissé de côté par Gmail et Apple Mail ... :(

De toute évidence, vous ne pouvez pas valider une adresse e-mail avec JavaScript ou RegEx. Mais je pense que la réponse démontre "Voici une façon quelque peu valable de dire si le fouillis de caractères entré dans une zone de texte de courrier électronique est très probablement un format de courrier électronique. Je pense que cela donne à quelqu'un qui poserait assez cette question de travailler avec. en fait, pour valider les courriels turcs, ils doivent comprendre ses limites. Sinon, utilisez-les jusqu'à ce que vous tombiez sur un accroc et que vous répétiez, comme tous les autres programmeurs!

Avatar PSR

Cette validation échoue pour les identifiants de messagerie des alias gmail. Ex: firstname.lastname+test@gmail.com

Cette réponse n'accepte pas un e-mail valide Gmail comme "foo+bar@gmail.com"

Tout support pour l'utilisation de chèques regex pour les e-mails, je suis contre à 100%. J'en ai assez qu'on me dise que mon adresse e-mail "foo+bar@gmail.com" n'est pas valide. La meilleure option est de demander à l'utilisateur de taper son e-mail deux fois et si vous DEVEZ utiliser un vérificateur d'expressions régulières, puis de dire à l'utilisateur que son adresse e-mail ne semble pas être valide et de lui demander s'il est sûr de l'avoir tapé droite. Allez même jusqu'à signaler CE QUI n'a pas été vérifié lors de la vérification d'expression régulière, mais ne les empêchez PAS de soumettre le formulaire.

Quant à «ne valide pas» - le premier regex en jette environ la moitié: en. wikipedia.org/wiki/… , par exemple piskvor@example.lighting ; notez que plus de TLD au-delà de la taille \.[a-z]{2,8} ont été créés depuis 2011. (C'est une liste de TLD approuvés par l'IANA; peu m'importe si quelqu'un considère .horse frivole, je me soucie seulement si c'est canonique - et ça l'est). Edit: Aha, je vois que le regex a été complètement changé en mars.

cette expression régulière utilise des groupes de capture, avec ne sont pas nécessaires dans ce contexte et peuvent entraîner des problèmes de performances.

Essayez 1.2@gmail.com . l'expression régulière correspondrait à :(

l'expression régulière correspond également à d^&fvf#3d@frf.fffffefefe qui, je suppose, n'est pas un identifiant de messagerie valide?

stream@2x-fab0f8.png = true :)

me's@mess.co.uk.in is valid :) devrait-il être?

Cette expression doit être mise à jour pour ne pas honorer l'adresse e-mail en utilisant des adresses IP au lieu des noms de domaine, même si ceux-ci sont techniquement corrects.

@ AndersLindén En utilisant le lien ci-dessous pour le test unitaire et si l'adresse IP n'est pas valide, comptez également pour ne pas respecter les éléments suivants: email @ [123.123.123.123] codefool.tumblr.com/post/15288874550/…

@nwolybug Le cas d'utilisation d'avoir des adresses IP dans les adresses e-mail est si étroit qu'il devrait être omis.

--@ooo.ooo est-ce une adresse e-mail valide.

Ne fonctionne pas pour Abc@10.42.0.1 et Loïc.Accentué@voilà.fr

@Liberateur Comme il se doit. voilà.fr n'est pas un nom de domaine valide. En particulier, le à doit être encodé avec punycode dans le nom de domaine. Je ne connais pas l'encodage punycode réel, mais quelque chose comme Loïc.Accentué@voil--xa.fr validera ... comme il se doit.

Ai-je fait quelque chose de mal: nouveau RegExp ('^ (([^ <> () [] \.,; \ S @ \ "] + (\. [^ <> () [] \. ‌,; : \ s @ \ "] +) *) | (\". + \ ‌ ")) @ (([^ <> () [] \. ‌,;: \ s @ \"] + \. ) + [^ <> () ‌ [] \.,;: \ S @ \ "] {2, ‌}) $ ',' i '). Test ('test@test.com') return false ?

Ce n'est pas une expression régulière valide, par exemple æææ@gmail.com passez l'expression régulière

Ne fonctionne pas avec findEmailInStr ("sdf ll \ ud83c \ uddeb \ ud83c \ uddf7email@gmail.com sdkf")

@ AndersLindén - Q: Quoi de pire qu'un code buggy disant aux gens qu'ils ne connaissent pas leur propre adresse? R: Dire à quelqu'un qu'il / elle devrait refuser INTENTIONNELLEMENT les adresses valides.

tous ces motifs affichent une ligne rouge ondulée sous certains caractères. Pourquoi?

Merci pour votre partage mais votre code n'est pas standard pour "RFC822" ou "RFC2822".

Cette expression régulière refuse les adresses e-mail valides sur un nom de domaine internationalisé.

Je suggère fortement d'utiliser l'expression régulière suggérée par WDC html.spec .whatwg.org / multipage / input.html # valid-e-mail-addre‌ ss

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, ce qui est la raison d'être de la validation JavaScript.

+1 car envoyer un e-mail et voir ce qui se passe est le seul véritable moyen sûr de valider une adresse e-mail, il n'est donc pas nécessaire de faire plus qu'une simple correspondance régulière.

La version modifiée de Squirtle ci-dessous semble être la solution la plus efficace sur la page. Vous pouvez valider tout ce que vous voulez mais je peux toujours entrer une adresse e-mail "@ gmaaaail.com".

Vous pouvez toujours rester simple, mais faites un peu plus pour vous assurer qu'il a un "." quelque part après le @ suivi uniquement de chiffres ou de chiffres, donc des choses comme moi @ ici, moi @ ici @ et moi @ herecom ne sont pas valides ... ^ \ S + @ \ S + [\.] [0-9a-z ] + $

Avatar Sam

Je pense que les adresses e-mail peuvent contenir des espaces. Il vaut probablement mieux utiliser .+@.+

/\S+@\S+/.test("áéíóúý@ÁÉÍÓÚÝð") true

@gtournie Personne ne s'en soucie. Personne ne va entrer cela dans un champ de messagerie par accident , et c'est tout ce que la validation frontale est pour: Pour empêcher les gens d'entrer accidentellement le mauvais bit d'informations, comme leur nom, dans un champ e-mail.

@ MladenJanjetović Oui, la réponse indique spécifiquement que ce n'est pas complet. C'est cependant la meilleure réponse. Personne n'a besoin d'une validation par e-mail "complète" en amont. Vous devez attraper les fautes de frappe évidentes, puis envoyer un e-mail de confirmation.

@meagar Vous pouvez être sûr que les gens font ce genre d'erreurs;)

@TimmyFranks Mauvaise expression régulière. Outre le point mineur, vous n'avez pas besoin d'échapper le point entre parenthèses, vous invalidez les caractères majuscules qui sont valides, donc vous obtiendrez des utilisateurs en colère (moi, comme j'aime les utiliser quand j'écris mes adresses!) ... il est trop restrictif car foo @ [192.168.1.12] est une adresse e-mail valide ...

@TimmyFranks Sur une note plus positive, vous avez raison sur la remarque concernant un @ b @ (une faute de frappe qui pourrait se produire) et sur l'ancrage de l'expression régulière. Une amélioration (encore très permissive) serait /^.+@\S*(?!@).$/ . Le point n'est même pas requis: une adresse sur un réseau local peut être foo @ machinename (nous avons ce cas sur notre réseau!).

C'est tellement ennuyeux que chaque fois que vous évoquez la validation des e-mails, 99% des personnes décrochent de la façon dont il n'est pas exact d'utiliser une expression régulière, etc. Nous essayons de déterminer si la syntaxe est correcte!

| _ @ _ | - e-mail valide?

Bien que j'adore la simplicité en tant qu'approche de "vérification des sens", juste une observation qui l'enveloppe avec ^ ... $ comme suit ^ \ S + @ \ S + $ est une amélioration par rapport à ce qui précède - car elle nécessite la conformité de l'adresse e-mail complète, pas seulement en partie.

Légèrement modifié pour couvrir plus de cas comme "asd @ asd" \S+@{1}\S+\.{1}\S+

@meagar ("áéíóúý @ ÁÉÍÓÚÝð"), il est ainsi possible d'entrer dans le champ de texte tout en utilisant les touches du téléphone portable.

/\S+@\S+/ fonctionne aussi sur les champs vides ... pas bon!

Vous devez comprendre quelque chose à 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, this l'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.

-1 Pourquoi voudrais-je passer mon temps à valider une adresse e-mail qui ne passe même pas le contrôle regex?

@PaoloBergantino je veux dire que, pourquoi devrais-je essayer d'envoyer un mail pour vérifier une adresse mail manifestement erronée? même si je dois "être absolument, absolument sûr que ce que l'utilisateur a entré est en fait un e-mail", je ne vérifierais que les adresses e-mail qui correspondent à l'expression régulière

@kommradHomer - une adresse "regex invalide" est presque toujours valide, car la regex que vous utilisez pour valider une adresse e-mail est presque certainement fausse et exclura les adresses e-mail valides. Une adresse e-mail est name_part@domain_part et pratiquement tout, y compris un @ , est valide dans le nom_partie; L'adresse foo@bar@machine.subdomain.example.museum est légale, bien qu'elle doive être échappée en tant que foo\@bar@machine.... . Une fois que l'e-mail atteint le domaine, par exemple 'example.com' ce domaine peut acheminer le courrier "localement" afin que des noms d'utilisateur et des noms d'hôte "étranges" puissent exister.

Le deuxième regex dans la réponse de voyager dans stackoverflow.com/a/1373724/69697 est pratique à utiliser et ne devrait avoir pratiquement aucune fausse négatifs. Je suis d'accord avec @kommradHomer ici - pourquoi envoyer un e-mail si vous n'êtes pas obligé? Je peux comprendre l'aversion réflexive pour les expressions rationnelles incompréhensibles et le désir de garder le code simple, mais ce sont quelques lignes de code qui peuvent sauver votre serveur beaucoup de problèmes en éliminant immédiatement les éléments définitivement invalides. Une expression rationnelle seule n'est pas utile, mais sert de bon complément à la validation côté serveur.

@StephenP a raison. Il est pratiquement impossible de trouver une expression régulière qui correspondra à tous les e-mails valides. De plus, les formats d'adresse e-mail peuvent changer.

@kommradHomer - "pourquoi voudrais-je passer mon temps à valider un ..." Huh? Passer votre temps? Bien sûr que non, idiot! Vous écririez du code pour le faire pour vous. Et vous sauriez alors si vous aviez une adresse valide sans risque d'aliéner les utilisateurs. C'est plutôt cool! Ou vous pouvez faire la moue et utiliser avec défi une solution cassée. Je ne suis pas en colère contre ça. Ce sont vos utilisateurs.

@StephenP "une adresse 'regex invalide' est presque toujours valide, car quelle que soit l'expression régulière que vous utilisez pour valider une adresse e-mail, elle est presque certainement fausse et exclura les adresses e-mail valides" Je trouve que cet argument est logiquement erroné. Les gens entrent toutes sortes de choses invalides dans les formulaires.

@dmur Je concède que "presque toujours valide" le surestime probablement, mais mes adresses e-mail (parfaitement valides et fonctionnelles) ont été rejetées trop souvent par des sites Web, simplement parce que j'ai un domaine .us ou parce que J'ai utilisé un + à gauche du @ - de nombreux endroits ont corrigé ces erreurs flagrantes, mais la partie locale (à gauche de @) peut être n'importe quoi le propriétaire du domaine le souhaite. -> "foo@bar.com"@example.com <- est une adresse e-mail valide.

Existe-t-il absolument aucun moyen de savoir si une adresse e-mail est valide sans envoyer un e-mail? N'y a-t-il aucun type d'enregistrement central dans le DNS où toutes les adresses e-mail utilisées sont accumulées et peuvent donc être interrogées pour l'existence d'une adresse e-mail donnée?

@Cupidvogel: Hélas, nous ne vivons pas dans ce monde.

@ AttitudeMonger - une telle base de données pourrait contenir des milliards et des milliards d'adresses e-mail, donc la recherche serait lente. Il n'y a également aucun moyen d'imposer l'enregistrement des adresses e-mail pour maintenir un registre à jour, ni pour les utilisateurs de s'assurer que leur adresse e-mail a été enregistrée. Donc, un tel registre central échouerait et serait finalement pire qu'une expression régulière (ou simplement envoyer un e-mail et voir s'il est livré et vous obtenez une réponse).

@kommradHomer "Une adresse non valide d'expression régulière est% 100 une adresse non valide." Je suis désolé ... excusez-moi? Savez-vous combien de fois on m'a dit que foo+bar@gmail.com N'EST PAS un e-mail valide alors qu'en fait IL EST PARFAITEMENT VALABLE?! Votre logique est EXTRÊMEMENT défectueuse. J'ai envoyé des formulaires avec des e-mails en tant que tels: thisisafakeemailbutitwillpassyourstupidregexcheck @ regexcheck‌ sareretarded.com Et devinez quoi? Cela passe le contrôle REGEX ... mais ce n'est PAS un e-mail valide (bien que techniquement c'est le cas, mais je vous promets qu'il n'existe pas ... pourtant se gratte le menton ). Comme beaucoup l'ont dit, C'EST UNE MAUVAISE IDÉE ....

Je pense que cette discussion ne fait pas la distinction entre une adresse e-mail syntaxiquement valide et une adresse qui reçoit réellement du courrier. L'autre chose que nous ignorons est qu'il existe en fait une spécification technique pour ce qui est considéré comme une adresse e-mail valide. Le problème est que la plupart des sites Web élaborent leur propre logique de validation basée sur certaines hypothèses naïves, plutôt que de se conformer aux exigences.

Désolé, mais ce n'est pas une bonne réponse. -1 "et voyez ce qui se passe"? Comment allez-vous savoir si un utilisateur a reçu l'e-mail ou non? De plus, quelque chose pourrait être un e-mail syntaxiquement valide même si personne ne possède de boîte aux lettres avec cette adresse. De plus, si vous validez l'entrée utilisateur, vous ne devriez pas faire d'appels réseau lents dans le cadre de la validation. De plus ....

Cela filtre les domaines .museum et .travel toujours populaires (en raison de la limite de 4 caractères après . )

Changer {2,4} en {2,6} ne sera pas un problème

@Anton N: Il a également environ un gazillion d'autres problèmes; le {2,4} final est simplement un indicateur utile de celui-ci (comme dans "quand vous voyez cette erreur, d'autres sont susceptibles d'être autour"). Le plus basique est le manque de + dans la partie locale; cette zone de commentaire est trop petite pour signaler toutes les erreurs commises ci-dessus.

Avatar MT.

Pourquoi ne pouvez-vous pas simplement faire return filter.test(email.value); ?

@Piskvor - après avoir ajouté le + et supprimé une barre oblique inversée redondante et idem plus à la fin, je ne trouve rien de mal à cela. Voir cette démo: codepen.io/anon/pen/lzJtB?editors=100. Si vous constatiez encore des lacunes, je serais ravi de savoir lesquelles.

@FrankConijn: Eh bien pour commencer - regardez bien cette liste, puis dites-moi: comment cette expression régulière traitera-t-elle les adresses du TLD de Singapour (.新加坡 ) comme valides, par exemple? en.wikipedia.org/wiki/List_of_Internet_top-level_domains Ce n'est pas Internet de votre grand-père plus; et même Internet de votre grand-père permettait une gamme beaucoup, bien plus large de personnages dans la partie locale. En d'autres termes, cette expression rationnelle est trop stricte et signalera les faux négatifs sur des adresses e-mail entièrement valides.

@AntonN: Nous avons maintenant plus de 10 TLD de caractères (xn--clchc0ea0b2g2a9gcd ). Toujours pas de problème?

Je préfère cela: var re = /^[0-9a-zA-Z.,+\-_]+@[0-9a-zA-Z.\-]+\.[a-zA-Z]+$/; Pour moi, si une adresse e-mail contient des caractères unicode, cela indique à peu près une erreur. (Je suis également originaire d'un pays anglophone non natif, donc je traite quotidiennement de telles erreurs). C'est donc une très bonne idée de filtrer les caractères accentués.

Cela permet: tes.t. @ example.com

/^}a-zA-Z0-9 ] ‌) + \.) + ([A-zA-Z0-9] {2‌, 6}) + $ / cela ne permet pas: tes.t. @ example.com ou .tes.t. @ exemple.com

Expression régulière suivante:

/^([\w]+)(.[\w]+)*@([\w]+)(.[\w]{2,3}){1,2}$/;
 

Cela ne correspond pas au RFC.

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 à obtenir quelque chose de raisonnable.

Quelques points à améliorer:

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

if (reg.test(/@/))
 

Deuxièmement, assurez-vous qu'un point vient après le signe @ et assurez-vous qu'il y a des caractères entre le @ et les points.

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

     

Donc, 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.

Mine d'accentuation

NB: "En utilisation réelle aujourd'hui " peut avoir été valide lors de l'écriture du code, en 200x. Le code restera probablement utilisé au-delà de cette année spécifique. (Si j'avais un sou pour chaque "meh, personne n'utilisera jamais un TLD à 4 + lettres sauf ceux spécifiques" que j'ai dû réparer, je pourrais accaparer le marché mondial du cuivre et du nickel;))

Pour la mise en œuvre pratique de RFC 2822, la fin doit être légèrement modifiée pour empêcher les extensions de domaine à caractère unique. / [a-z0-9! # $% & '* + \ / =? ^ _ {|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_ {|} ~ -] +) * @ (?: [a-z0-9] (?: [‌ a-z0-9 -] * [a-z0-9])? \ ‌.) + [A-z0-9] [a-z0-9-] ‌ * [a- z0-9] /

En outre, la première partie doit être (?: [A-z avec un A majuscule pour éviter les faux négatifs lorsqu'un utilisateur met en majuscule son adresse e-mail.

En utilisant "l'implémentation pratique", j'ai rencontré un problème dans Safari: si la partie de l'adresse correspondant après @ est de 32 caractères ou plus, le test d'expression régulière échouera. Cela est dû à cette limite de l'analyseur webkit: github.com/WebKit/webkit/blob/master/Source/JavaScriptCore/… ‌. Notez que ce n'est le cas que lors de la définition de l'expression régulière comme suit: var email_re = new RegExp("[a-z ...0-9])?", "i"); (par opposition à var email_re = new RegExp(/[a-z ...0-9])?/i); L'ajout d'un \` before each supplémentaire. '' Résout également le problème. + + @ Cal pour avoir suggéré cette solution!

Avec la spécification, d._.___d@gmail.com n'est pas un e-mail valide, mais cela détecte toujours qu'il est correct

@DonRolling Ne faites pas ça. Cela ne signifie pas seulement "A à Z, a à z", cela signifie également "[\] ^ _` "car ce sont entre " Z "et" a ". Utilisez \w , ou mieux, mettez simplement l'adresse e-mail en minuscules avant de faire quoi que ce soit avec, car c'est la convention de toute façon.

J'utilise celui-ci avec la modification suivante: [a-z0-9! # $% & '* + / =? ^ _ {|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_ {|} ~ -] +) ‌ * @ (? : [a-z0-9] (?: [a-z‌ 0-9 -] * [a-z0-9])? \.) + ‌ (?: [a-zA-Z] {2} | com | o‌ rg | net | gov | mil | biz | i‌ nfo | mobi | nom | aero | j‌ obs | museum) \ b Modification ajoutée az pour la fin pour autoriser .au, .it et plusieurs niveaux supérieurs domaines de pays qui utilisent deux caractères minuscules. Je voudrais savoir pourquoi cela n'a pas été inclus.

@willFarrell, en plus d'empêcher les domaines de premier niveau à un seul caractère (quelqu'un@exemple.c), ne devrions-nous pas également empêcher les domaines à un seul caractère (quelqu'un@e.com)? cela donne [a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]‌​+)*@(?:[a-z0-9][a-z0‌​-9-]*[a-z0-9]\.)+[a-‌​z0-9][a-z0-9-]*[a-z0‌​-9] Aussi, faites attention à ce que le démarque fait à votre regex, il a mangé certains de vos backticks ("" ")! Aussi vôtre @nwolybug!

La deuxième expression régulière "correspondant à 99,99%" n'empêche pas me@domain.fr. ou .me@domain.fr , ce qui peut être une simple erreur de frappe et n'est pas valide, je suppose que si le point "apparaît comme premier ou dernier caractère " droite?

"Vous devrez le mettre à jour à mesure que de nouveaux domaines de premier niveau seront ajoutés." Eh bien, tant pis pour ça maintenant - il y a plus de 1500 TLD reconnus.

J'ai trouvé que je devais changer tous les a-z en a-zA-Z.

@MadeInMoon Il n'empêche pas non plus les espaces et les signes @ multiples. asdasd asdasd @asdasd@gmail.com est valide

Cela permet des espaces comme toutes les chaînes suivantes sdf @ fdsfsdf sdfsdfdf @ klk@com.c

permet %20f3v34g34@gvvre.com? Je ne pense pas qu'il soit valable de commencer par%

Celui du milieu n'autorise pas les adresses locales: P hello@localhost = false

Bonne réponse. Je pense que la mise en œuvre pratique de RFC 2822 est préférable comme validation regex. Parce que seul le fournisseur de services de messagerie peut dire que les adresses e-mail sont valides ou non. Ce que nous pouvons faire en utilisant regex est de vérifier les validations générales. Personne ne peut valider à 100% toutes les adresses e-mail en utilisant l'expression régulière. Parce que différents fournisseurs de messagerie ont leurs différentes méthodes de validation.

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

-1 La liste blanche laisse beaucoup à désirer - notamment, vous avez manqué .jobs . De plus, il existe des IDN en direct (la plupart, j'en conviens, n'ont été officiellement approuvés qu'après votre publication - par exemple .中國 en juin 2010; mais la plupart sont en préparation depuis des années).

-1 n'utilise pas de domaines de premier niveau constants. Il pourrait toujours y avoir (et il y aura par exemple 2013) de nouveaux tld.

Il y a des centaines de nouveaux TLD confirmés. Cette réponse n'est pas valide et ne doit jamais être utilisée.

Ouaip. Je l'ai dit en 2011, et je le répète: une liste blanche de domaines "spéciaux" ne fera qu'empirer avec le temps, à mesure que davantage de TLD sont approuvés. Il y a plus de 100 TLD complètement valides ne correspondant pas à la liste blanche ci-dessus: en.wikipedia.org/wiki/List_of_Internet_top -level_domains

Nous sommes en 2015. Votre expression n'est pas pratique. Vous devriez prendre cette réponse, mais vous êtes probablement trop occupé à corriger toutes les pages sur lesquelles vous mettez cette expression. Droite?

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
 

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

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

Ils ont oublié d'échapper au @ .

La 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 : le dernier @ doit être avant le dernier . car @ ne peut pas faire partie du nom du serveur (pour l'instant comme je sais).

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

  • str.indexOf('@@') == -1 : Il ne doit pas y avoir de @@ dans l'adresse. Même si @ apparaît comme le dernier caractère du nom d'utilisateur de l'e-mail, il doit être cité pour que " se situe entre ce @ 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.

Ce fn a l'air bien, mais est-il meilleur que l'expression régulière écrite dans la réponse du haut?

J'en doute. Je l'utilise uniquement pour vérifier si une chaîne ressemble à un e-mail et laisser les détails au code côté serveur.

Il valide OK toute chaîne comme 'aaaa', c'est-à-dire sans '@' et '.'

Cela ne devrait pas. lastIndexOf () devrait retourner -1 s'il ne trouve pas l'aiguille.

Avatar Ry-

"Même si @ apparaît comme le dernier caractère du nom d'utilisateur de l'e-mail, il doit être cité pour que " se situe entre ce @ et le dernier @ dans l'adresse. " Et "@@"@example.com ?

"@@"@example.com est valide.

test @ .ds est également valide (?)

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>
 

lien jsFiddle

À partir de la spécification HTML5 :

  

Une adresse e-mail valide est une chaîne qui correspond à la production 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 e-mail 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 et les chaînes entre guillemets de manières inconnues) à la plupart des utilisateurs) pour être utile 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])?)*$/
 

c'est bien, mais le problème est qu'il doit être à l'intérieur d'une balise form et soumis par une entrée submit , ce que tout le monde n'a pas le luxe de faire. De plus, vous ne pouvez pas vraiment styliser le message d'erreur.

J'ai ajouté une réponse ci-dessous qui vous libère du formulaire et de la soumettre. Mais oui, les navigateurs n'appliquent généralement qu'une vérification de plausibilité et non une validation RFC 822 complète.

Avatar tim

certaines personnes (comme moi) n'utilisent plus du tout les balises input et s'appuient plutôt sur contenteditable sur des balises div standard.

a@a.a est validé en FF22

@ br1: ce n'est pas invalide simplement parce qu'il n'y a pas de domaine de premier niveau "a". que se passe-t-il si votre Internet a une résolution a.a vers une IP?

Le type de champ de messagerie html5 accepte les e-mails comme user @ email

Cette expression régulière est celle que j'utilise et vous pouvez la voir passer tous les Tests de chrome mentionnés dans la réponse acceptée ici .

Remarque du commentaire de @ Puce: la saisie de courrier électronique HTML 5 accepte user@email alors que, par exemple, le filter_var de PHP ne l’accepte pas. Cela pourrait provoquer des problèmes.

Ce n'est jamais une bonne idée de s'appuyer uniquement sur la validation côté client. Il existe de nombreuses façons d'introduire de mauvaises valeurs dans votre application serveur.

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

Cela permet de saisir autant d'adresses e-mail invalides que ce sont des conseils inutiles.

Il ne doit pas du tout être impossible de déboguer. Il y a beaucoup d'exemples fins dans ce fil qui valident plus que "a-t-il un '@' dedans. Votre exemple permet à" u @ "d'être considéré comme une adresse e-mail valide. Évaluez au moins s'il existe un domaine ou quelque chose qui pourrait être un domaine. Le vôtre est un exemple de ce que j'appellerais "codage agressivement paresseux." Je ne sais pas pourquoi vous le défendez car il est de loin la réponse la moins bien notée dans le fil.

@cazlab vous avez peut-être raison. Après tout, j'ai été rejeté. Contrairement à vous, je ne pense pas que le code ci-dessus montre des extraits de code faciles à déboguer. Mon approche «agressivement paresseuse» au moins peut être améliorée si nécessaire.

L'une des meilleures réponses à cette question. Vous ne devez jamais verrouiller un utilisateur en raison d'une adresse e-mail «étrange». Il est toujours préférable d’essayer d’envoyer un e-mail à cette adresse et de demander à l’utilisateur de cliquer sur un lien d’activation si vous voulez être sûr qu’un e-mail est valide.

En quoi est-ce différent de l'utilisation de regex? (.+)@(.*) fait la même chose, et plus court.

+1 - Si l'objectif est de s'assurer que l'utilisateur a au moins tenté de saisir une adresse e-mail, vérifier si l'on peut déterminer que l'adresse e-mail n'est certainement PAS un e-mail est un excellente solution. Un bon exemple serait si vous voulez que le nom d'utilisateur d'une personne soit une adresse e-mail. Si l'utilisateur tape «sexy_chick_23», cette expression régulière peut être utilisée pour lui indiquer qu'un e-mail est attendu. Si quelque chose est tapé qui ressemble à un e-mail, mais ne l'est pas, l'utilisateur ne recevra jamais l'e-mail de «confirmation» et le processus d'inscription ne sera jamais validé.

@cazlab - Quel est votre cas d'utilisation pour savoir si l'adresse e-mail de l'utilisateur est valide sans simplement lui envoyer un e-mail et voir ce qui se passe? De quoi pensez-vous qu'une expression régulière peut vous protéger?

@lwburk si vous ne voulez pas envoyer inutilement des e-mails dans l'éther. "its @ u" passerait cette "validation". je ne considère pas cet exemple comme une validation, je suis désolé.

+1, bien que le txt.length > 0 && soit redondant à cause du deuxième test. Dans tous les cas, il s'agit de donner un petit retour rapide à l'utilisateur, tout en évitant autant que possible les hits sur le serveur. Personne qui sait quoi que ce soit ne dépend en fait que de JavaScript pour la validation.

+1 pas parce que j'aime votre solution (comme l'indique @cookiemonster, la longueur> 0 est un test idiot car un e-mail RFC valide minimum est d'au moins 3 caractères, une adresse e-mail routable Internet REAL est au moins 5) mais je suis d'accord , une solution simple est toujours préférable, et la SEULE façon de valider réellement un e-mail est d'envoyer un e-mail. J'adore toujours lire ces arguments sémantiques entre souffleurs qui peuvent jaillir des normes et ne peuvent pas coder dans le monde réel pour leur sauver la vie. Merci!

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

Vous pouvez implémenter quelque chose 20x aussi longtemps qui pourrait causer des problèmes à quelques utilisateurs et ne pas être valide à l'avenir, ou vous pouvez récupérer la version d'ImmortalFirefly pour vous assurer qu'ils s'efforcent au moins de la rendre réelle. Selon votre application, il est plus probable que quelqu'un tombe en colère parce que vous n'acceptez pas son e-mail non conventionnel, plutôt que quelqu'un qui cause des problèmes en entrant des adresses e-mail qui n'existent pas vraiment (ce qu'il peut faire de toute façon en entrant une adresse e-mail RFC2822 100% valide mais en utilisant un nom d'utilisateur ou un domaine non enregistré). A voté!

@ImmortalFirefly, l'expression régulière que vous avez fournie correspondra en fait à name@again@example.com . Essayez de coller votre ligne dans une console JavaScript. Je crois que votre intention était de ne faire correspondre que le texte entier, ce qui nécessiterait le début du texte «^» et la fin du texte «$». Celui que j'utilise est /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test('name@again@example.com')

Sur la base de cette validation, cet e-mail est valide: check @ this..com

l'une de mes adresses e-mail est damiann @ dragon, cela ne permet pas le cas des machines qui sont visibles directement par le serveur web / e-mail.

Hm. Wikipedia indique que "very.unusual.@.unusual.com"@example.com est une adresse e-mail valide. /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test('"very.unusual.@.unusual.c‌​om"@example.com') // false . Oops.

Cela n'autorise-t-il pas également @@@.@ ? :RÉ

Avatar tk_

'/\S+@\S+\.\S+/.test('name@example.-com') '' true '

Je pense que le pire de cette solution simple est qu'elle teste uniquement que le modèle est contenu . Bien sûr, nous ne voulons pas terminer avec une expression rationnelle excessive, mais au moins la rendre pertinente et ajouter ces vérifications de début et de fin: /^...$/ - Pas comme si cela rendait l'écriture plus difficile ... des signes @ supplémentaires sont également une bonne idée

OregonTrail votre regex passe a@b._com , a@b_.com pour être vrai

J'ai combiné les réponses sur la page pour atteindre l'esprit de la validation frontale: détecter les erreurs courantes des utilisateurs. Voici mon expression régulière: /^[^\s@#!]+@[^\s@.#!]+.[^\s@.]+$/ C'est est un peu plus complexe, mais cela nécessite spécifiquement un et un seul @ et . dans cet ordre et empêche les caractères # et ! de chaque côté du @ . J'exclus uniquement ceux car il est possible de les toucher accidentellement en appuyant sur @ . Il n'est pas exhaustif, mais il attrape un @ b..com ou a@#b.com etc.

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

Vous n'avez pas besoin du == true sur votre exemple.

La solution de Sectrean fonctionne très bien, mais elle échouait à mon linter . J'ai donc ajouté quelques échappements:

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

validateEmail ("e_mail@sth.com") et validateEmail ("e.mail@sth.com") renvoient tous les deux la valeur false

function validateEmail(elementValue){        
    var emailPattern = /^[a-zA-Z0-9._]+[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z]{2,4}$/;  
    return emailPattern.test(elementValue);   
  }   
 

Il renvoie vrai si l'adresse e-mail est valide. Sinon, il retournera faux.

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 RFC 2822 , qui est un e-mail standard pour TOUS les adresses DOIVENT adhérer. Et je ne sais pas pourquoi tu t'embêterais avec quelque chose de "plus simple" ... tu vas 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 à 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') );
 

Remarque :
Techniquement, certains e-mails peuvent inclure des guillemets dans la section avant 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 RFC 2822 standard, et omis ici.

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

@Kondal le code javascript n'est pas sensible à la casse en raison de l'indicateur /i à la fin de l'expression régulière. Je mentionne le fait qu'il doit être une comparaison insensible à la casse, mais je vais le dire plus clairement.

A fonctionné pour moi comme un charme

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é à la détection des fonctionnalités et à la validation à nu de Squirtle's Answer , il vous libère du massacre des expressions régulières et ne cogne pas sur les anciens navigateurs.

C'est une idée intelligente pour résoudre le problème, mais cela ne fonctionne pas car les navigateurs ont également une validation merdique. Par exemple. .@a est validé en tant que true dans les versions actuelles de Chrome, Firefox et Safari.

@HenryJackson Malheureusement, dans ce cas, oui. En effet, selon le RFC, il s'agit d'une adresse e-mail valide (pensez aux intranets). Les navigateurs seraient grillés s'ils valident trop étroitement et produisent de faux négatifs.

Mis à jour pour contenir la détection des fonctionnalités et une dégradation gracieuse, il ne se casse plus sur les nouveaux navigateurs mais utilise les expressions rationnelles que vous aimez.

Belle solution. Malheureusement, ce n'est que pour HTML5 +.

C'est de loin la meilleure solution à la question d'origine. Oui, il utilise HTML5, mais la majorité des applications qui nécessitent ce niveau de précision s'appuieront sûrement déjà sur HTML5 d'une autre manière, donc point discutable. Il est impossible pour nous de déterminer si l'e-mail de quelqu'un est valide sans le faire vérifier de toute façon, nous ne devrions donc pas investir autant de temps ou d'efforts pour le valider. Une vérification rapide de toute syntaxe évidente ou tentative de méchanceté est tout l'effort que nous devons déployer.

Fait intéressant, ce code a renvoyé true pour les chaînes vides. Je l'ai édité pour ajouter une vérification de chaîne vide et vide.

Oui, car des valeurs vides sont autorisées, si aucune entrée n'est requise. Vous pouvez également définir input.required = true pour le même effet.

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

Peut-être que si vous avez ajouté une explication ou une description pour l'accompagner? Je ne pense pas que vous ayez vraiment besoin de montrer du html; tout le monde est concerné par le javascript et l'expression régulière. Si vous réduisez votre réponse au simple JavaScript et ajoutez un petit texte descriptif pour l'accompagner, je vous donnerai un vote positif.

Ma connaissance des expressions régulières n'est pas si 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
 

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

@BGM: Préféreriez-vous avoir une belle fonction qui ne fonctionne pas?

@Piskvor Non, je préfère avoir une belle fonction qui fonctionne. Et vous?

@BGM: Allez-y et modifiez, alors. La réponse est, après tout, marquée "wiki communautaire".

Les adresses IDN ne sont pas validées (info@üpöü.com)

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.

IE <10 ne prend pas en charge cela, pas plus que le propre navigateur d'Android.

Upvoting. IE <10 est mort.

Toutes les adresses e-mail contiennent un symbole `` à '' (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 ce qui compte vraiment.

Pour tester cela, envoyez un message de validation.

et s'il y aura plus d'un symbole '@'? d'autres symboles restreints? Cette validation n'est pas fiable ...

Parfait, cette réponse était simple, juste une validation de couche supplémentaire. ont déjà une couche sur l'extrémité avant, cela aide donc merci

C'est de loin la meilleure réponse de l'OMI. Assez bon pour attraper la plupart des entrées accidentelles (c'est-à-dire la plupart des choses qui ne sont pas des adresses e-mail) sans faux négatifs.

Si vous utilisez Closure, vous pouvez utiliser le type goog.format.EmailAddress intégré:

  

http: //docs.closure-library.googlecode.com/git/class_goog_format_EmailAddress.html

Par exemple:

goog.format.EmailAddress.isValidAddrSpec("blah@blah.com")
 

Notez qu'en lisant la source (liée ci-dessus), vous pouvez voir les commentaires déclarer que les IDN ne sont pas pris en charge et qu'il vise uniquement à couvrir la plupart des adresses:

// This is a fairly naive implementation, but it covers 99% of use cases.
// For more details, see http://en.wikipedia.org/wiki/Email_address#Syntax
// TODO(mariakhomenko): we should also be handling i18n domain names as per
// http://en.wikipedia.org/wiki/Internationalized_domain_name
 

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])\]))$/
 

W3Schools donne un bon script simple et efficace pour valider un e-mail:

function validateEmail(email) {
    var atpos=email.indexOf("@");
    var dotpos=email.lastIndexOf(".");
    if (atpos < 1 || dotpos < atpos+2 || dotpos+2 >= email.length) {
        alert("Not a valid e-mail address");
        return false;
    }
    return true;
}
 

Notez que vous devrez supprimer les espaces s'il y en a cependant, avec quelque chose comme ceci:

.replace(/ /g,'')
 

Source: Validation de formulaire JavaScript

abc@xyz est un e-mail parfaitement valide qui n'est pas reconnu par votre expression régulière.

Ce n'est pas mon expression régulière, c'est l'expression régulière de w3schools, et pour une simple validation par e-mail, à condition que vous préfériez être trop restrictif que pas assez, cela fonctionne. Si vous voulez le package complet, utilisez la solution de voyager.

Assez horrible cependant, il validera de nombreux e-mails incorrects, c'est-à-dire que quelque chose comme d @@. Com sera valide.

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
}
 

abc@xyz est un e-mail parfaitement valide qui n'est pas reconnu par votre expression régulière.

Non ce n'est pas. Le modèle d'e-mail correct est quelque chose@something.something, abc @ xyz ne correspond pas à ce modèle. Donc, ce n'est pas une adresse valide.

Je dis que l'email a: local-part @ domain. Et voici '.' dans la partie domaine.

Pouvez-vous citer un e-mail réel valide de type quelque chose @ quelque chose?

Avez-vous la page wikipedia? Un TLD est un nom d'hôte valide. abc@tld est donc une adresse e-mail valide.

Eh bien, je n'ai jamais rencontré un tel e-mail, la vérification ci-dessus fonctionne bien avec moi. Si vous ne le souhaitez pas, supprimez simplement les points et la clause associée. Cela fonctionnera alors pour abc @ xyz. Je suggère de vérifier l'e-mail avec le lien si vous voulez en être sûr. davidcel.is/blog/2012/09 / 06 /…

Et l'API de validation JQuery n'accepte pas non plus les e-mails de type abc @ xyz

La seule façon de valider une adresse e-mail est d'envoyer un e-mail puis d'attendre la réponse. En dehors de cela, voici une URL où vous pouvez tester si votre adresse est conforme à la RFC822: mythic-beasts.com/~pdw/cgi-bin/emailvalidate . Vous pouvez voir que abc @ xyz est une adresse valide pour RFC822.

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 - bien qu'il ait toujours été parfait pour mes besoins.

Ne permet pas les + dans la partie nom de l'e-mail.

<pre>
**The personal_info part contains the following ASCII characters.
1.Uppercase (A-Z) and lowercase (a-z) English letters.
2.Digits (0-9).
3.Characters ! # $ % & ' * + - / = ? ^ _ ` { | } ~
4.Character . ( period, dot or fullstop) provided that it is not the first or last character and it will not come one after the other.**
</pre>
*Example of valid email id*
<pre>
yoursite@ourearth.com
my.ownsite@ourearth.org
mysite@you.me.net
xxxx@gmail.com
xxxxxx@yahoo.com
</pre>
<pre>
xxxx.ourearth.com [@ is not present] 
xxxx@.com.my [ tld (Top Level domain) can not start with dot "." ]
@you.me.net [ No character before @ ]
xxxx123@gmail.b [ ".b" is not a valid tld ]
xxxx@.org.org [ tld can not start with dot "." ]
.xxxx@mysite.org [ an email should not be start with "." ]
xxxxx()*@gmail.com [ here the regular expression only allows character, digit, underscore and dash ]
xxxx..1234@yahoo.com [double dots are not allowed
</pre>
**javascript mail code**

    function ValidateEmail(inputText)
    {
    var mailformat = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
    if(inputText.value.match(mailformat))
    {
    document.form1.text1.focus();
    return true;
    }
    else
    {
    alert("You have entered an invalid email address!");
    document.form1.text1.focus();
    return false;
    }
    }
 

Très simple dans JavaScript . suivez ce code.

function validate(){
    var email = document.getElementById('Email');
    var filter = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;

    if (!filter.test(email.value))
    {
        alert('Please Enter the valid email address');
        email.focus;
        return false;
    }
    else
{
        return true;
    }
 

HTML code pour cela:

form name="form"
     enctype="multipart/form-data"
     name="form"
     action="register.php"
     method="POST" onsubmit="return validate();" >
    <input type="text" placeholder="Enter ur Email Id" id="Email" name="Email" />
    <input type="submit" id="submit" value="save" name="Like" class="button" />
</form>
 

Ce filtre invalide de nombreuses adresses e-mail valides courantes ... Par exemple: user+tag@gmail.com

Un de mes collègues a partagé cette expression régulière avec moi. Je l'aime beaucoup.

function isValidEmailAddress (email) {
    var validEmail = false;
    if (email) {
        email = email.trim().toLowerCase();
        var pattern = /^[\w-']+(\.[\w-']+)*@([a-zA-Z0-9]+[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*?\.[a-zA-Z]{2,6}|(\d{1,3}\.){3}\d{1,3})(:\d{4})?$/;
        validEmail = pattern.exec(email);
    }

    return validEmail;
}

if (typeof String.prototype.trim !== 'function') {
    String.prototype.trim = function() {
        return this.replace(/^\s+|\s+$/g, '');
    };
}
 

function validatecontactEmail(email) { 

 if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(email))  
  {  
    return (true)  
  }  

    return (false)  

}
 

Que diriez-vous simplement de return /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(email) ?

Voici une fonction que j'utilise pour la validation des e-mails frontaux. (L'expression régulière provient de persil.js)

<!DOCTYPE html>
<html>
<head>
    <title>Our Company</title>
    <style>
        .form-style {
            color: #ccc;
        }
    </style>
</head>
<body>
    <h1>Email Validation Form Example</h1>
    <input type="text" name="email" id="emailInput" class="form-style">
    <script>
        function validateEmail(emailAddress) {
            var regularExpression = /^((([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]))){2,6}$/i;
             return regularExpression.test(emailAddress);
        }

        function showEmailValidationState(event) {
            if (validateEmail(event.target.value)) {
                document.getElementById("emailInput").style.color = 'black';
            }
        }
    document.getElementById("emailInput").addEventListener("keyup", showEmailValidationState);
    </script>
</body>
</html>
 

J'adore les regex, mais pas pour la validation des e-mails. Amusez-vous à déboguer si quelqu'un trouve un problème avec ça!

J'utilise la validation en 3 étapes pour le courrier électronique. 1er j'utilise HTML5 avec type = email requis. Le deuxième est une expression régulière JS illustrée ci-dessus, puis le dernier côté serveur.

@ zéros-uns, sauf que vous utilisez type="text" ici, pas type="email" : - /

Oui c'est correct, je trouve la validation HTML5 ennuyeuse.

Si vous utilisez AngularJS, ajoutez simplement type="email" à l'élément d'entrée:

  

https://docs.angularjs.org/api/ng/ input / input% 5Bemail% 5D

S'il n'y a pas d'élément d'entrée, il peut être créé dynamiquement:

var isEmail = $compile('<input ng-model="m" type="email">')($rootScope.$new()).
    controller('ngModel').$validators["email"];

if (isEmail('email@gmail.com')) {
  console.log('valid');
} 
 

Mais qu'est-ce que cette fonction d'analyse de courrier électronique? Pourriez-vous l'afficher pour que l'on puisse l'utiliser sans angulaire?

Oui, si vous souhaitez publier une réponse dans une boîte noire, veuillez déterrer le RegEx derrière la fonction d'analyse de l'e-mail et nous montrer ce qu'il utilise.

Regex de validation pour le courrier électronique:

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

if(email=="") {
    window.plugins.toast.showShortBottom( "Please enter the details. ", function(a) {
        console.log('toast success: ' + a);
    }, function(b) { });
} else if(!rex_email.test(email)) {
    window.plugins.toast.showShortBottom( "Please enter the valid email id. ", function(a) {
        console.log('toast success: ' + a);
    }, function(b) { });
}
 

Cela fonctionnera pour les adresses e-mail de base très courantes, mais il existe certains cas extrêmes où cela rejettera les adresses e-mail valides. Si vous avez lu les 36 autres (!) Réponses ici, vous l'auriez déjà su.

Je sais que ce n'est pas regex mais de toute façon ...

Ceci est un exemple avec le nœud et le package npm existence e-mail . e-mail existe et si c'est sous la bonne forme :)

Cela enverra un ping à l'e-mail s'il répond s'il n'a reçu aucune réponse, il retournera faux ou sinon vrai.

function doesEmailExist(email) {
    var emailExistence = require('email-existence');
    return emailExistence.check(email,function (err,status) {
            if (status) {
                return status;
            }
            else {
                throw new Error('Email does not exist');
            }
        });
}
 

Après les validations Regex:

  • Aucun caractère spatial avant @
  • (-) et (.) ne doivent pas être ensemble après @ Aucun caractère spécial après @ 2 caractères doivent avant @ La longueur de l'e-mail doit être inférieure à 128 caractères
function validateEmail(email) {
var chrbeforAt = email.substr(0, email.indexOf('@'));
if (!($.trim(email).length > 127)) {
    if (chrbeforAt.length >= 2) {
        var re = /^(([^<>()[\]{}'^?\\.,!|//#%*-+=&;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
        //var re = /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
        return re.test(email);
    } else {
        return false;
    }
} else {
    return false;
}
}
 

J'ai fini par utiliser celui-ci, il fonctionne le mieux pour mes besoins et surtout j'ai juste détourné la partie utilisateur et utilisé autre chose pour la correspondance après le signe @ parce que j'avais besoin de mon implémentation pour n'autoriser que les utilisateurs d'un domaine spécifique. Mais celui-ci est intelligent!

Après les validations Regex:

  • Aucun caractère spatial avant @
  • (-) et (.) ne devraient pas être ensemble après @
  • Aucun caractère spécial après @ 2 caractères ne doit précéder @
  • La longueur de l'e-mail doit être inférieure à 128 caractères

    function validateEmail(email) {
        var chrbeforAt = email.substr(0, email.indexOf('@'));
        if (!($.trim(email).length > 127)) {
            if (chrbeforAt.length >= 2) {
                var re = /^(([^<>()[\]{}'^?\\.,!|//#%*-+=&;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
                return re.test(email);
            } else {
                return false;
            }
        } else {
            return false;
        }
    }
    

\b[a-z][\w\d_\.]+@\w+\.[a-z]{2}[a-z]?\.?[a-z]{,2}\s
 

Il permet:

abcxyz123@qwert.com    
abc123xyz@asdf.co.in   
abc1_xyz1@gmail1.com   
abc.xyz@gmail.com.in
 

Bon essai: 2 mises à jour ici: Pour les plages de correspondance, nous fournissons {min,max} . Un min vide est une erreur, mais peut avoir un max vide. Je veux dire que [a-z]{,2} est faux, écrivez comme {0,2} . De plus: votre regex affiche kamal@_gmail.com comme valide, ce qui ne l'est pas!

le meilleur: D (compatible RFC et aucune erreur "trop ​​complexe"):

function    isMail(mail)
{
    pattuser = /^([A-Z0-9_%+\-!#$&'*\/=?^`{|}~]+\.?)*[A-Z0-9_%+\-!#$&'*\/=?^`{|}~]+$/i;
    pattdomain = /^([A-Z0-9-]+\.?)*[A-Z0-9-]+(\.[A-Z]{2,9})+$/i;

    tab = mail.split("@");
    if (tab.length != 2)
        return false;
    return (pattuser.test(tab[0]) && pattdomain.test(tab[1]));
}
 

L'utilisateur autorise les espaces, qu'y a-t-il exactement qui autorise les espaces?

tu as raison, j'ai oublié que je ne les accepte pas dans celui-ci

Si vous souhaitez utiliser Jquery et souhaitez avoir une approche moderne, utilisez le masque de saisie JQuery avec validation.

http://bseth99.github.io/projects/ jquery-ui / 5-jquery-masks.html

Démo sur la simplicité du masque de saisie jquery: http://codepen.io/anon/pen/ gpRyBp

Exemple de masque de saisie simple pour la date par exemple PAS de validation complète

 <input id="date" type="text" placeholder="YYYY-MM-DD"/>
 

et le script:

 $("#date").mask("9999-99-99",{placeholder:"YYYY-MM-DD"});
 

La meilleure pratique consiste à utiliser la balise de courrier électronique HTML5 intégrée.

<input type="email" name="email">
 

ou la syntaxe de messagerie courante reconnaissant @ et. de la chaîne est donnée ci-dessous.

^[a-zA-Z0-9_\-.]+@[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-.]+$
 
  

Notez que cela produirait toujours des e-mails invalides qui correspondraient toujours   le regex, il est presque impossible de tous les attraper, mais cela   améliorer un peu la situation.

Selon votre expression régulière, "_.............. kamal@gmail.com" est valide, ce qui ne devrait pas l'être!

C'est ce que j'ai dit dans la note

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. 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. Il bloquera les espaces qui sont techniquement autorisés par RFC, mais ils sont si rares que je suis heureux de le faire.

Il autorise les formats suivants:

, mais ils sont si rares que je suis heureux de le faire. 

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)

It's clearly versatile and allows the all-important international characters, while still enforcing the basic anything@anything.anything format. It will block spaces which are technically allowed by RFC 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. Il bloquera les espaces qui sont techniquement autorisés par RFC, mais ils sont si rares que je suis heureux de le faire.

Il autorise les formats suivants:

, mais ils sont si rares que je suis heureux de le faire. 

C'est exactement ce que je fais. Toutes ces réponses "compliquées" engendrent des problèmes: soit elles n'autorisent pas les IDN puny-code, soit elles utilisent un ensemble fixe de TLD, soit elles limitent inutilement l'utilisateur à ne pas utiliser de caractères comme [@ çµ.ö dans leur préfixe email (avant @) ou nom de domaine. JavaScript en frontend (pas pour l'utilisation de cause par le backend) n'est pas suffisant pour valider pour des raisons de sécurité. Alors pourquoi ne pas simplement aider l'utilisateur à éviter les fautes de frappe de base. Les fautes de frappe de base sont les suivantes: oublier le TLD ou le préfixe utilisateur (avant @) ou la partie de domaine ou le type @ erroné en . (ou vice versa). Il faut bien sûr être beaucoup plus restrictif côté serveur.

Pour des raisons étranges, username@domain.com ne fonctionne pas avec ce modèle

Selon votre expression régulière, "_.............. kamal@gmail.com" est valide, ce qui ne devrait pas l'être!

Voici le RegEx indiqué avec des exemples, si vous souhaitez bricoler avec cette solution: regex101.com/r/AzzGQU/ 2

Cette expression régulière est correcte. Si quelqu'un entre son e-mail comme a@b@c@d.x.y.@.z , alors peut-être qu'il mérite de passer un mauvais moment? :RÉ

Testé pour regex.test ("john-appleseed@mac.com") et regex.test ("anna-haro@mac.com"). Le premier a montré faux et le dernier vrai, donc quelque chose ne va pas avec l'expression régulière que vous mentionnez.

@ spa900 les deux donnent vrai pour moi

Cette expression régulière empêche les noms de domaine en double comme abc@abc.com.com.com.com, elle n'autorisera que deux fois le domaine comme abc@abc.co.in. Il ne permet pas non plus de statuer à partir d'un numéro comme 123abc@abc.com

regexp: /^([a-zA-Z])+([a-zA-Z0-9_.+-])+\@(([a-zA-Z])+\.+?(com|co|in|org|net|edu|info|gov|vekomy))\.?(com|co|in|org|net|edu|info|gov)?$/,  
 

Tout le meilleur !!!!!

Pourquoi voudriez-vous utiliser quelque chose comme ça? La spécification des normes d'adresse e-mail suggère que les adresses e-mail peuvent commencer par des chiffres et peuvent contenir plusieurs caractères de période dans le domaine et la partie lcoal. Cette réponse semble être quelque chose que vous avez créé pour un scénario entièrement personnalisé, où vous discriminez efficacement les gens pour avoir des adresses e-mail que vous n'aimez pas! Pour s'étendre légèrement, les adresses e-mail peuvent également contenir des adresses IP, ce qui est potentiellement encore plus restrictif que décrit.

Vrai !!!!!! Mais différentes personnes peuvent avoir des exigences différentes et c'est pourquoi nous écrivons des validations .... n'est-ce pas ?????????

Eh bien pas vraiment. Nous utilisons la validation pour confirmer que la saisie correspond à nos attentes afin d'éviter d'essayer d'utiliser des données mal formatées de certaines manières. Dans ce cas, OP recherche un code qui peut valider une adresse e-mail, comme il est censé l'être. Dans votre exemple, vous semblez valider une chaîne pour être quelque chose que vous voulez qu'elle soit. Pour le dire simplement, vous validez qu'une chaîne correspond à quelque chose que vous voulez qu'elle corresponde, qui n'est pas une adresse e-mail, tandis que OP cherche à valider qu'une chaîne correspond à une adresse e-mail. Ce ne sont pas les mêmes choses.

Regex simple pour l'identifiant e-mail

 String EMAIL_PATTERN ="^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$";
 

Selon votre expression régulière, "_.............. kamal@gmail.com" est valide, ce qui ne devrait pas l'être!

Utilisez l'expression régulière:

  /^[a-z][a-zA-Z0-9_.]*(\.[a-zA-Z][a-zA-Z0-9_.]*)?@[a-z][a-zA-Z-0-9]*\.[a-z]+(\.[a-z]+)?$/
  

Exemple:

function validateEmail(email) {
    var re = /^[a-z][a-zA-Z0-9_.]*(\.[a-zA-Z][a-zA-Z0-9_.]*)?@[a-z][a-zA-Z-0-9]*\.[a-z]+(\.[a-z]+)?$/;
    return re.test(email);
}
 

Il ne devrait autoriser que @,. , _

J'ai mélangé @mevius et @Boldewyn Code pour créer ce code ultime pour la vérification des e-mails à l'aide de JavaScript.

 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,}))$/;
 
  var input = document.createElement('input');
 
  input.type = 'email';
  input.value = email;
 
  return typeof input.checkValidity == 'function' ? input.checkValidity() : re.test(email);
 
}  

J'ai partagé ce code sur mon blog ici .

Cela échouera si le champ est vide. Vous pouvez ajouter un attribut requis et rogner l'adresse e-mail pour résoudre le problème.

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

pour passer les exemples dans Adresse e-mail Wikipedia .

Et vous pouvez voir le résultat dans ici .

entrez description de l'image ici

Cela semble être une bonne solution, cela fonctionne également avec les nouveaux TLD et les e-mails à 1 lettre

Pourquoi john..doe@example.com ne devrait pas être correct? C'est une valise d'angle valide.

Si vous utilisez le motif et le matériau ng, cela fait l'affaire.

vm.validateEmail = '([a-zA-Z0-9_.]{1,})((@[a-zA-Z]{2,})[\\\.]([a-zA-Z]{2}|[a-zA-Z]{3}))';
 

Quiconque utilise la solution @pvl et souhaite qu'elle passe ESLint Prefer-template alors voici une version où j'ai utilisé des littéraux de modèle au lieu de la concaténation de chaînes.

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

    let reValidEmail = new RegExp(sValidEmail);

    return reValidEmail.test(email);
}
 

Regex pour valider 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])+
 

Je ne vois pas votre expression rationnelle dans RFC5322: tools.ietf.org/html/rfc5322 - il y a une erreur?

"Le meilleur regex de tous les temps"? Peut-être une sorte d'explication ici?

Pourquoi avez-vous dit que c'est la meilleure solution de toutes, pouvez-vous expliquer un peu plus s'il vous plaît?

Je ne peux pas me rappeler pourquoi j'ai écrit "le meilleur regex jamais". Désolé les gars si cela vous dérange.

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: Vérifier si 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.ccc passe le regex, ce n'est pas un e-mail valide, car ccc n'est pas un domaine de premier niveau par l'IANA.

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

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

  • email@example.com E-mail valide

  • firstname.lastname@example.com L'e-mail 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 les e-mails 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.jp Le point dans le nom de domaine de premier niveau est également considéré comme valide (en utilisant co.jp comme exemple ici)

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

C'est parti:

http://regexr.com/3f07j

OU expression régulière:

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

Dans nodeJS, vous pouvez également utiliser le module de noeud validateur et simplement utiliser comme ça

Installez la bibliothèque avec npm install validator

var validator = require('validator');

validator.isEmail('foo@bar.com'); //=> true 
 

Si vous définissez votre expression régulière comme une chaîne, toutes les barres obliques inverses doivent être échappées, donc au lieu de «\ w», vous devriez avoir «\ w».

Alternativement, définissez-le comme une expression régulière:

var pattern = /^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$/; 
 

Il y a des RegEx complexes écrits ici, qui fonctionnent aussi.

J'ai testé celui-ci et ça marche aussi:

[a-zA-Z0-9._]+[@]+[a-zA-Z0-9]+[.]+[a-zA-Z]{2,6}
 

Veuillez tester ceci ici: http://www.regextester.com/?fam=97334

J'espère que cela vous aidera.

me@localhost échoue.

Je voudrais ajouter une courte note sur les caractères non ASCII. La solution de Rnevius (et co.) Est brillante, mais elle permet d'ajouter des symboles cyrilliques, japonais, émoticônes et autres symboles unicode qui peuvent être limités par certains serveurs.

Le code ci-dessous imprimera true bien qu'il contienne le caractère UTF-8 Ё .

 console.log (/^(([^<>()\[\]\\.,;:\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 ('Ё@example.org'))  

Dans mon cas, tous les symboles non ASCII sont interdits, j'ai donc modifié l'expression originale pour exclure tous les caractères au-dessus de U + 007F:

 /^(([^\u0080-\uffff<>()\[\]\\.,;:\s@"]+(\.[^\u0080-\uffff<>()\[\]\\.,;:\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,}))$/  

Peut-être que cela aidera quelqu'un à prévenir les comportements indésirables.

Non, je pense que c'est un cas d'utilisation assez inhabituel pour que ce soit sa propre réponse

Que diriez-vous de créer une fonction qui testera n'importe quelle chaîne par rapport au modèle d'e-mails en utilisant une expression régulière en JavaScript, car nous savons que les adresses e-mail peuvent être très différentes dans différentes régions, comme au Royaume-Uni et en Australie, elles se terminent généralement par .co.uk ou , j'ai donc essayé de les couvrir également, vérifiez également si la chaîne est passée à la fonction, quelque chose comme ceci:

.com.au 

et vérifiez s'il s'agit d'un e-mail comme ci-dessous:

var isEmail = function(str) {
  return typeof str==='string' && /^[\w+\d+._]+\@[\w+\d+_+]+\.[\w+\d+._]{2,8}$/.test(str);
}
  

Que se passe-t-il avec alireza@test.uk ou phil.h\@\@cked+liked~it@haacked.com ?

Syntaxe de messagerie standard Wikipedia:

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
 

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

Exemple ES6

const validateEmail=(email)=> /^(([^<>()\[\]\\.,;:\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);
 

Maintenant, ReactNative version 0.46 utilise le code ci-dessous pour la validation des e-mails.

 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,}))$/;
     if (re.test(email)) {
     } else {
       alert('email: ' + "Please enter valid emailID.")
     }
 }
 

Vous pouvez également essayer

var string = "hmharsh3@gmail.com"
var exp = /(\w(=?@)\w+\.{1}[a-zA-Z]{2,})/i
alert(exp.test(string))
 

Cette réponse est loin d'être correcte: my.mail@gmail.com la casse déjà

Mise à jour Regex 2018! essayez ceci

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

Cela a échoué pour un email@domain.com standard

@RickS, ce n'est tout simplement pas vrai. Veuillez vérifier à nouveau

 <input type="email" class="form-control" required="required" placeholder="Email Address" name="Email" id="Email" autocomplete="Email">
 <button class="btn-1 shadow-0 full-width" type="button" id="register">Register account</button>
 

 $("#register").click(function(){       
    var rea = /^[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])?)*$/;
    var Email = $("#Email").val();
    var x = rea.test(Email);
    if (!x) {
        alert('Type Your valid Email');
        return false;
    }           
 </script>
 

Voici une expression régulière simple qui vérifierait simplement le format de base d'un e-mail, par exemple, X@Y.C :

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

Cette question est plus difficile à répondre qu'il n'y paraît à première vue.

Il y avait des tas de gens à travers le monde à la recherche de "l'expression rationnelle pour les gouverner tous", mais la vérité est qu'il existe des tonnes de fournisseurs de messagerie.

Quel est le problème? Eh bien, "a_z%@gmail.com ne peut pas exister mais il peut exister une adresse comme celle-ci via un autre fournisseur" a__z@provider.com.

Pourquoi? Selon le RFC: https://en.wikipedia.org/wiki/Email_address#RFC_specification .

Je vais prendre un extrait pour faciliter la conférence:

The local-part of the email address may use any of these ASCII characters:

- uppercase and lowercase Latin letters A to Z and a to z;
- digits 0 to 9;
- special characters !#$%&'*+-/=?^_`{|}~;
- dot ., provided that it is not the first or last character unless quoted, and provided also that it does not appear consecutively unless quoted (e.g. John..Doe@example.com is not allowed but "John..Doe"@example.com is allowed);[6]
Note that some mail servers wildcard local parts, typically the characters following a plus and less often the characters following a minus, so fred+bah@domain and fred+foo@domain might end up in the same inbox as fred+@domain or even as fred@domain. This can be useful for tagging emails for sorting, see below, and for spam control. Braces { and } are also used in that fashion, although less often.
- space and "(),:;<>@[\] characters are allowed with restrictions (they are only allowed inside a quoted string, as described in the paragraph below, and in addition, a backslash or double-quote must be preceded by a backslash);
- comments are allowed with parentheses at either end of the local-part; e.g. john.smith(comment)@example.com and (comment)john.smith@example.com are both equivalent to john.smith@example.com.
 

Donc, je peux posséder une adresse e-mail comme ça:

A__z/J0hn.sm{it!}h_comment@example.com.co
 

Si vous essayez cette adresse, je parie qu'elle échouera dans tout ou dans la majeure partie des expressions régulières publiées sur le net. Mais rappelez-vous que cette adresse suit les règles RFC, donc elle est juste valide.

Imaginez ma frustration de ne pas pouvoir vous inscrire n'importe où vérifié avec ces expressions régulières !!

Le seul qui peut vraiment valider une adresse e-mail est le fournisseur de l'adresse e-mail.

Comment gérer, alors?

Peu importe si un utilisateur ajoute un e-mail non valide dans presque tous les cas. Vous pouvez compter sur HTML 5 input type = "email" qui s'exécute près de RFC, peu de chances d'échouer. HTML5 input type = "email" info: https : //www.w3.org/TR/2012/WD-html-markup-20121011/input.email.html

Par exemple, il s'agit d'un e-mail valide RFC:

"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com
 

Mais la validation html5 vous dira que le texte avant @ ne doit pas contenir de caractères "ou () par exemple, ce qui est en fait incorrect.

Quoi qu'il en soit, vous devez le faire en acceptant l'adresse e-mail et en envoyant un e-mail à cette adresse e-mail, avec un code / lien que l'utilisateur doit visiter pour confirmer la validité.

Une bonne pratique lors de cette opération est l'entrée "saisir à nouveau votre e-mail" pour éviter les erreurs de frappe de l'utilisateur. Si cela ne vous suffit pas, ajoutez une fenêtre modale de pré-soumission avec un titre "est-ce votre e-mail actuel?", Puis le courrier entré par l'utilisateur dans une balise h2, vous savez, pour montrer clairement quel e -mail qu'ils ont entré, puis un bouton "oui, soumettre".

Comment écrire une expression régulière particulière dans Android ou Java.

1) USER_NAME = "^[A-Za-z0-9_-]{min number of character,max number of character}$";

2) TELEPHONE = "(^\\+)?[0-9()-]*";

3) TELEPHONE_OPTIONAL = "^($|(^\\+)?[0-9()-]*)$";

4) EMAIL = "[a-zA-Z0-9_\\.\\+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-\\.]+";

5) EMAIL_OPTIONAL = "^($|[a-zA-Z0-9_\\.\\+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-\\.]+)$";

6) WEB_URL = "^($|(http:\\/\\/|https:\\/\\/)?(www.)?([a-zA-Z0-9]+).[a-zA-Z0-9]*.[a-z]{3}.?([a-z]+)?)$";

7) WEB_URL_YOUTUBE_BE = "https?\\:\\/\\/(www\\.)?youtu(\\.)?be(\\.com)?\\/.*(\\?v=|\\/v\\/)?[a-zA-Z0-9_\\-]+";

8) POSTAL_ADDRESS = "[a-zA-Z\\d\\s\\-\\,\\#\\.\\+]+";

9) FIELD_NOT_EMPTY = "[^\\s]*";

10) PINCODE = "^([0-9]{6})?$";

11) IFSC_CODE = "^[^\\s]{4}\\d{7}$";

12) SWIFT_CODE = "^([0-9]{10})?$";

13) PINCODE = "^([0-9]{6})?$";

Il s'agit d'une traduction JavaScript de la validation suggérée par le guide officiel Rails utilisé par des milliers de sites Web:

/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
 

Relativement simple mais teste contre les erreurs les plus courantes.

Testé sur un ensemble de données de milliers d'e-mails et ne contenant aucun faux négatif / positif.

Exemple d'utilisation:

const emailRegex = /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i;

emailRegex.test('email@example.com');    // true

// Multi-word domains
emailRegex.test('email@example.co.uk');  // true
emailRegex.test('email@mail.gmail.com'); // true

// Valid special characters
emailRegex.test('unusual+but+valid+email1900=/!#$%&\'*+-/=?^_`.{|}~@example.com') // true

// Trailing dots
emailRegex.test('email@example.co.uk.'); // false

// No domain
emailRegex.test('email@example');        // false

// Leading space
emailRegex.test(' email@example.com');   // false

// Trailing space
emailRegex.test('email@example.com ');   // false

// Incorrect domains
emailRegex.test('email@example,com ');   // false

// Other invalid emails
emailRegex.test('invalid.email.com')        // false
emailRegex.test('invalid@email@domain.com') // false
emailRegex.test('email@example..com')       // false
 

Ne fonctionne pas pour drikk@øl.com ou tout autre personnage en dehors de a-z

Voici une solution qui fonctionne et inclut la fonctionnalité de validation / notification dans un formulaire:

Vous pouvez l'exécuter sur ce lien

JAVASCRIPT

(function() {
  'use strict';

  window.addEventListener('load', function() {
    var form = document.getElementById('needs-validation');
    form.addEventListener('submit', function(event) {
      if (form.checkValidity() === false) {
        event.preventDefault();
      }
      form.classList.add('was-validated');
      event.preventDefault();              
    }, false);
  }, false);
})();
 

HTML

<p class='title'>
    <b>Email validation</b>
  <hr size="30px;">
</p>
<br>

<form id="needs-validation" novalidate>
  <p class='form_text'>Try it out!</p>
  <div class="form-row">
    <div class="col-12">
      <input type="email" class="form-control" placeholder="Email Address" required>
        <div class="invalid-feedback">
          Please enter a valid email address.
        </div>
    </div>
  <div class="row">
    <div class="col-12">
      <button type="submit" 
          class="btn btn-default btn-block">Sign up now
      </button>
    </div>
   </div>
</form>
 

J'ai écrit un validateur d'e-mail JavaScript qui est entièrement compatible avec l'implémentation filter_var($value, FILTER_VALIDATE_EMAIL) de PHP.

https://github.com/mpyw/FILTER_VALIDATE_EMAIL.js

import validateEmail from 'filter-validate-email'

const value = '...'
const result = validateEmail(value)
 

est équivalent à:

<?php

$value = '...';
$result = (bool)filter_var($value, FILTER_VALIDATE_EMAIL, FILTER_FLAG_EMAIL_UNICODE);
 

function ValidateEmail(mail) 
{
  if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
  {
    return (true)
  }
  alert("You have entered an invalid email address!")
  return (false)
}
 

URL de référence: https://www.w3resource.com/javascript/ form / email-validation.php

Cela fonctionne pour moi:

function Email(mail)
{
 if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
  {
    return (true)
  }
    alert("Invalid email address!")
    return (false)
}
 

La partie personal_info contient les caractères ASCII suivants.

  1. Lettres anglaises majuscules (A-Z) et minuscules (a-z). Chiffres (0-9).
  2. Personnages! # $% & '* + - / =? ^ _ `{| } ~
  3. Personnage. (point, point ou point final) à condition qu'il ne soit pas premier ou dernier caractère et il ne viendra pas l'un après l'autre.

La partie nom de domaine [par exemple com, org, net, in, us, info] contient des lettres, des chiffres, des tirets et des points.

 function ValidateEmail(mail) 
{
 if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
  {
    return (true)
  }
    alert("You have entered an invalid email address!")
    return (false)
}
 

Vous pouvez également utiliser la nouvelle classe Regex et procéder comme suit:

function validateEmail( str ) { return new RegExp( /([\w\.\-_]+)?\w+@[\w-_]+(\.\w+){1,}/, 'igm' ).test( str ); }

référence: https://developer.mozilla.org/en-US/ docs / Web / JavaScript / Guide / Regular_Expressions

Voici le modèle Regex recommandé pour HTML5 sur MDN:

  

Les navigateurs qui prennent en charge le type d'entrée de courrier électronique fournissent automatiquement une validation pour garantir que seul le texte correspondant au format standard des adresses de messagerie Internet est entré dans la zone de saisie. Les navigateurs qui implémentent la spécification doivent utiliser un algorithme équivalent à l'expression régulière suivante:

/^[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])?)*$/
 

https: //developer.mozilla .org / en-US / docs / Web / HTML / Element / input / email # Validation

Bien. Avez-vous déjà essayé d'autres méthodes de validation comme les services PHP ou API? Comme DeBounce Email Validation Tool.

Vous utilisez à froid https://github.com/chriso/validator.js et faites simplement:

var validator = require('validator');

validator.isEmail('foo@bar.com'); //=> true
 

Notez que cela peut fonctionner sur le client.

Voici comment je le fais. J'utilise match () pour vérifier le modèle d'e-mail standard et j'ajoute une classe au texte d'entrée pour informer l'utilisateur en conséquence. J'espère que ça aide!

 $(document).ready(function(){
  $('#submit').on('click', function(){
      var email = $('#email').val();
      var pat = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
      if (email.match(pat)){
        $('#email')
          .addClass('input-valid');
        return false;
      } else {
        $('#email')
        	.addClass('input-error')
          .val('');
        return false;
      }
  });
});  
 .input-error {
  border: 1px solid red;
  color: red;
}

.input-valid {
  border: 1px solid green;
  color: green;
}  
 <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<form>
    <input type="text" id="email" placeholder="name@service.xx" class="">
    <input type="submit" id="submit" value="Send"/>
</form>  

Avez-vous déjà essayé DeBounce Validation des e-mails ? Je suggère de jeter un œil à cela.

Il y a ma version d'un validateur d'email. Ce code est réalisé avec une programmation orientée objet et réalisé en tant que classe avec des méthodes statiques. Vous trouverez deux versions des validateurs: strict (EmailValidator.validate ) et kind (EmailValidator.validateKind ).

Le premier génère une erreur si un e-mail n'est pas valide et renvoie un e-mail dans le cas contraire. La seconde renvoie une valeur booléenne qui indique si un e-mail est valide. Je préfère la version stricte dans la plupart des cas.

export class EmailValidator {
    /**
     * @param {string} email
     * @return {string}
     * @throws {Error}
     */
    static validate(email) {
        email = this.prepareEmail(email);

        const isValid = this.validateKind(email);

        if (isValid)
            return email;

        throw new Error(`Got invalid email: ${email}.`);
    }

    /**
     * @param {string} email
     * @return {boolean}
     */
    static validateKind(email) {
        email = this.prepareEmail(email);

        const regex = this.getRegex();

        return regex.test(email);
    }

    /**
     * @return {RegExp}
     * @private
     */
    static getRegex() {
        return /^(([^<>()\[\]\\.,;:\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,}))$/;
    }

    /**
     * @param {string} email
     * @return {string}
     * @private
     */
    static prepareEmail(email) {
        return String(email).toLowerCase();
    }
}
 

Pour valider un e-mail, vous pouvez suivre les étapes suivantes:

// First way.

try {
    EmailValidator.validate('balovbohdan@gmail.com');
} catch (e) {
    console.error(e.message);
}
 
// Second way.

const email = 'balovbohdan@gmail.com';
const isValid = EmailValidator.validateKind(email);

if (isValid)
    console.log(`Email is valid: ${email}.`);
else
    console.log(`Email is invalid: ${email}.`);
 

J'utilise cette fonction

/**
 * @param {*} email
 */
export const validateEmail = email => {
    return new RegExp(/[\w-]+@([\w-]+\.)+[\w-]+/gm).test(email);
};
 

Ne fonctionne pas pour Unicode. validateEmail('køkø@gmail.com') === false . Oubliez la validation en utilisant des contrôles comme celui-ci. Testez @ et envoyez simplement un e-mail à l'utilisateur.

Expression générale des e-mails (norme officielle RFC 5322): https://emailregex.com/

JavaScript:

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

Avatar Pax

Recherchez le signe @ dans le champ de saisie.

Cette! C'est la seule vérification valable que vous pouvez vraiment faire qui ne complique pas les choses inutilement. Si vous voulez vraiment savoir si l'e-mail est valide, envoyez un e-mail à l'utilisateur.

Si vous voulez quelque chose qu'un être humain puisse lire et maintenir , je recommanderais Masala Parser (j'en suis l'un des créateurs).

 import {C,Streams} from '@masala/parser'

const illegalCharset = ' @\u00A0\n\t';
const extendedIllegalCharset = illegalCharset + '.';


// Assume 'nicolas@internal.masala.co.uk'
export function simpleEmail() {

    return C.charNotIn(illegalCharset).rep() // 'nicolas'
        .then(C.char('@'))
        .then(subDns())  //'internal.masala.co.'
        .then(C.charNotIn(extendedIllegalCharset).rep()) //'uk'
        .eos(); // Must be end of the char stream
}

// x@internal.masala.co.uk => extract 'internal.masala.co.'
function  subDns() {
    return C.charNotIn(extendedIllegalCharset).rep().then(C.char('.')).rep()
}

function validateEmail(email:string) {
    console.log(email + ': ' + (simpleEmail().parse(Streams.ofString(email)).isAccepted()));
}


validateEmail('nicolas@internal.masala.co.uk'); // True
validateEmail('nz@co.'); // False, trailing "."
  

Si vous souhaitez accepter la dernière version de courrier électronique laide, vous pouvez ajouter des guillemets dans la première partie:

 
function inQuote() {
    return C.char('"')
        .then(C.notChar('"').rep())
        .then(C.char('"'))
}

function allEmail() {

    return inQuote().or(C.charNotIn(illegalCharset))
        .rep() // repeat (inQuote or anyCharacter)
        .then(C.char('@'))
        .then(subDns())
        .then(C.charNotIn(extendedIllegalCharset).rep())
        .eos() // Must be end of the character stream
        // Create a structure
        .map(function (characters) { return ({ email: characters.join('') }); });
}
  

'"nicolas""love-quotes"@masala.co.uk' est officiellement valide, mais devrait-il être dans votre système?

Au moins avec Masala, vous vous donnez une chance de le comprendre. Et donc pour l'année prochaine, collègue.

J'ajoute mon Regex - j'ai résolu pour moi plus de petits problèmes comme les caractères d'autres langues ou les majuscules

^[a-zA-Z0-9][a-zA-Z0-9-_\.]+@([a-zA-Z]|[a-zA-Z0-9]?[a-zA-Z0-9-]+[a-zA-Z0-9])\.[a-zA-Z0-9]{2,10}(?:\.[a-zA-Z]{2,10})?$
 

Utilisez le navigateur / runtime pour gérer l'analyse de l'entrée en ajoutant un protocole et en le transmettant à l'API URL , en détectant toutes les erreurs et en vérifiant les username et hostname propriétés du résultat. Il gérera essentiellement toutes les transformations et possibilités ( punycode des jeux de caractères, etc.). Cela établit seulement que l'entrée est analysable, pas celle qui est valide - cela n'est possible qu'en vérifiant si la machine de destination reçoit des messages pour cet alias. Cela fournit une supposition étroite (imo raisonnable) et peut être développé pour être plus spécifique et réaliste si vous êtes à l'aise à la fois de le maintenir et de risquer des rejets non valides. (Notez qu'il n'essaie pas d'adresser les adresses IPv4 ou IPv6, mais simplement le large éventail de scénarios destinés aux clients utilisant un domaine.)

 

C'est l'exemple à la fois le plus simple et le plus généralement permissif que je puisse trouver. Veuillez le modifier dans les cas où il peut être rendu plus précis tout en conservant sa simplicité et sa validité généralement permissive raisonnable.

Voir également la documentation de l'URL MDN URL , window.URL et Nodejs pour URL API.

pour la validation des e-mails, vous pouvez créer votre fonction personnalisée et utiliser la syntaxe regex pour valider les e-mails:

function validateEmail(email){
        var reg = /^([A-Za-z0-9_\-\.])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/;

       //your custom code here to check your email address 

}
 

Ceux-ci fonctionneront avec les e-mails les plus utilisés ( ils correspondent exactement aux règles de chacun ).

Gmail
/^[a-z]((?!\.\.)([a-z\.])){4,28}[a-z0-9]@google.com$/i

Yahoo
/^[a-z]((?!\.\.)([\w\.])){3,30}[\w]@yahoo.com$/i

Outlook / Hotmail
/[a-z]((?!\.\.)([\w\.])){0,62}[\w]@(outlook.com|hotmail.com)$/i

Savez-vous que \w comprend déjà \d et _ ? Veuillez consulter ces sites: Liste des TLD ; adresses valides / invalides ; regex pour l'adresse e-mail RFC822

@Toto c'est vrai, je ne sais pas comment je l'ai perdu là-bas, j'ai en fait utilisé cette expression régulière dans le traitement de ma base de données: \, merci encore.

Vous pouvez essayer RegExp

 function isValidEmail( value ) {
	return /^[\w\-\.\+]+\@[a-zA-Z0-9\.\-]+\.[a-zA-z0-9]{2,5}$/.test( value );
}

console.log( isValidEmail("mymail@mydomain.com") )  

Dans mon cas, je veux éviter ~ et # c'est pourquoi j'ai utilisé une autre solution Cliquez ici Pour plus d'informations

function validEmail(email){
  const regex = /^((?!\.)[\w-_.]*[^.])(@\w+)(\.\w+(\.\w+)?[^.\W])$/;
  return regex.test(email);
}
 

 function validEmail(email){
  const regex = /^((?!\.)[\w-_.]*[^.])(@\w+)(\.\w+(\.\w+)?[^.\W])$/;
  return regex.test(email);
}

const emails = [
'pio_pio@factory.com',
'~pio_pio@factory.com',
'pio_~pio@factory.com',
'pio_#pio@factory.com',
'pio_pio@#factory.com',
'pio_pio@factory.c#om',
'pio_pio@factory.c*om',
'pio^_pio@factory.com'
]

for(const email of emails){
  document.write(email+' : '+validEmail(email)+'</br>');
}