javascript जावास्क्रिप्ट में एक ईमेल पता कैसे सत्यापित करें?




regex validation (24)

जावास्क्रिप्ट में एक ईमेल पता कैसे सत्यापित किया जा सकता है?


यह करो:

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

क्यूं कर? यह आरएफसी 2822 पर आधारित है , जो एक मानक सभी ईमेल पते का पालन करना चाहिए।

अक्सर डेटाबेस में ईमेल पते संग्रहीत करते समय मैं उन्हें लोअरकेस बना देता हूं और, व्यावहारिक रूप से, रेगेक्स आमतौर पर केस असंवेदनशील चिह्नित किया जा सकता है। उन मामलों में यह थोड़ा छोटा है:

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

जावास्क्रिप्ट में इसका उपयोग करने का एक उदाहरण यहां दिया गया है (अंत में मामले असंवेदनशील ध्वज के साथ)।

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('[email protected]') );

नोट :
तकनीकी रूप से कुछ ईमेल उद्धरण के अंदर भागने वाले पात्रों के साथ @ प्रतीक से पहले अनुभाग में उद्धरण शामिल कर सकते हैं (इसलिए आपका ईमेल उपयोगकर्ता अप्रिय हो सकता है और इसमें "..." और "..." जैसे सामान शामिल हैं, जब तक यह उद्धरण में लिखा गया हो)। कोई भी यह कभी नहीं करता है! यह अप्रचलित है। लेकिन, यह वास्तविक आरएफसी 2822 मानक में शामिल है, और यहां छोड़ा गया है।

अधिक जानकारी: http://www.regular-expressions.info/email.html


एक ईमेल सत्यापनकर्ता 100% सही प्राप्त करना मुश्किल है। इसे सही करने का एकमात्र असली तरीका खाते में एक परीक्षण ईमेल भेजना होगा। उस ने कहा, कुछ बुनियादी जांच हैं जो यह सुनिश्चित करने में मदद कर सकती हैं कि आपको कुछ उचित मिल रहा है।

कुछ चीजों को सुधारने के लिए:

नए के बजाय RegExp, बस regexpइस तरह लिखने का प्रयास करें:

if (reg.test(/@/))

दूसरा, यह सुनिश्चित करने के लिए जांचें कि एक अवधि @साइन के बाद आता है , और सुनिश्चित करें कि @एस और अवधि के बीच वर्ण हैं ।


यह सही आरएफसी 822 संस्करण है।

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

एचटीएमएल 5 में ईमेल सत्यापन है। यदि आपका ब्राउज़र HTML5 का समर्थन करता है तो आप निम्न कोड का उपयोग कर सकते हैं।

<form><input type="email" placeholder="[email protected]">
    <input type="submit">
</form>

jsFiddle लिंक

एचटीएमएल 5 spec से :

एक वैध ई-मेल पता एक स्ट्रिंग है जो निम्नलिखित एबीएनएफ के email उत्पादन से मेल खाता है, जिसके लिए चरित्र सेट यूनिकोड है।

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 >

यह आवश्यकता आरएफसी 5322 का एक जानबूझकर उल्लंघन है, जो ई-मेल पते के लिए एक वाक्यविन्यास परिभाषित करता है जो एक साथ बहुत सख्त है ("@" चरित्र से पहले), बहुत अस्पष्ट ("@" चरित्र के बाद), और बहुत ढीला (टिप्पणियां , व्हाईटस्पेस वर्ण, और अधिकांश उपयोगकर्ताओं के लिए अपरिचित शिष्टाचार में उद्धृत तार) यहां व्यावहारिक उपयोग के लिए।

निम्नलिखित जावास्क्रिप्ट- और पर्ल-संगत नियमित अभिव्यक्ति उपरोक्त परिभाषा का कार्यान्वयन है।

/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-][email protected][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])?)*$/

एएसपी.नेट एमवीसी के भीतर माइक्रोसॉफ्ट द्वारा प्रदान की गई नियमित अभिव्यक्ति है

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

जो मैं यहां त्रुटिपूर्ण होने पर यहां पोस्ट करता हूं - हालांकि यह हमेशा मेरी ज़रूरतों के लिए बिल्कुल सही रहा है।


जाहिर है, यह है:

/^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~][email protected]((((([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

1 अक्टूबर को http://fightingforalostcause.net/misc/2006/compare-email-regex.php से लिया गया ।

लेकिन, ज़ाहिर है, यह अंतरराष्ट्रीयकरण को अनदेखा कर रहा है।


मैं वास्तव में इस समस्या को हल करने की उम्मीद कर रहा हूं। तो मैंने ऊपर ईमेल सत्यापन नियमित अभिव्यक्ति संशोधित की

विकिपीडिया ईमेल पते में उदाहरणों को पारित करने के लिए।

और आप here परिणाम देख सकते हैं।


मैंने यह सबसे अच्छा समाधान पाया है:

/^[^\[email protected]][email protected][^\[email protected]]+\.[^\[email protected]]+$/

यह निम्नलिखित प्रारूपों की अनुमति देता है:

1.  [email protected]
2.  [email protected]
3.  [email protected]
4.  [email protected]
9.  #!$%&'*+-/=?^_`{}|[email protected]
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)

यह स्पष्ट रूप से बहुमुखी है और सभी महत्वपूर्ण अंतरराष्ट्रीय पात्रों को अनुमति देता है, जबकि अभी भी बुनियादी कुछ भी लागू कर रहा है। कुछ भी प्रारूप। यह रिक्त स्थान को अवरुद्ध करेगा जो तकनीकी रूप से आरएफसी द्वारा अनुमत हैं, लेकिन वे इतने दुर्लभ हैं कि मुझे ऐसा करने में खुशी है।


आरएफसी के अनुपालन में ईमेल पते का सही सत्यापन कुछ ऐसा नहीं है जिसे एक लाइनर नियमित अभिव्यक्ति के साथ हासिल किया जा सके। PHP में पाया गया सबसे अच्छा समाधान वाला आलेख एक मान्य ईमेल पता क्या है? । जाहिर है, यह जावा को पोर्ट किया गया है। मुझे लगता है कि फ़ंक्शन को पोर्ट करने और जावास्क्रिप्ट में उपयोग करने के लिए बहुत जटिल है। जावास्क्रिप्ट / node.js पोर्ट: https://www.npmjs.com/package/email-addresses

एक अच्छा अभ्यास क्लाइंट पर अपने डेटा को प्रमाणित करना है, लेकिन सर्वर पर सत्यापन को दोबारा जांचें। इसे ध्यान में रखते हुए, आप आसानी से जांच सकते हैं कि कोई स्ट्रिंग क्लाइंट पर मान्य ईमेल पता की तरह दिखती है और सर्वर पर सख्त जांच करती है।

यहां एक जावास्क्रिप्ट फ़ंक्शन है जिसका उपयोग मैं यह जांचने के लिए करता हूं कि कोई स्ट्रिंग मान्य मेल पता की तरह दिखती है या नहीं:

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

स्पष्टीकरण:

  • lastAtPos < lastDotPos : अंतिम @ अंतिम से पहले होना चाहिए . चूंकि @ सर्वर नाम का हिस्सा नहीं हो सकता है (जहां तक ​​मुझे पता है)।

  • lastAtPos > 0 : अंतिम @ से पहले कुछ (ईमेल उपयोगकर्ता नाम) होना चाहिए।

  • str.indexOf('@@') == -1 : पते में @@ नहीं होना चाहिए। यहां तक ​​कि अगर @ ईमेल उपयोगकर्ता नाम में अंतिम चरित्र के रूप में दिखाई देता है, तो इसे उद्धृत किया जाना चाहिए ताकि " पते में @ और अंतिम @ बीच होगा।

  • lastDotPos > 2 : अंतिम बिंदु से कम से कम तीन वर्ण होने चाहिए, उदाहरण के लिए [email protected]

  • (str.length - lastDotPos) > 2 : दो-वर्ण डोमेन बनाने के लिए अंतिम बिंदु के बाद पर्याप्त वर्ण होने चाहिए। मुझे यकीन नहीं है कि ब्रैकेट आवश्यक हैं या नहीं।


यह http://codesnippets.joyent.com/posts/show/1917 से चोरी हो गया था

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

बस पूर्णता के लिए, यहां आपके पास एक और आरएफसी 2822 अनुपालन रेगेक्स है

आधिकारिक मानक आरएफसी 2822 के रूप में जाना जाता है। यह वाक्यविन्यास का वर्णन करता है कि वैध ईमेल पते का पालन करना चाहिए। आप इस नियमित अभिव्यक्ति के साथ इसे लागू कर सकते हैं ( लेकिन आपको नहीं पढ़ना चाहिए ):

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

(...) अगर हम डबल कोट्स और स्क्वायर ब्रैकेट का उपयोग करके सिंटैक्स को छोड़ देते हैं तो हमें आरएफसी 2822 का अधिक व्यावहारिक कार्यान्वयन मिलता है। आज भी वास्तविक उपयोग में सभी ईमेल पतों का 99.99% मैच होगा।

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

एक और परिवर्तन जो आप कर सकते हैं वह दो-अक्षर देश कोड शीर्ष स्तर डोमेन, और केवल विशिष्ट सामान्य शीर्ष स्तर डोमेन की अनुमति देना है। यह regex [email protected] जैसे डमी ईमेल पते फ़िल्टर [email protected] । आपको इसे अपडेट करने की आवश्यकता होगी क्योंकि नए शीर्ष-स्तरीय डोमेन जोड़े गए हैं

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[AZ]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\b

तो जब भी आधिकारिक मानकों का पालन किया जाता है, तब भी व्यापार-बंद किए जाते हैं। अंधेरे से ऑनलाइन पुस्तकालयों या चर्चा मंचों से नियमित अभिव्यक्तियों की प्रतिलिपि न लें। हमेशा अपने डेटा पर और अपने स्वयं के अनुप्रयोगों के साथ परीक्षण करें।

जोर मेरा


ईमेल को प्रमाणित करने के लिए नियमित अभिव्यक्ति का उपयोग करने का निर्णय लेने वाले दूसरे को समझने के लिए आपको कुछ समझना है: शायद यह एक अच्छा विचार नहीं है । एक बार जब आप इसके साथ बात कर लेंगे, वहां कई कार्यान्वयन हैं जो आपको आधा रास्ते मिल सकते हैं, यह आलेख उन्हें अच्छी तरह से बताता है।

संक्षेप में, हालांकि, बिल्कुल सही होने का एकमात्र तरीका सकारात्मक रूप से सुनिश्चित है कि उपयोगकर्ता द्वारा दर्ज किया गया वास्तव में एक ईमेल वास्तव में एक ईमेल भेजना है और देखें कि क्या होता है। इसके अलावा यह सब सिर्फ अनुमान है।


Regex अद्यतन 2018! इसे इस्तेमाल करे

let val = '[email protected]';
if(/^[a-z0-9][a-z0-9-_\.][email protected]([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');
}

टाइपस्क्रिप्ट संस्करण पूर्ण

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

अधिक जानकारी https://git.io/vhEfc


वाह, यहां बहुत सारी जटिलताएं हैं। यदि आप बस इतना करना चाहते हैं कि सबसे स्पष्ट वाक्यविन्यास त्रुटियों को पकड़ें, तो मैं ऐसा कुछ करूंगा:

\[email protected]\S+

यह आमतौर पर सबसे स्पष्ट त्रुटियों को पकड़ता है जो उपयोगकर्ता बनाता है और आश्वासन देता है कि फ़ॉर्म अधिकतर सही है, जो जावास्क्रिप्ट सत्यापन के बारे में है।


बस दर्ज करें कि दर्ज ईमेल पता मान्य है या HTML का उपयोग नहीं कर रहा है या नहीं।

<input type="email"/>

सत्यापन के लिए एक समारोह लिखने की कोई जरूरत नहीं है।


एक समाधान जो टीएलडी के अस्तित्व की जांच नहीं करता है अधूरा है।

इस प्रश्न के लगभग सभी उत्तरों ईमेल पते को सत्यापित करने के लिए रेगेक्स का उपयोग करने का सुझाव देते हैं। मुझे लगता है कि रेगेक्स एक प्राथमिक सत्यापन के लिए केवल अच्छा है। ऐसा लगता है कि ईमेल पते की जांच सत्यापन वास्तव में दो अलग-अलग समस्याएं हैं:

1- ईमेल प्रारूप का सत्यापन: यह सुनिश्चित करना कि ईमेल आरएफसी 5322 में ईमेल के स्वरूप और पैटर्न का अनुपालन करता है और यदि टीएलडी वास्तव में मौजूद है। सभी वैध टीएलडी की एक सूची here पाई जा सकती here

उदाहरण के लिए, हालांकि पता [email protected]रेगेक्स पास करेगा, यह वैध ईमेल cccनहीं है , क्योंकि आईएएनए द्वारा शीर्ष-स्तरीय डोमेन नहीं है।

2- यह सुनिश्चित करना कि ईमेल वास्तव में मौजूद है: ऐसा करने के लिए, उपयोगकर्ताओं को एक ईमेल भेजने का एकमात्र विकल्प है ।


इस प्रकार node-validator यह करता है:

/^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~][email protected](?:(?:(?:[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])\]))$/

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

नियमित अभिव्यक्तियों का उपयोग करना शायद सबसे अच्छा तरीका है। आप here परीक्षणों here एक गुच्छा देख सकते हैं ( chromium से लिया गया)

function validateEmail(email) {
    var re = /^(([^<>()\[\]\\.,;:\[email protected]"]+(\.[^<>()\[\]\\.,;:\[email protected]"]+)*)|(".+"))@((\[[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());
}

यहां नियमित विस्तार का उदाहरण दिया गया है जो यूनिकोड स्वीकार करता है:

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

लेकिन ध्यान रखें कि किसी को केवल जावास्क्रिप्ट सत्यापन पर भरोसा नहीं करना चाहिए। जावास्क्रिप्ट आसानी से अक्षम किया जा सकता है। यह सर्वर पक्ष पर भी मान्य होना चाहिए।

उपरोक्त कार्रवाई में एक उदाहरण दिया गया है:

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

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

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

$("#validate").bind("click", validate);
<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>


सर्वश्रेष्ठ रेगेक्स जो आरएफसी 5322 के साथ पुष्टि करता है

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


सभी ईमेल पतों में 'एट' (यानी @) प्रतीक होता है। आवश्यक शर्त का परीक्षण करें:

email.indexOf("@") > 0

कुछ भी जटिल से परेशान मत करो। यहां तक ​​कि यदि आप पूरी तरह से यह निर्धारित कर सकते हैं कि कोई ईमेल आरएफसी-वाक्य रचनात्मक रूप से मान्य है, तो यह आपको नहीं बताएगा कि यह उस व्यक्ति से संबंधित है जो इसे प्रदान करता है। यही वास्तव में मायने रखता है।

इसका परीक्षण करने के लिए, एक सत्यापन संदेश भेजें।


विकिपीडिया मानक मेल वाक्यविन्यास:

https://en.wikipedia.org/wiki/Email_address#Examples https://fr.wikipedia.org/wiki/Adresse_%C3%A9lectronique#Syntaxe_exacte

function validMail(mail)
{
    return /^(([^<>()\[\]\.,;:\[email protected]\"]+(\.[^<>()\[\]\.,;:\[email protected]\"]+)*)|(\".+\"))@(([^<>()\.,;\[email protected]\"]+\.{0,1})+([^<>()\.,;:\[email protected]\"]{2,}|[\d\.]+))$/.test(mail);
}

// VALID MAILS

validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('user+mailbox/[email protected]') // Return true
validMail('"very.(),:;<>[]\".VERY.\"[email protected]\\ \"very\".unusual"@strange.example.com') // Return true
validMail('!#$%&\'*+-/=?^_`.{|}[email protected]') // Return true
validMail('"()<>[]:,;@\\\"!#$%&\'-/=?^_`{}| ~.a"@example.org') // Return true
validMail('"[email protected]"@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('[email protected][IPv6:2001:DB8::1]') // Return true

// INVALID MAILS

validMail('Abc.example.com') // Return false
validMail('[email protected]@[email protected]') // Return false
validMail('a"b(c)d,e:f;g<h>i[j\k][email protected]') // Return false
validMail('just"not"[email protected]') // Return false
validMail('this is"not\[email protected]') // Return false
validMail('this\ still\"not\\[email protected]') // Return false
validMail('[email protected]') // Return false
validMail('[email protected]') // Return false

यह परीक्षण दिखाएं: https://regex101.com/r/LHJ9gU/1


जावास्क्रिप्ट एक नियमित अभिव्यक्ति से मेल खा सकता है:

emailAddress.match( / some_regex /);

ईमेल के लिए RFC22 नियमित अभिव्यक्ति यहां दी गई है:

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

ईमेल पते मान्य करने के लिए नियमित अभिव्यक्तियों का उपयोग करने के बारे में यहां एक बहुत अच्छी चर्चा है; " http://fightingforalostcause.net/misc/2006/compare-email-regex.php "

संदर्भ शीर्ष उद्देश्यों के लिए वर्तमान शीर्ष अभिव्यक्ति यहां है, जो जावास्क्रिप्ट संगत है:

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






email-validation