web-dev-qa-db-fra.com

Validation d'email d'expressions régulières JavaScript

Ce code alerte toujours "null", ce qui signifie que la chaîne ne correspond pas à l'expression.

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

function isEmailAddress(str) {

    str = "[email protected]";      

    alert(str.match(pattern)); 
    return str.match(pattern);    

}
javascriptregex
94
azamsharp

Si vous définissez votre expression régulière en tant que chaîne, toutes les barres obliques inverses doivent être ignorées. Par conséquent, au lieu de "\ w", vous devez avoir "\\ w".

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

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

BTW, s'il vous plaît ne pas valider les adresses e-mail du côté client. Votre expression régulière est bien trop simple pour passer pour une implémentation solide de toute façon.

Voir la vraie chose ici: http://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html

70
James

c'est celui que j'utilise sur ma page.

http://www.zparacha.com/validate-email-address-using-javascript-regular-expression/

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

27
rat

J'utilise cette fonction depuis un moment. il retourne une valeur booléenne.

// Validates email address of course.
function validEmail(e) {
    var filter = /^\s*[\w\-\+_]+(\.[\w\-\+_]+)*\@[\w\-\+_]+\.[\w\-\+_]+(\.[\w\-\+_]+)*\s*$/;
    return String(e).search (filter) != -1;
}
13
rcastera

Vous pouvez être intéressé par cette question (ou celui-ci ), ce qui met en évidence le fait que l'identification d'adresses e-mail valides via regexps est un problème très difficile à résoudre (même s'il est possible de le résoudre )

11
Brian Agnew
function isEmailAddress(str) {
   var pattern =/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
   return pattern.test(str);  // returns a boolean 
}
8
Nanhe Kumar

Parfois, la plupart des pages d’inscription et de connexion doivent valider un courrier électronique. Dans cet exemple, vous apprendrez la validation de courrier électronique simple. Prenez d'abord une entrée de texte en HTML et une entrée de bouton comme celle-ci

<input type='text' id='txtEmail'/>
<input type='submit' name='submit' onclick='checkEmail();'/>

<script>
    function checkEmail() {
        var email = document.getElementById('txtEmail');
        var filter = /^(([^<>()\[\]\\.,;:\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 (!filter.test(email.value)) {
            alert('Please provide a valid email address');
            email.focus;
            return false;
        }
    }
</script>

vous pouvez également vérifier en utilisant cette expression régulière

<input type='text' id='txtEmail'/>
<input type='submit' name='submit' onclick='checkEmail();'/>

<script>
    function checkEmail() {

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

        if (!filter.test(email.value)) {
            alert('Please provide a valid email address');
            email.focus;
            return false;
        }
    }
</script>

Vérifiez cette sortie de démonstration que vous pouvez vérifier ici

function checkEmail() {
        var email = document.getElementById('txtEmail');
        var filter = /^(([^<>()\[\]\\.,;:\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 (!filter.test(email.value)) {
            alert('Please provide a valid email address');
            email.focus;
            return false;
        }
    }
<input type='text' id='txtEmail'/>
<input type='submit' name='submit' onclick='checkEmail();'/>

si l'email est invalide, alors donnez un message d'alerte, si l'email est valide, alors aucun message d'alerte. pour plus d'informations sur l'expression régulière

https://www.w3schools.com/jsref/jsref_obj_regexp.asp

espérons que cela vous aidera

7
Shafiqul Islam

avec plus simple regex

C'est ici :

var regexEmail = /\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*/;
var email = document.getElementById("txtEmail");

if (regexEmail.test(email.value)) {
    alert("It's Okay")
} else {
    alert("Not Okay")

}

bonne chance.

7
M.R.Safari

Vous voudrez peut-être jeter un coup d'œil à ceci page il répertorie les expressions régulières permettant de valider une adresse électronique qui couvrent des cas plus généraux.

5
Nadia Alramli

La validation de courrier électronique est facile de se tromper. Je vous recommande donc d'utiliser Verimail.js .

Pourquoi?

  • Validation de la syntaxe (selon RFC 822).
  • Validation du TLD IANA
  • Suggestion orthographique pour les TLD et les domaines de messagerie les plus courants
  • Refuser les domaines de comptes de messagerie temporaires tels que mailinator.com
  • support du plugin jQuery

Un autre grand avantage de Verimail.js est qu’il contient des suggestions d’orthographe pour les domaines de messagerie les plus courants et les TLD enregistrés. Cela peut réduire considérablement votre taux de rebond pour les utilisateurs qui mal orthographient des noms de domaine courants tels que gmail.com, hotmail.com, aol.com, etc.

Exemple:

Comment l'utiliser?

La méthode la plus simple consiste à télécharger et à inclure verimail.jquery.js sur votre page. Après cela, connectez Verimail en exécutant la fonction suivante sur la zone de saisie qui nécessite la validation:

$("input#email-address").verimail({
    messageElement: "p#status-message"
});

L'élément message est un élément facultatif qui affiche un message tel que "Adresse électronique non valide .." ou "Voulez-vous dire [email protected]?". Si vous avez un formulaire et que vous souhaitez continuer uniquement si le courrier électronique est vérifié, vous pouvez utiliser la fonction getVerimailStatus comme indiqué ci-dessous:

if($("input#email-address").getVerimailStatus() < 0){
    // Invalid email
}else{
    // Valid email
}

La fonction getVerimailStatus renvoie un code entier en fonction de l'objet Comfirm.AlphaMail.Verimail.Status. Comme indiqué ci-dessus, si le statut est un entier négatif, la validation doit être traitée comme un échec. Mais si la valeur est supérieure ou égale à 0, la validation doit être traitée comme une réussite.

5
Robin Orheden

J'ai utilisé celui-ci ....

/^[\w._-]+[+]?[\w._-]+@[\w.-]+\.[a-zA-Z]{2,6}$/

Il permet que + avant @([email protected])

3
teacher

Un peu tard pour la fête, mais ici ne va rien ...

function isEmailValid(emailAdress) {
    var EMAIL_REGEXP = new RegExp('^[a-z0-9]+(\.[_a-z0-9]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,15})$', 'i');
    return EMAIL_REGEXP.test(emailAdress)
}

http://jsfiddle.net/yrshaikh/xvd6H/

2
Yasser
var emailRegex = /^[A-Z0-9_'%=+!`#~$*?^{}&|-]+([\.][A-Z0-9_'%=+!`#~$*?^{}&|-]+)*@[A-Z0-9-]+(\.[A-Z0-9-]+)+$/i;
if(emailRegex.test('yoursamplemail'))
alert('valid');
else
alert('invalid');
2
Santron Manibharathi

Vous pouvez également essayer cette expression, je l'ai testée avec de nombreuses adresses électroniques.

var pattern = /^[A-Za-z0-9._%+-]+@([A-Za-z0-9-]+\.)+([A-Za-z0-9]{2,4}|museum)$/;
2
Sabeeh Chaudhry

Validation simple mais puissante du courrier électronique pour la syntaxe de vérification du courrier électronique:

var EmailId = document.getElementById('Email').value;
var emailfilter = /^[\w._-]+[+]?[\w._-]+@[\w.-]+\.[a-zA-Z]{2,6}$/;
if((EmailId != "") && (!(emailfilter.test(EmailId ) ) )) {
    msg+= "Enter the valid email address!<br />";
}
1
Gaurav Gupta

N'oubliez pas que a-z, A-Z, 0-9,., _ Et - ne sont pas les seuls caractères valides au début d'une adresse électronique.

Gmail, par exemple, vous permet de mettre un signe "+" dans l'adresse pour "simuler" un courrier électronique différent (par exemple, quelqu'[email protected] recevra également un courrier électronique envoyé à quelqu'[email protected]).

micky.o'[email protected] n'apprécierait pas que votre code les empêche de saisir leur adresse ... les apostrophes sont parfaitement valables dans les adresses électroniques.

Le "contrôle" de fermeture d'une adresse email valide mentionnée ci-dessus est, comme il est dit, assez naïf:

http://code.google.com/p/closure-library/source/browse/trunk/closure/goog/format/emailaddress.js#198

Je recommande d’être très ouvert dans votre code côté client, puis beaucoup plus lourd comme envoyer un email avec un lien pour vraiment vérifier qu’il est "valide" (comme syntaxiquement valide pour son fournisseur, et également non mal orthographié).

Quelque chose comme ça:

var pattern = /[^@]+@[-a-z\.]\.[a-z\.]{2,6}/

Gardant à l'esprit que théoriquement, vous pouvez avoir deux signes @ dans une adresse électronique, et je n'ai même pas inclus de caractères autres que latin1 dans les noms de domaine!

http://www.eurid.eu/en/eu-domain-names/idns-e

http://haacked.com/archive/2007/08/21/i-knew-how-to-validate-an-email-address-until-i.aspx

0
pete otaqui

Il serait préférable d'utiliser:

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

Cela autorise des domaines tels que: any.info (4 lettres à la fin)

Également pour tester, en utilisant

pattern.test("[email protected]")

renvoie vrai si cela fonctionne

http://www.w3schools.com/js/js_obj_regexp.asp

0
Alex V