JavaScript'te bir e-posta adresi nasıl doğrulanır?

JavaScript'te bir e-posta adresini doğrulamak için düzenli bir ifade var mı?

Düzenli ifadeler kullanmak muhtemelen en iyi yoldur. Burada bir sürü test görebilirsiniz ( kromdan alınmıştır )

function validateEmail(email) {
    const re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    return re.test(String(email).toLowerCase());
}

Unicode'u kabul eden düzenli ifade örneği:

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

Ancak, yalnızca JavaScript doğrulamasına güvenmemeniz gerektiğini unutmayın. JavaScript kolayca devre dışı bırakılabilir. Bu, sunucu tarafında da doğrulanmalıdır.

İşte yukarıdaki eylemlere bir örnek:

function validateEmail(email) {
  const re = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
  return re.test(email);
}

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

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

$("#validate").on("click", validate);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

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

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

Şeklinde gerçekten basit doğrulama isteyen insanlar için Jaymon'un cevabını biraz değiştirdim :

anystring@anystring.anystring

Normal ifade:

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

Örnek JavaScript işlevi:

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

Sadece eksiksizlik için, burada başka bir RFC 2822 uyumlu regex var

Resmi standart RFC 2822 olarak bilinir . Geçerli e-posta adreslerinin uyması gereken sözdizimini açıklar. Sen olabilir ( ama olmamalı - okumaya bu düzenli ifade ile bunu uygulamaya):

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

(...) Sözdizimini çift tırnak ve köşeli parantez kullanarak atlarsak, RFC 2822'nin daha pratik bir uygulamasını elde ederiz. Bugün hala kullanılmakta olan tüm e-posta adreslerinin% 99,99'uyla eşleşecektir.

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

Yapabileceğiniz başka bir değişiklik, iki harfli ülke kodu üst düzey alan adına ve yalnızca belirli genel üst düzey alanlara izin vermektir. Bu normal ifade gibi kukla e-posta adreslerini filtrelerasdf@adsf.adsf . Sen yeni üst düzey etki eklendikçe güncellemeniz gerekecektir .

[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

Bu nedenle, resmi standartları takip ederken bile, yapılması gereken değişimler vardır. Çevrimiçi kütüphanelerden veya tartışma forumlarından normal ifadeleri körü körüne kopyalamayın. Bunları her zaman kendi verilerinizde ve kendi uygulamalarınızla test edin.

_{Vurgu madeni}

Vay be, burada bir sürü karmaşıklık var. Yapmak istediğiniz tek şey en belirgin sözdizimi hatalarını yakalamaksa, böyle bir şey yapardım:

^\S+@\S+$

Genellikle kullanıcının yaptığı en belirgin hataları yakalar ve formun çoğunlukla doğru olduğunu garanti eder, bu da JavaScript doğrulamasının temelini oluşturur.

E-postaları doğrulamak için normal ifadeyi kullanmaya karar verdiğiniz saniyeyi anlamanız gereken bir şey var: Muhtemelen iyi bir fikir değil . Bunu kabul ettikten sonra, orada yarıya varabilecek birçok uygulama var, bu makale onları güzel bir şekilde özetliyor.

Kısacası, kullanıcının girdiği şeyin aslında bir e-posta olduğundan kesinlikle emin olmanın tek yolu, aslında bir e-posta göndermek ve ne olduğunu görmek. Bunun dışında hepsi sadece tahminler.

HTML5'in kendisinde e-posta doğrulaması vardır. Tarayıcınız HTML5'i destekliyorsa, aşağıdaki kodu kullanabilirsiniz.

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

jsFiddle bağlantısı

Gönderen HTML5 spec :

Bir geçerli bir e-posta adresi ile eşleşen bir dize emailaşağıdaki ABNF üretimini, karakter kümesi Unicode olduğunu.

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 >

Bu gereksinim, aynı anda çok katı ("@" karakterinden önce), çok belirsiz ("@" karakterinden sonra) ve çok gevşek (yorumlara izin veren) e-posta adresleri için bir sözdizimi tanımlayan, RFC 5322'nin kasıtlı bir ihlalidir . , boşluk karakterleri ve alıntılanmış dizeler çoğu kullanıcıya yabancıdır) burada pratik olarak kullanılabilir.

Aşağıdaki JavaScript ve Perl uyumlu düzenli ifade, yukarıdaki tanımın bir uygulamasıdır.

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

Bunu en iyi çözüm olarak buldum:

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

Aşağıdaki biçimlere izin verir:

1. prettyandsimple@example.com
2. very.common@example.com
3. tek kullanımlık.
4. other.email-with-dash@example.com
9. #!$%&'*+-/=?^_`{ {|~@example.org
6. "() []:,; @ \\\"! # $% & '* + - / =? ^ _ `{} | ~ .A "@ example.org
7. "" @ example.org (tırnak işaretleri arasındaki boşluk)
8. üñîçøðé@example.com (Yerel bölümdeki Unicode karakterler)
9. üñîçøðé@üñîçøðé.com (Alan adı bölümünde Unicode karakterler)
10. Pelé@example.com (Latin)
11. δοκιμή@παράδειγμα.δοκιμή (Yunanca)
12. 我 買 @ 屋企. 香港 (Çince)
13. 甲 斐 @ 黒 川. 日本 (Japonca)
14. чебурашка@ящик-с-апельсинами.рф (Kiril)

Çok yönlüdür ve önemli uluslararası karakterlere izin verirken, temel bir şey@ything.yothing biçimini hala uygular. Teknik olarak RFC tarafından izin verilen alanları engelleyecek, ancak çok nadirdirler, bunu yapmaktan mutluluk duyuyorum.

Modern tarayıcılarda @ Sushil'in saf JavaScript ve DOM ile cevabının üstüne inşa edebilirsiniz :

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

Http://jsfiddle.net/boldewyn/2b6d5/ kemanına bir örnek koydum . Özellik algılama ve Squirtle's Answer'dan çıplak kemik doğrulaması ile birleştiğinde , sizi normal ifade katliamından kurtarır ve eski tarayıcılarda uğraşmaz.

Bu doğru RFC822 sürümüdür.

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

  var reValidEmail = new RegExp(sValidEmail);

  return reValidEmail.test(emailAddress);
}

JavaScript normal bir ifadeyle eşleşebilir:

emailAddress.match( / some_regex /);

İşte e-postalar için bir RFC22 düzenli ifadesi:

^((?>[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)>)$

Tüm e-posta adreslerinde 'at' (yani @) sembolü bulunur. Gerekli koşulu test edin:

email.indexOf("@") > 0

Daha karmaşık bir şeyle uğraşmayın. Bir e-postanın RFC sözdizimsel olarak geçerli olup olmadığını mükemmel bir şekilde belirleyebilseniz bile, bu e-postanın onu sağlayan kişiye ait olup olmadığını söylemez. Gerçekten önemli olan bu.

Bunu test etmek için bir doğrulama mesajı gönderin.

E-posta adresinin RFC'lere uygun olarak doğrulanması, tek satırlık düzenli bir ifade ile gerçekleştirilebilecek bir şey değildir. PHP'de bulduğum en iyi çözümü içeren bir makale Geçerli bir e-posta adresi nedir? . Açıkçası, Java'ya taşındı. Bence bu işlevin JavaScript'te taşınması ve kullanılması çok karmaşık. JavaScript / node.js bağlantı noktası: https://www.npmjs.com/package/email-addresses .

İstemcideki verilerinizi doğrulamak iyi bir yöntemdir, ancak sunucudaki doğrulamayı iki kez kontrol edin. Bunu göz önünde bulundurarak, bir dizenin istemcide geçerli bir e-posta adresi gibi olup olmadığını kontrol edebilir ve sunucuda sıkı bir kontrol gerçekleştirebilirsiniz.

Bir dizenin geçerli bir posta adresi gibi olup olmadığını kontrol etmek için kullandığım JavaScript işlevi:

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

Açıklama:

• lastAtPos < lastDotPos: Son @son öncesinde olmalıdır .çünkü @sunucu adının bir parçası olamaz (bildiğim kadarıyla).

• lastAtPos > 0: Sondan önce bir şey (e-posta kullanıcı adı) olmalıdır @.

• str.indexOf('@@') == -1: Adresinde hayır olmamalıdır @@. Bile @e-posta kullanıcı son karakter olarak göründüğünde, bu alıntı zorundadır böylece "arasındaki olacağını @ve son @adresi.

• lastDotPos > 2: Örneğin, son noktadan önce en az üç karakter olmalıdır a@b.com.

• (str.length - lastDotPos) > 2: İki noktadan oluşan bir alan oluşturmak için son noktadan sonra yeterli karakter olmalıdır. Köşeli parantezlerin gerekli olup olmadığından emin değilim.

Bu, http://codesnippets.joyent.com/posts/show/1917 adresinden çalındı.

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

Bunu yap:

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

Neden? Standart TÜM e-posta adreslerine uyulması GEREKİR RFC 2822'yi temel alır . Ve neden "daha basit" bir şeyle uğraştığınızdan emin değilim ... yine de kopyalayıp yapıştıracaksınız;)

Genellikle e-posta adreslerini veritabanında saklarken küçük harfli hale getiririm ve pratikte normal ifadeler genellikle büyük / küçük harfe duyarsız olarak işaretlenebilir. Bu durumlarda bu biraz daha kısadır:

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

Aşağıda JavaScript'te kullanıldığına ilişkin bir örnek verilmiştir (büyük / küçük harf duyarsız bayrak isonunda).

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

Not :
Teknik olarak bazı e-postalar, tırnak içinde @kaçış karakterleri bulunan simgeden önceki bölümde tırnak işareti içerebilir (bu nedenle e-posta kullanıcınız iğrenç olabilir ve tırnak işaretleri içine alındığı sürece @ve "..."gibi şeyler içerebilir ). KİMSE HİÇ BU KADAR! Eski. Ancak, gerçek RFC 2822'ye dahil standardına ve burada atlanır.

Daha fazla bilgi: http://www.regular-expressions.info/email.html

Gerçekten bu sorunu çözmek için sabırsızlanıyorum. Bu yüzden yukarıdaki e-posta doğrulama normal ifadesini değiştirdim

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

• Değiştirilmiş
  /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+[^<>()\.,;:\s@\"]{2,})$/

e-posta adresindeki örnekleri geçirmek için .

Ve sonucu burada görebilirsiniz .

Giriş dizesini doğrulamak için normal e-posta olup olmadığını kontrol etmek için normal ifadeler kullanmamalısınız. Çok karmaşık ve tüm vakaları kapsamaz.

Şimdi vakaların sadece% 90'ını kapsayabildiğiniz için, şöyle bir şey yazın:

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

Hassaslaştırabilirsiniz. Örneğin, 'aaa @' geçerlidir. Ama genel olarak özü elde edersiniz. Ve taşınmayın ... Basit bir% 90 çözüm, çalışmayan% 100 çözümden daha iyidir.

Dünyanın daha basit bir koda ihtiyacı var ...

Girilen e-posta adresinin geçerli olup olmadığını HTML kullanarak kontrol etmeniz yeterlidir.

<input type="email"/>

Doğrulama için bir işlev yazmaya gerek yoktur.

% 100 doğru bir e-posta doğrulayıcı almak zor. Bunu düzeltmenin tek gerçek yolu, hesaba bir test e-postası göndermektir. Bununla birlikte, makul bir şey aldığınızdan emin olmanıza yardımcı olabilecek birkaç temel kontrol var.

Geliştirilecek bazı şeyler:

Yeni yerine RegExp, şu şekilde yazmayı deneyin regexp:

if (reg.test(/@/))

İkinci olarak, @işaretten sonra bir nokta geldiğinden emin olun ve @s ile nokta arasında karakterler olduğundan emin olun .

Bu nasıl düğüm-doğrulayıcı yapar:

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

Doğrulayıcı işlevinizde bu kodu kullanın:

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

Başka jQuery kullanabilirsiniz . İç kurallar şunları tanımlar:

eMailId: {
    required: true,
    email: true
}

Regex güncelleme 2018! bunu dene

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

typscript sürümü tamamlandı

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

daha fazla bilgi https://git.io/vhEfc

TLD'nin varlığını kontrol etmeyen bir çözüm eksik.

Bu soruların hemen hemen tüm yanıtları, e-posta adreslerini doğrulamak için Regex'in kullanılmasını önermektedir. Bence Regex sadece temel bir onay için iyi. Görünüşe göre e-posta adreslerinin doğrulanması iki ayrı sorundur:

1- E-posta biçiminin doğrulanması: E-postanın RFC 5322'deki e-postaların biçimine ve desenine uygun olup olmadığından ve TLD'nin gerçekten var olup olmadığından emin olun. Geçerli tüm TLD'lerin bir listesini burada bulabilirsiniz .

Örneğin, adres example@example.cccnormal ifadeyi geçecek olsa da , geçerli bir e-posta cccdeğildir , çünkü IANA tarafından üst düzey bir alan adı değildir.

2- emin olma eposta gerçekte var: Bu iş için, tek seçenek olan bir e-posta kullanıcıları göndermek .

E-posta adresini doğrulamak için normal ifade

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

İşte e-posta adreslerini doğrulamak için düzenli ifadeler kullanma hakkında çok iyi bir tartışma; " Normal İfadeleri Doğrulama E-posta Adresini Karşılaştırma "

Referans amacıyla şu anki en iyi ifade olan JavaScript uyumludur:

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

Görünüşe göre, hepsi bu:

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

Alındığı http://fightingforalostcause.net/misc/2006/compare-email-regex.php Eki 1 '10 tarihinde.

Ancak, elbette, bu uluslararasılaşmayı görmezden geliyor.

Squirtle'ın aksine , burada karmaşık bir çözüm var, ancak e-postaları düzgün bir şekilde doğrulamak için güçlü bir iş yapıyor:

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

Şöyle kullanın:

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

Düzenli ifade bilgim o kadar iyi değil. Bu yüzden genel sözdizimini önce basit bir düzenli ifade ile kontrol ediyorum ve daha sonra diğer fonksiyonlarla daha spesifik seçenekleri kontrol ediyorum. Bu en iyi teknik çözüm olmayabilir, ancak bu şekilde çok daha esnek ve hızlıyım.

Karşılaştığım en yaygın hatalar boşluklar (özellikle başlangıçta ve sonunda) ve bazen çift noktadır.

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

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

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

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

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

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

JS'de tüm e-posta adresi sınama örneklerini geçiren bir Regex arıyordum:

• email@example.com Geçerli e-posta

• firstname.lastname@example.com E-posta adres alanında nokta içeriyor

• email@subdomain.example.com E-postada alt alan adı olan nokta var

• firstname+lastname@example.com Artı işareti geçerli karakter olarak kabul edilir

• email@192.0.2.123 Alan adı geçerli bir IP adresidir

• email@[192.0.2.123] IP adresinin etrafındaki köşeli ayraç geçerli kabul edilir

• “email”@example.com E-posta ile ilgili teklifler geçerli kabul edilir

• 1234567890@example.com Adresteki rakamlar geçerlidir

• email@domain-one.example Alan adındaki kısa çizgi geçerli

• _______@example.com Adres alanındaki alt çizgi geçerlidir

• email@example.name .name geçerli Üst Düzey Alan adı

• email@example.co.jp Üst Düzey Alan adındaki nokta da geçerli sayılır (kullanarak co.jp burada örnek olarak )

• firstname-lastname@example.com Adres alanındaki tire işareti geçerli

İşte başlıyoruz :

http://regexr.com/3f07j

VEYA normal ifade:

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

İçinde Microsoft tarafından sağlanan düzenli ifade ASP.NET MVC olduğunu

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

Hangi kusurlu olması durumunda burada post it - Gerçi her zaman benim ihtiyaçları için mükemmel oldu.