regex - नियमित अभिव्यक्ति का उपयोग करके ईमेल पते को कैसे सत्यापित करें?

validation email (20)

सालों से मैंने धीरे-धीरे एक नियमित अभिव्यक्ति विकसित की है जो कि अधिकांश ईमेल पते को सही ढंग से मान्य करता है, मानते हैं कि वे सर्वर भाग के रूप में आईपी पते का उपयोग नहीं करते हैं।

मैं इसे कई PHP प्रोग्रामों में उपयोग करता हूं, और यह ज्यादातर समय काम करता है। हालांकि, समय-समय पर मुझे किसी ऐसे व्यक्ति से संपर्क मिलता है जो उस साइट के साथ परेशानी कर रहा है जो इसका उपयोग करता है, और मुझे कुछ समायोजन करना पड़ता है (हाल ही में मुझे एहसास हुआ कि मैं 4-वर्ण टीएलडी की अनुमति नहीं दे रहा था)।

ईमेल की पुष्टि के लिए आपके पास सबसे अच्छी नियमित अभिव्यक्ति क्या है या आपने देखा है?

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

शीघ्र जवाब

इनपुट सत्यापन के लिए निम्न रेगेक्स का उपयोग करें:

CHAR        =  <any ASCII character>
            =~ .

CTL         =  <any ASCII control character and DEL>
            =~ [\x00-\x1F\x7F]

CR          =  <ASCII CR, carriage return>
            =~ \r

LF          =  <ASCII LF, linefeed>
            =~ \n

SPACE       =  <ASCII SP, space>
            =~  

HTAB        =  <ASCII HT, horizontal-tab>
            =~ \t

<">         =  <ASCII quote mark>
            =~ "

CRLF        =  CR LF
            =~ \r\n

LWSP-char   =  SPACE / HTAB
            =~ [ \t]

linear-white-space =  1*([CRLF] LWSP-char)
                   =~ ((\r\n)?[ \t])+

specials    =  "(" / ")" / "<" / ">" / "@" /  "," / ";" / ":" / "\" / <"> /  "." / "[" / "]"
            =~ [][()<>@,;:\\".]

quoted-pair =  "\" CHAR
            =~ \\.

qtext       =  <any CHAR excepting <">, "\" & CR, and including linear-white-space>
            =~ [^"\\\r]|((\r\n)?[ \t])+

dtext       =  <any CHAR excluding "[", "]", "\" & CR, & including linear-white-space>
            =~ [^][\\\r]|((\r\n)?[ \t])+

quoted-string  =  <"> *(qtext|quoted-pair) <">
               =~ "([^"\\\r]|((\r\n)?[ \t])|\\.)*"
(erratum)      =~ "(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"

domain-literal =  "[" *(dtext|quoted-pair) "]"
               =~ \[([^][\\\r]|((\r\n)?[ \t])|\\.)*]
(erratum)      =~ \[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]

atom        =  1*<any CHAR except specials, SPACE and CTLs>
            =~ [^][()<>@,;:\\". \x00-\x1F\x7F]+

word        =  atom / quoted-string
            =~ [^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"

domain-ref  =  atom

sub-domain  =  domain-ref / domain-literal
            =~ [^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]

local-part  =  word *("." word)
            =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"))*
(opt-lwsp)  =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")(((\r\n)?[ \t])*\.((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"))*

domain      =  sub-domain *("." sub-domain)
            =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*])(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]))*
(opt-lwsp)  =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*])(((\r\n)?[ \t])*\.((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]))*

addr-spec   =  local-part "@" domain
            =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"))*@([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*])(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]))*
(opt-lwsp)  =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")((\r\n)?[ \t])*(\.((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")((\r\n)?[ \t])*)*@((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*])(((\r\n)?[ \t])*\.((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]))*
(canonical) =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]))*(\\\r)*")(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]))*(\\\r)*"))*@([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]))*(\\\r)*])(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]))*(\\\r)*]))*

इस रेगेक्स द्वारा मिलान किए गए पते:

एक स्थानीय हिस्सा (यानी @ -sign से पहले भाग) जो आरएफसी 5321/5322 के साथ सख्ती से अनुपालन करता है,
एक डोमेन भाग (यानी @ -sign के बाद का हिस्सा) है जो कम से कम दो लेबल वाले मेजबान नाम है, जिनमें से प्रत्येक 63 वर्ण लंबा है।

दूसरी बाधा आरएफसी 5321/5322 पर एक प्रतिबंध है।

विस्तृत उत्तर

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

हालांकि यह ध्यान दिया जाना चाहिए कि यदि आप यह जानना चाहते हैं कि पता वास्तव में किसी मौजूदा मेलबॉक्स को संदर्भित करता है, तो पते पर संदेश भेजने के लिए कोई विकल्प नहीं है। यदि आप केवल यह जांचना चाहते हैं कि कोई पता व्याकरणिक रूप से सही है या नहीं, तो आप नियमित अभिव्यक्ति का उपयोग कर सकते हैं, लेकिन ध्यान दें कि ""@[]एक व्याकरणिक रूप से सही ईमेल पता है जो निश्चित रूप से किसी मौजूदा मेलबॉक्स का संदर्भ नहीं देता है।

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

इस जवाब में मैं addr-specआरएफसी (यानी [email protected], लेकिन नहीं "John Doe"<[email protected]>, न ही some-group:[email protected],[email protected];) में परिभाषित के रूप में "ईमेल पता" लेगा ।

आरएफसी वाक्यविन्यास को रेगेक्स में अनुवाद करने में एक समस्या है: वाक्यविन्यास नियमित नहीं हैं! ऐसा इसलिए है क्योंकि वे ईमेल पतों में वैकल्पिक टिप्पणियों की अनुमति देते हैं जिन्हें असीमित रूप से घोंसला किया जा सकता है, जबकि अनंत घोंसले को नियमित अभिव्यक्ति द्वारा वर्णित नहीं किया जा सकता है। टिप्पणियों वाले पते को स्कैन या मान्य करने के लिए आपको एक पार्सर या अधिक शक्तिशाली अभिव्यक्तियों की आवश्यकता होती है। (ध्यान दें कि पर्ल जैसी भाषाओं में संदर्भ मुक्त व्याकरण को रेगेक्स-जैसी तरीके से वर्णित करने के लिए तैयार किया गया है।) इस उत्तर में मैं टिप्पणियों की उपेक्षा करूंगा और केवल उचित नियमित अभिव्यक्तियों पर विचार करूंगा।

आरएफसी ईमेल संदेशों के लिए सिंटैक्स परिभाषित करता है, ईमेल पते के लिए नहीं। पते विभिन्न हेडर फ़ील्ड में दिखाई दे सकते हैं और यह वह जगह है जहां उन्हें मुख्य रूप से परिभाषित किया जाता है। जब वे हेडर फ़ील्ड में दिखाई देते हैं तो पते में (लेक्सिकल टोकन के बीच) व्हाइटस्पेस, टिप्पणियां और यहां तक कि लाइनब्रैक भी हो सकते हैं। हालांकि, इसका कोई महत्व नहीं है। किसी पते से इस व्हाइटस्पेस इत्यादि को हटाकर आप एक अर्थात् समकक्ष कैननिकल प्रतिनिधित्व प्राप्त करते हैं । इस प्रकार, का वैधानिक प्रतिनिधित्व first. last (comment) @ [3.5.7.9]है [email protected][3.5.7.9]।

अलग-अलग उद्देश्यों के लिए विभिन्न वाक्यविन्यासों का उपयोग किया जाना चाहिए। यदि आप एक (संभावित रूप से बहुत पुराने) दस्तावेज़ में ईमेल पते के लिए स्कैन करना चाहते हैं तो आरएफसी 822 में परिभाषित वाक्यविन्यास का उपयोग करना एक अच्छा विचार हो सकता है। दूसरी ओर, यदि आप उपयोगकर्ता इनपुट को सत्यापित करना चाहते हैं तो आप इसका उपयोग करना चाहेंगे आरएफसी 5322 में परिभाषित वाक्यविन्यास, शायद केवल कैननिकल प्रस्तुतियों को स्वीकार कर रहा है। आपको तय करना चाहिए कि कौन सा सिंटैक्स आपके विशिष्ट मामले पर लागू होता है।

मैं एक ASCII संगत चरित्र सेट मानते हुए, इस जवाब में POSIX "विस्तारित" नियमित अभिव्यक्तियों का उपयोग करता हूं।

आरएफसी 822

मैं निम्नलिखित नियमित अभिव्यक्ति पर पहुंचा। मैं हर किसी को कोशिश करने और इसे तोड़ने के लिए आमंत्रित करता हूं। यदि आपको कोई झूठी सकारात्मक या झूठी नकारात्मकता मिलती है, तो कृपया उन्हें एक टिप्पणी में पोस्ट करें और मैं जितनी जल्दी हो सके अभिव्यक्ति को ठीक करने का प्रयास करूंगा।

VCHAR           =   %x21-7E
                =~  [!-~]

ALPHA           =   %x41-5A / %x61-7A
                =~  [A-Za-z]

DIGIT           =   %x30-39
                =~  [0-9]

HTAB            =   %x09
                =~  \t

CR              =   %x0D
                =~  \r

LF              =   %x0A
                =~  \n

SP              =   %x20
                =~  

DQUOTE          =   %x22
                =~  "

CRLF            =   CR LF
                =~  \r\n

WSP             =   SP / HTAB
                =~  [\t ]

quoted-pair     =   "\" (VCHAR / WSP)
                =~  \\[\t -~]

FWS             =   ([*WSP CRLF] 1*WSP)
                =~  ([\t ]*\r\n)?[\t ]+

ctext           =   %d33-39 / %d42-91 / %d93-126
                =~  []!-'*-[^-~]

("comment" is left out in the regex)
ccontent        =   ctext / quoted-pair / comment
                =~  []!-'*-[^-~]|(\\[\t -~])

(not regular)
comment         =   "(" *([FWS] ccontent) [FWS] ")"

(is equivalent to FWS when leaving out comments)
CFWS            =   (1*([FWS] comment) [FWS]) / FWS
                =~  ([\t ]*\r\n)?[\t ]+

atext           =   ALPHA / DIGIT / "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "/" / "=" / "?" / "^" / "_" / "`" / "{" / "|" / "}" / "~"
                =~  [-!#-'*+/-9=?A-Z^-~]

dot-atom-text   =   1*atext *("." 1*atext)
                =~  [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*

dot-atom        =   [CFWS] dot-atom-text [CFWS]
                =~  (([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*

qtext           =   %d33 / %d35-91 / %d93-126
                =~  []!#-[^-~]

qcontent        =   qtext / quoted-pair
                =~  []!#-[^-~]|(\\[\t -~])

(erratum)
quoted-string   =   [CFWS] DQUOTE ((1*([FWS] qcontent) [FWS]) / FWS) DQUOTE [CFWS]
                =~  (([\t ]*\r\n)?[\t ]+)?"(((([\t ]*\r\n)?[\t ]+)?([]!#-[^-~]|(\\[\t -~])))+(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?)"(([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  "([]!#-[^-~ \t]|(\\[\t -~]))+"

dtext           =   %d33-90 / %d94-126
                =~  [!-Z^-~]

domain-literal  =   [CFWS] "[" *([FWS] dtext) [FWS] "]" [CFWS]
                =~  (([\t ]*\r\n)?[\t ]+)?\[((([\t ]*\r\n)?[\t ]+)?[!-Z^-~])*(([\t ]*\r\n)?[\t ]+)?](([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  \[[\t -Z^-~]*]

local-part      =   dot-atom / quoted-string
                =~  (([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?"(((([\t ]*\r\n)?[\t ]+)?([]!#-[^-~]|(\\[\t -~])))+(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?)"(([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+"

domain          =   dot-atom / domain-literal
                =~  (([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?\[((([\t ]*\r\n)?[\t ]+)?[!-Z^-~])*(([\t ]*\r\n)?[\t ]+)?](([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|\[[\t -Z^-~]*]

addr-spec       =   local-part "@" domain
                =~  ((([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?"(((([\t ]*\r\n)?[\t ]+)?([]!#-[^-~]|(\\[\t -~])))+(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?)"(([\t ]*\r\n)?[\t ]+)?)@((([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?\[((([\t ]*\r\n)?[\t ]+)?[!-Z^-~])*(([\t ]*\r\n)?[\t ]+)?](([\t ]*\r\n)?[\t ]+)?)
(normalized)    =~  ([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|\[[\t -Z^-~]*])

मेरा मानना है कि यह आरएफसी 822 के साथ errata सहित पूरी तरह से अनुकूल है । यह केवल उनके कैनोनिकल रूप में ईमेल पते को पहचानता है। एक रेगेक्स जो पहचानता है (फोल्डिंग) व्हाइटस्पेस नीचे व्युत्पन्न देखता है।

व्युत्पन्न दिखाता है कि मैं अभिव्यक्ति पर कैसे पहुंचे। मैं आरएफसी से सभी प्रासंगिक व्याकरण नियमों को ठीक वैसे ही सूचीबद्ध करता हूं, इसके बाद वे संबंधित रेगेक्स के बाद होते हैं। जहां एक इरेटाम प्रकाशित किया गया है, मैं सही व्याकरण नियम (चिह्नित "इरेटाम") के लिए एक अलग अभिव्यक्ति देता हूं और बाद के नियमित अभिव्यक्तियों में अद्यतन संस्करण को उप-अभिव्यक्ति के रूप में उपयोग करता हूं।

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

Let-dig         =   ALPHA / DIGIT
                =~  [0-9A-Za-z]

Ldh-str         =   *( ALPHA / DIGIT / "-" ) Let-dig
                =~  [0-9A-Za-z-]*[0-9A-Za-z]

(regex is updated to make sure sub-domains are max. 63 charactes long - RFC 1034 section 3.5)
sub-domain      =   Let-dig [Ldh-str]
                =~  [0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?

Domain          =   sub-domain *("." sub-domain)
                =~  [0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)*

Snum            =   1*3DIGIT
                =~  [0-9]{1,3}

(suggested replacement for "Snum")
ip4-octet       =   DIGIT / %x31-39 DIGIT / "1" 2DIGIT / "2" %x30-34 DIGIT / "25" %x30-35
                =~  25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9]

IPv4-address-literal    =   Snum 3("."  Snum)
                        =~  [0-9]{1,3}(\.[0-9]{1,3}){3}

(suggested replacement for "IPv4-address-literal")
ip4-address     =   ip4-octet 3("." ip4-octet)
                =~  (25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}

(suggested replacement for "IPv6-hex")
ip6-h16         =   "0" / ( (%x49-57 / %x65-70 /%x97-102) 0*3(%x48-57 / %x65-70 /%x97-102) )
                =~  0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}

(not from RFC)
ls32            =   ip6-h16 ":" ip6-h16 / ip4-address
                =~  (0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}

(suggested replacement of "IPv6-addr")
ip6-address     =                                      6(ip6-h16 ":") ls32
                    /                             "::" 5(ip6-h16 ":") ls32
                    / [                 ip6-h16 ] "::" 4(ip6-h16 ":") ls32
                    / [ *1(ip6-h16 ":") ip6-h16 ] "::" 3(ip6-h16 ":") ls32
                    / [ *2(ip6-h16 ":") ip6-h16 ] "::" 2(ip6-h16 ":") ls32
                    / [ *3(ip6-h16 ":") ip6-h16 ] "::"   ip6-h16 ":"  ls32
                    / [ *4(ip6-h16 ":") ip6-h16 ] "::"                ls32
                    / [ *5(ip6-h16 ":") ip6-h16 ] "::"   ip6-h16
                    / [ *6(ip6-h16 ":") ip6-h16 ] "::"
                =~  (((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::

IPv6-address-literal    =   "IPv6:" ip6-address
                        =~  IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)

Standardized-tag        =   Ldh-str
                        =~  [0-9A-Za-z-]*[0-9A-Za-z]

dcontent        =   %d33-90 / %d94-126
                =~  [!-Z^-~]

General-address-literal =   Standardized-tag ":" 1*dcontent
                        =~  [0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+

address-literal =   "[" ( IPv4-address-literal / IPv6-address-literal / General-address-literal ) "]"
                =~  \[((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)|(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+)]

Mailbox         =   Local-part "@" ( Domain / address-literal )
                =~  ([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)*|\[((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)|(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+)])

आरएफसी 5322

$RFC822PAT = <<'EOF';
[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\
xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xf
f\n\015()]*)*\)[\040\t]*)*(?:(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\x
ff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015
"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\
xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80
-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*
)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\
\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\
x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x8
0-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n
\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x
80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^
\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040
\t]*)*)*@[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([
^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\
\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\
x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-
\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()
]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\
x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\04
0\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\
n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\
015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?!
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\
]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\
x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\01
5()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*|(?:[^(\040)<>@,;:".
\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]
)|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[^
()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037]*(?:(?:\([^\\\x80-\xff\n\0
15()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][
^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)|"[^\\\x80-\xff\
n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[^()<>@,;:".\\\[\]\
x80-\xff\000-\010\012-\037]*)*<[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?
:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-
\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:@[\040\t]*
(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015
()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()
]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\0
40)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\
[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\
xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*
)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80
-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x
80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t
]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\
\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])
*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x
80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80
-\xff\n\015()]*)*\)[\040\t]*)*)*(?:,[\040\t]*(?:\([^\\\x80-\xff\n\015(
)]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\
\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*@[\040\t
]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\0
15()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015
()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(
\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|
\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80
-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()
]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x
80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^
\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040
\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".
\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff
])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\
\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x
80-\xff\n\015()]*)*\)[\040\t]*)*)*)*:[\040\t]*(?:\([^\\\x80-\xff\n\015
()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\
\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)?(?:[^
(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-
\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\
n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|
\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))
[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff
\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\x
ff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(
?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\
000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\
xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\x
ff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)
*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*@[\040\t]*(?:\([^\\\x80-\x
ff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-
\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)
*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\
]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\]
)[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-
\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\x
ff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(
?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80
-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<
>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x8
0-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:
\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]
*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)
*\)[\040\t]*)*)*>)
EOF

मुझे विश्वास है कि यह आरएफसी 5322 के साथ errata सहित पूरी तरह से अनुकूल है । यह केवल उनके कैनोनिकल रूप में ईमेल पते को पहचानता है। एक रेगेक्स जो पहचानता है (फोल्डिंग) व्हाइटस्पेस नीचे व्युत्पन्न देखता है।

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

मैंने आरएफसी से सभी "obs-" नियमों को नजरअंदाज कर दिया। इसका मतलब है कि रेगेक्स केवल उन ईमेल पतों से मेल खाते हैं जो सख्ती से आरएफसी 5322 अनुपालनशील हैं। यदि आपको "पुराने" पते से मिलान करना है (जैसा कि "obs-" नियमों सहित लूसर व्याकरण के रूप में है, तो आप पिछले पैराग्राफ से आरएफसी 822 रेगेक्स में से एक का उपयोग कर सकते हैं।

filter_var($value, FILTER_VALIDATE_EMAIL)

ध्यान दें कि कुछ स्रोत (विशेष रूप से डब्ल्यू 3 सी ) का दावा है कि आरएफसी 5322 स्थानीय हिस्से पर बहुत सख्त है (यानी @ -ignign से पहले हिस्सा)। ऐसा इसलिए है क्योंकि "..", "ए..बी" और "ए।" हैं न वैध डॉट परमाणुओं, जबकि वे मेलबॉक्स नाम के रूप में इस्तेमाल किया जा सकता है। आरएफसी, तथापि, करता है इस तरह के स्थानीय भागों के लिए अनुमति देते हैं, को छोड़कर उद्धृत किया जाना है कि वे। तो आपके बजाय [email protected]लिखना चाहिए "a..b"@example.net, जो अर्थात् समकक्ष है।

और प्रतिबंध

एसएमटीपी (जैसा कि आरएफसी 5321 में परिभाषित किया गया है ) वैध ईमेल पते (या वास्तव में: मेलबॉक्स नाम) के सेट को प्रतिबंधित करता है। यह कठोर व्याकरण लगाने के लिए उचित लगता है, ताकि मिलान किए गए ईमेल पते का उपयोग वास्तव में एक ईमेल भेजने के लिए किया जा सके।

आरएफसी 5321 मूल रूप से अकेले "स्थानीय" भाग (यानी @ -sign से पहले भाग) छोड़ देता है, लेकिन डोमेन भाग (यानी @ -sign के बाद भाग) पर कठोर है। यह डोमेन अक्षरों के स्थान पर केवल डॉट-परमाणुओं और पता अक्षर के स्थान पर मेजबान नामों की अनुमति देता है।

आरएफसी 5321 में प्रस्तुत व्याकरण बहुत ही कमजोर है जब मेजबान नाम और आईपी पते दोनों की बात आती है। मैंने इस मसौदे और आरएफसी 1034 दिशानिर्देशों के रूप में , प्रश्नों के नियमों को "सही करने" की स्वतंत्रता ली । परिणामी regex यहाँ है।

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

ध्यान दें कि उपयोग के मामले के आधार पर आप अपने रेगेक्स में "सामान्य-पता-शाब्दिक" की अनुमति नहीं दे सकते हैं। यह भी ध्यान रखें कि मैंने (?!IPv6:)"सामान्य-पता-शाब्दिक" भाग को विकृत आईपीवी 6 पते से मेल खाने के लिए अंतिम रेगेक्स में नकारात्मक दिखने का उपयोग किया था। कुछ रेगेक्स प्रोसेसर नकारात्मक लुकहेड का समर्थन नहीं करते हैं। |(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+अगर आप पूरे "सामान्य-पता-शाब्दिक" भाग को लेना चाहते हैं तो रेगेक्स से सबस्ट्रिंग को हटा दें ।

यहां व्युत्पन्न है:

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

उपयोगकर्ता इनपुट सत्यापन

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

([-!#-'*+/-9=?AZ^-~]+(\.[-!#-'*+/-9=?AZ^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)+

मैं स्थानीय भाग को और प्रतिबंधित करने की अनुशंसा नहीं करता, उदाहरण के लिए उद्धृत तारों को रोककर, क्योंकि हम नहीं जानते कि किस प्रकार के मेलबॉक्स नाम कुछ होस्ट (जैसे "a..b"@example.netया यहां तक कि "ab"@example.net) अनुमति देते हैं ।

मैं भी शाब्दिक शीर्ष-स्तरीय डोमेन की सूची के खिलाफ स्पष्ट रूप से मान्य करने की सिफारिश नहीं करता हूं या यहां तक कि लंबाई-बाधाओं को भी लागू करता हूं (याद रखें कि "। संग्रहालय" कैसे अमान्य है [az]{2,4}), लेकिन यदि आपको यह करना होगा:

([-!#-'*+/-9=?AZ^-~]+(\.[-!#-'*+/-9=?AZ^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?\.)*(net|org|com|info| आदि... )

यदि आप स्पष्ट शीर्ष-स्तरीय डोमेन सत्यापन के पथ को नीचे जाने का निर्णय लेते हैं तो अपने रेगेक्स को अद्यतित रखना सुनिश्चित करें।

आगे विचार

जब डोमेन भाग में केवल होस्ट नाम स्वीकार करते हैं (@ -sign के बाद), उपरोक्त regexes केवल 63 वर्णों के साथ लेबल स्वीकार करते हैं, जैसा कि उन्हें करना चाहिए। हालांकि, वे इस तथ्य को लागू नहीं करते हैं कि संपूर्ण होस्ट नाम अधिकतम 253 अक्षरों (बिंदुओं सहित) होना चाहिए। यद्यपि यह बाधा सख्ती से नियमित रूप से बोल रही है, फिर भी इस नियम को शामिल करने वाले रेगेक्स को बनाने के लिए संभव नहीं है।

एक और विचार, विशेष रूप से इनपुट सत्यापन के लिए regexes का उपयोग करते समय, उपयोगकर्ता को प्रतिक्रिया है। यदि कोई उपयोगकर्ता गलत पता दर्ज करता है, तो सरल "वाक्यगत रूप से गलत पता" से थोड़ा अधिक प्रतिक्रिया देना अच्छा लगेगा। "वेनिला" regexes के साथ यह संभव नहीं है।

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

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

[अद्यतन] मैंने यहां ईमेल पता सत्यापन के बारे में जो कुछ भी पता है, उसे मैंने एकत्रित किया है: http://isemail.info/ , जो अब न केवल मान्य है बल्कि ईमेल पते के साथ समस्याओं का निदान भी करता है। मैं यहां कई टिप्पणियों से सहमत हूं कि सत्यापन केवल उत्तर का हिस्सा है; http://isemail.info/about पर मेरा निबंध http://isemail.info/about ।

is_email () बनी हुई है, जहां तक मुझे पता है, एकमात्र वैधकर्ता जो आपको निश्चित रूप से बताएगा कि दी गई स्ट्रिंग एक वैध ईमेल पता है या नहीं। मैंने http://isemail.info/ पर एक नया संस्करण अपलोड किया है

मैंने कैल हैंडर्सन, डेव चाइल्ड, फिल हैक, डौग लोवेल, आरएफसी 5322 और आरएफसी 36 9 6 से टेस्ट केस एकत्र किए। 275 टेस्ट पते सभी में। मैंने इन सभी परीक्षणों को उन सभी मुफ्त सत्यापनकर्ताओं के खिलाफ चलाया जो मुझे मिल सके।

मैं इस पृष्ठ को अद्यतित रखने की कोशिश करूंगा क्योंकि लोग अपने वैधकर्ताओं को बढ़ाते हैं। कैल, माइकल, डेव, पॉल और फिल के लिए धन्यवाद और इन परीक्षणों और मेरे अपने वैधकर्ता की रचनात्मक आलोचना को संकलित करने में सहयोग और सहयोग के लिए धन्यवाद।

लोगों को विशेष रूप से आरएफसी 36 9 6 के खिलाफ इरेटा से अवगत होना चाहिए। तीन कैनोलिक उदाहरण वास्तव में अमान्य पते हैं। और पते की अधिकतम लंबाई 254 या 256 वर्ण है, 320 नहीं ।

इस सवाल से बहुत कुछ पूछा जाता है, लेकिन मुझे लगता है कि आपको वापस कदम उठाना चाहिए और खुद से पूछना चाहिए कि आप ईमेल एड्रेस को सिंटैक्टिक रूप से क्यों सत्यापित करना चाहते हैं? वास्तव में लाभ क्या है?

यह सामान्य टाइपो नहीं पकड़ेगा।
यह लोगों को अमान्य या मेड-अप ईमेल पते दर्ज करने या किसी और के पते में प्रवेश करने से नहीं रोकता है।

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

पर्ल 5.10 या नए में यह आसान है:

/(?(DEFINE)
   (?<address>         (?&mailbox) | (?&group))
   (?<mailbox>         (?&name_addr) | (?&addr_spec))
   (?<name_addr>       (?&display_name)? (?&angle_addr))
   (?<angle_addr>      (?&CFWS)? < (?&addr_spec) > (?&CFWS)?)
   (?<group>           (?&display_name) : (?:(?&mailbox_list) | (?&CFWS))? ;
                                          (?&CFWS)?)
   (?<display_name>    (?&phrase))
   (?<mailbox_list>    (?&mailbox) (?: , (?&mailbox))*)

   (?<addr_spec>       (?&local_part) \@ (?&domain))
   (?<local_part>      (?&dot_atom) | (?&quoted_string))
   (?<domain>          (?&dot_atom) | (?&domain_literal))
   (?<domain_literal>  (?&CFWS)? \[ (?: (?&FWS)? (?&dcontent))* (?&FWS)?
                                 \] (?&CFWS)?)
   (?<dcontent>        (?&dtext) | (?&quoted_pair))
   (?<dtext>           (?&NO_WS_CTL) | [\x21-\x5a\x5e-\x7e])

   (?<atext>           (?&ALPHA) | (?&DIGIT) | [!#\$%&'*+-/=?^_`{|}~])
   (?<atom>            (?&CFWS)? (?&atext)+ (?&CFWS)?)
   (?<dot_atom>        (?&CFWS)? (?&dot_atom_text) (?&CFWS)?)
   (?<dot_atom_text>   (?&atext)+ (?: \. (?&atext)+)*)

   (?<text>            [\x01-\x09\x0b\x0c\x0e-\x7f])
   (?<quoted_pair>     \\ (?&text))

   (?<qtext>           (?&NO_WS_CTL) | [\x21\x23-\x5b\x5d-\x7e])
   (?<qcontent>        (?&qtext) | (?&quoted_pair))
   (?<quoted_string>   (?&CFWS)? (?&DQUOTE) (?:(?&FWS)? (?&qcontent))*
                        (?&FWS)? (?&DQUOTE) (?&CFWS)?)

   (?<word>            (?&atom) | (?&quoted_string))
   (?<phrase>          (?&word)+)

   # Folding white space
   (?<FWS>             (?: (?&WSP)* (?&CRLF))? (?&WSP)+)
   (?<ctext>           (?&NO_WS_CTL) | [\x21-\x27\x2a-\x5b\x5d-\x7e])
   (?<ccontent>        (?&ctext) | (?&quoted_pair) | (?&comment))
   (?<comment>         \( (?: (?&FWS)? (?&ccontent))* (?&FWS)? \) )
   (?<CFWS>            (?: (?&FWS)? (?&comment))*
                       (?: (?:(?&FWS)? (?&comment)) | (?&FWS)))

   # No whitespace control
   (?<NO_WS_CTL>       [\x01-\x08\x0b\x0c\x0e-\x1f\x7f])

   (?<ALPHA>           [A-Za-z])
   (?<DIGIT>           [0-9])
   (?<CRLF>            \x0d \x0a)
   (?<DQUOTE>          ")
   (?<WSP>             [\x20\x09])
 )

 (?&address)/x

यह सब इस बात पर निर्भर करता है कि आप कितना सटीक होना चाहते हैं। मेरे उद्देश्यों के लिए, जहां मैं बस bob @ aol.com (ईमेल में रिक्त स्थान) या steve (बिल्कुल कोई डोमेन नहीं) या [email protected] (.com से पहले नहीं) जैसी चीज़ों को रखने की कोशिश कर रहा हूं, मैं उपयोग करता हूं

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

निश्चित रूप से, यह ऐसी चीजों से मेल खाएगा जो मान्य ईमेल पते नहीं हैं, लेकिन यह 90/10 नियम खेलने का मामला है।

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

एक आरएफसी 5322 अनुपालन रेगेक्स http://emailregex.com/ पर पृष्ठ के शीर्ष पर पाया जा सकता है लेकिन आईपी एड्रेस पैटर्न का उपयोग करता है जो इंटरनेट के चारों ओर एक बग के साथ चल रहा है जो किसी भी हस्ताक्षरित बाइट दशमलव मानों के लिए 00 अनुमति देता है एक डॉट-सीमांकित पता, जो अवैध है। यह शेष आरएफसी 5322 व्याकरण के साथ संगत प्रतीत होता है और grep -Po का उपयोग करके कई परीक्षण पास करता है, जिसमें मामलों के डोमेन नाम, आईपी पते, बुरे और खाते के नाम उद्धरण के साथ और बिना।

आईपी पैटर्न में 00 बग को सुधारना, हम एक कामकाजी और काफी तेज़ रेगेक्स प्राप्त करते हैं। (वास्तविक कोड के लिए, रेंडर संस्करण, मार्कडाउन नहीं, स्क्रैप करें।)

([एक-Z0-9 # $% & '* + / = ^ _ `{|} ~ - + (?।!: \ [एक-Z0-9 # $% &!]'? * + / ? = ^ _ `{|} ~ -] +) * |" (: [\ x01- \ x08 \ x0b \ x0c \ x0e- \ x1f \ x21 \ x23- \ x5b \ x5d- \ x7f] | \\ [\ x01- \ x09 \ x0b \ x0c \ x0e- \ x7f]) * ") @ (: (: [एक-Z0-9] (?? [एक-Z0-9 -] * [एक-z0 ? -9]) \) + [एक-Z0-9] (:।? [एक-Z0-9 -] * [एक-Z0-9]) | \ [(:( :( 2 (5? [0-5] | [0-4] [0-9]) | 1 [0-9] [0-9] |?। [1-9] [0-9])) \) {3} ( ? :( 2 (5 [0-5] | [0-4] [0-9]) | 1 [0-9] [0-9] | [1-9] [0-9]) |? [ एक-Z0-9 -] * [एक-Z0-9]: (: [\ x01- \ x08 \ x0b \ x0c \ x0e- \ x1f \ x21- \ x5a \ x53- \ x7f] | \\ [\ x01- \ x09 \ x0b \ x0c \ x0e- \ x7f]) +) \])

यहां उपरोक्त regexp के लिए परिमित राज्य मशीन का diagram है जो regexp से अधिक स्पष्ट है

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

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

पुष्टिकरण टोकन यह जानने का एकमात्र तरीका है कि आपको उस व्यक्ति का पता मिला है जिसमें प्रवेश कर रहा है। यही कारण है कि अधिकांश मेलिंग सूचियां अब साइन-अप की पुष्टि करने के लिए उस तंत्र का उपयोग करती हैं। आखिरकार, कोई भी [email protected] @whitehouse.gov को नीचे डाल सकता है, और यह कानूनी रूप से भी विश्लेषण करेगा, लेकिन दूसरी तरफ व्यक्ति होने की संभावना नहीं है।

PHP के लिए, आपको PHP के साथ ई-मेल पता मान्य करने के लिए दिए गए पैटर्न का उपयोग नहीं करना चाहिए , जिस दाएं से मैं उद्धरण देता हूं:

कुछ खतरा है कि आम उपयोग और व्यापक मैला कोडिंग ई-मेल पते के लिए एक वास्तविक तथ्य स्थापित करेगा जो रिकॉर्ड किए गए औपचारिक मानक से अधिक प्रतिबंधित है।

यह अन्य सभी गैर-आरएफसी पैटर्न से बेहतर नहीं है। यह आरएफसी 822 को संभालने के लिए पर्याप्त स्मार्ट भी नहीं है, अकेले आरएफसी 5322 दें। हालांकि, यह एक है।

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

निर्दिष्ट ई-मेल पता 'myemail @ पता, com' अमान्य है। क्या आपका मतलब '[email protected]' था?

टिप्पणियों सहित ईमेल पते को मान्य करना भी देखें। या नियमित अभिव्यक्तियों को मान्य करने वाले ई-मेल पते की तुलना करना ।

डीबगेज डेमो

W3C HTML5 spec के अनुसार :

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

प्रसंग:

एक वैध ई-मेल पता एक स्ट्रिंग है जो एबीएनएफ उत्पादन से मेल खाता है [...]।
नोट: यह आवश्यकता आरएफसी 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])?)*$/

आप jQuery सत्यापन प्लगइन द्वारा नियोजित एक का उपयोग कर सकते हैं:

// derivative of work with the following copyright and license:
// Copyright (c) 2004 Casey West.  All rights reserved.
// This module is free software; you can redistribute it and/or
// modify it under the same terms as Perl itself.

// see http://search.cpan.org/~cwest/Email-Address-1.80/

private static string gibberish = @"
(?-xism:(?:(?-xism:(?-xism:(?-xism:(?-xism:(?-xism:(?-xism:\
s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^
\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))
|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+
|\s+)*[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s]+(?-xism:(?-xism:\
s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^
\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))
|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+
|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(
?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?
:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x
0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*<DQ>(?-xism:(?-xism:[
^\\<DQ>])|(?-xism:\\(?-xism:[^\x0A\x0D])))+<DQ>(?-xism:(?-xi
sm:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xis
m:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\
]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\
s*)+|\s+)*))+)?(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?
-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:
\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[
^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*<(?-xism:(?-xi
sm:(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^(
)\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(
?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))
|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()<
>\[\]:;@\,.<DQ>\s]+(?:\.[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s]
+)*)(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))
|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:
(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s
*\)\s*))+)*\s*\)\s*)+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((?
:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x
0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xi
sm:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*
<DQ>(?-xism:(?-xism:[^\\<DQ>])|(?-xism:\\(?-xism:[^\x0A\x0D]
)))+<DQ>(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\
]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-x
ism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+
)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*))\@(?-xism:(?-xism:(?-xism:(
?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?
-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^
()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s
*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s]+(
?:\.[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s]+)*)(?-xism:(?-xism:
\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[
^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+)
)|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)
+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:
(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((
?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\
x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*\[(?:\s*(?-xism:(?-x
ism:[^\[\]\\])|(?-xism:\\(?-xism:[^\x0A\x0D])))+)*\s*\](?-xi
sm:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:
\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(
?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+
)*\s*\)\s*)+|\s+)*)))>(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-
xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\
s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^
\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*))|(?-xism:(?-x
ism:(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^
()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*
(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D])
)|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()
<>\[\]:;@\,.<DQ>\s]+(?:\.[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s
]+)*)(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+)
)|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism
:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\
s*\)\s*))+)*\s*\)\s*)+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((
?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\
x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-x
ism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)
*<DQ>(?-xism:(?-xism:[^\\<DQ>])|(?-xism:\\(?-xism:[^\x0A\x0D
])))+<DQ>(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\
\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-
xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)
+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*))\@(?-xism:(?-xism:(?-xism:
(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(
?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[
^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\
s*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s]+
(?:\.[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s]+)*)(?-xism:(?-xism
:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:
[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+
))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*
)+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism
:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\(
(?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A
\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*\[(?:\s*(?-xism:(?-
xism:[^\[\]\\])|(?-xism:\\(?-xism:[^\x0A\x0D])))+)*\s*\](?-x
ism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism
:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:
(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))
+)*\s*\)\s*)+|\s+)*))))(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?
>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:
\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0
D]))|)+)*\s*\)\s*))+)*\s*\)\s*)*)"
  .Replace("<DQ>", "\"")
  .Replace("\t", "")
  .Replace(" ", "")
  .Replace("\r", "")
  .Replace("\n", "");

private static Regex mailbox =
  new Regex(gibberish, RegexOptions.ExplicitCapture);

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

यह एक पार्सर के लिए एक नौकरी है, लेकिन यदि कोई पता वाक्य रचनात्मक रूप से मान्य है, तो भी यह वितरित करने योग्य नहीं हो सकता है। कभी-कभी आपको पहाड़ी की विधि का सहारा लेना पड़ता है "अरे, आप, हमें देखिए!"

'/^(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){255,})(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){65,}@)((?>(?>(?>((?>(?>(?>\x0D\x0A)?[\t ])+|(?>[\t ]*\x0D\x0A)?[\t ]+)?)(\((?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-\'*-\[\]-\x7F]|\\\[\x00-\x7F]|(?3)))*(?2)\)))+(?2))|(?2))?)([!#-\'*+\/-9=?^-~-]+|"(?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\x7F]))*(?2)")(?>(?1)\.(?1)(?4))*(?1)@(?!(?1)[a-z0-9-]{64,})(?1)(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)(?>(?1)\.(?!(?1)[a-z0-9-]{64,})(?1)(?5)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?6)){7}|(?!(?:.*[a-f0-9][:\]]){8,})((?6)(?>:(?6)){0,6})?::(?7)?))|(?>(?>IPv6:(?>(?6)(?>:(?6)){5}:|(?!(?:.*[a-f0-9]:){6,})(?8)?::(?>((?6)(?>:(?6)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?>\.(?9)){3}))\])(?1)$/isD'

जैसा कि आप PHP में लिख रहे हैं, मैं सलाह देता हूं कि आप ईमेल के लिए PHP बिल्ड-इन सत्यापन का उपयोग करें।

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

यदि आप 5.3.6 से कम PHP प्रोग्राम चला रहे हैं, तो कृपया इस समस्या से अवगत रहें: https://bugs.php.net/bug.php?id=53091

यदि आप अधिक जानकारी चाहते हैं कि यह buid-in validation कैसे काम करता है, तो यहां देखें: क्या PHP का filter_var FILTER_VALIDATE_EMAIL वास्तव में काम करता है?

एचटीएमएल 5 कल्पना का सुझाव ई-मेल पते को मान्य के लिए एक सरल regex:

import java.util.regex.*;

class regexSample 
{
   public static void main(String args[]) 
   {
      //Input the string for validation
      String email = "[email protected]";

      //Set the email pattern string
      Pattern p = Pattern.compile(" (?:[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])+)\\]");

      //Match the given string with the pattern
      Matcher m = p.matcher(email);

      //check whether match is found 
      boolean matchFound = m.matches();

      if (matchFound)
        System.out.println("Valid Email Id.");
      else
        System.out.println("Invalid Email Id.");
   }
}

यह जानबूझकर 5322 का पालन नहीं करता है ।

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

कुल लंबाई 254 वर्णों तक सीमित हो सकती है, प्रति आरएफसी 3696 इरेटा 16 9 0 ।

अजीब बात है कि आप 4 अक्षर टीएलडी की अनुमति नहीं दे सकते हैं। आप से लोगों पर प्रतिबंध लगाने कर रहे हैं .info और .name , और लंबाई सीमा बंद .travel और .museum , लेकिन हाँ, वे 2 वर्ण TLD के और 3 अक्षरों TLD के कम से कम आम हैं।

आपको अपरकेस अक्षरों को भी अनुमति देना चाहिए। ईमेल सिस्टम स्थानीय भाग और डोमेन भाग को सामान्यीकृत करेंगे।

डोमेन भाग के आपके regex के लिए, डोमेन नाम '-' से शुरू नहीं हो सकता है और '-' के साथ समाप्त नहीं हो सकता है। डैश केवल बीच में रह सकता है।

यदि आपने पीईएआर लाइब्रेरी का इस्तेमाल किया है, तो अपने मेल फ़ंक्शन को देखें (सटीक नाम / लाइब्रेरी भूल गए)। आप एक फ़ंक्शन को कॉल करके ईमेल पता सत्यापित कर सकते हैं, और यह आरएफसी 822 में परिभाषा के अनुसार ईमेल पते को मान्य करता है।

ईमेल पते को सत्यापित करने के लिए सर्वोत्तम नियमित अभिव्यक्ति के सबसे व्यापक मूल्यांकन के लिए कृपया यह लिंक देखें; " नियमित अभिव्यक्तियों को मान्य करने वाले ई-मेल पते की तुलना करना "

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

function validateEmail($email) {
  return (bool) stripos($email,'@');
}

उल्लेख नहीं है कि निकट भविष्य में गैर-लैटिन (चीनी, अरबी, यूनानी, हिब्रू, सिरिलिक और इसी तरह) डोमेन नामों की अनुमति है । क्योंकि उन अक्षरों को निश्चित रूप से नहीं कर रहे हैं में शामिल करने हर कोई, उपयोग किए गए ईमेल regex बदलने के लिए है [az]/iऔर न ही \w। वे सभी असफल हो जाएंगे।

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

यदि रेगेक्स का उद्देश्य यूआई में उपयोगकर्ता को तुरंत सूचित करना है कि निर्दिष्ट ईमेल पता सही प्रारूप में नहीं दिखता है, तो यह जांचना अभी भी सबसे अच्छा है कि यह मूल रूप से निम्नलिखित रेगेक्स से मेल खाता है या नहीं:

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

इतना ही आसान। पृथ्वी पर क्यों आप नाम और डोमेन में इस्तेमाल किए गए पात्रों की परवाह करेंगे? यह वैध ईमेल पता दर्ज करने के लिए ग्राहक की ज़िम्मेदारी है, न कि सर्वर के। यहां तक कि जब ग्राहक एक वाक्य रचनात्मक रूप से मान्य ईमेल पते में प्रवेश [email protected]करता है, यह गारंटी नहीं देता है कि यह एक कानूनी ईमेल पता है। कोई भी regex उस को कवर कर सकते हैं।

ऐसा कोई नहीं है जो वास्तव में प्रयोग योग्य है।
मैं अपने उत्तर में कुछ मुद्दों पर चर्चा करता हूं क्या ईमेल पता सत्यापन के लिए कोई PHP लाइब्रेरी है? , ईमेल पते की Regexp मान्यता में भी यह चर्चा की गई है ?

संक्षेप में, एक उचित, काम करने के लिए एक एकल, प्रयोग योग्य regex की उम्मीद नहीं है। और सबसे अच्छा रेगेक्स सिंटैक्स को मान्य करेगा, ई-मेल की वैधता नहीं ([email protected] सही है लेकिन यह शायद उछाल जाएगा ...)।

जिन ईमेल पतों को मैं सत्यापित करना चाहता हूं उन्हें लोगों की सूची में ईमेल भेजने के लिए System.Net.mail नामस्थान का उपयोग करके एएसपी.NET वेब एप्लिकेशन द्वारा उपयोग किया जा रहा है। तो, कुछ जटिल जटिल अभिव्यक्ति का उपयोग करने के बजाय, मैं बस पते से MailAddress उदाहरण बनाने का प्रयास करता हूं। यदि पता ठीक से नहीं बनाया गया है तो MailAddress construtor अपवाद फेंक देगा। इस तरह, मुझे पता है कि मैं कम से कम ईमेल को ईमेल से बाहर कर सकता हूं। बेशक यह सर्वर-साइड सत्यापन है लेकिन कम से कम आपको वैसे भी इसकी आवश्यकता है।

protected void emailValidator_ServerValidate(object source, ServerValidateEventArgs args)
{
    try
    {
        var a = new MailAddress(txtEmail.Text);
    }
    catch (Exception ex)
    {
        args.IsValid = false;
        emailValidator.ErrorMessage = "email: " + ex.Message;
    }
}

मैं PHP का उपयोग करता हूं। मैंने इस समाधान को "झूठी सकारात्मक झूठी नकारात्मकताओं से बेहतर" की भावना में चुना है जैसा कि यहां एक अन्य टिप्पणीकर्ता द्वारा घोषित किया गया है और आपके प्रतिक्रिया समय को ऊपर रखने और सर्वर लोड करने के संबंध में ... सर्वर संसाधनों को बर्बाद करने की वास्तव में कोई आवश्यकता नहीं है एक नियमित अभिव्यक्ति जब यह सबसे सरल उपयोगकर्ता त्रुटि से बाहर निकल जाएगा। यदि आप चाहें तो परीक्षण ईमेल भेजकर आप इसका हमेशा पालन कर सकते हैं।

'/^(?!(?>"?(?>\\\[ -~]|[^"])"?){255,})(?!"?(?>\\\[ -~]|[^"]){65,}"[email protected])(?>([!#-\'*+\/-9=?^-~-]+)(?>\.(?1))*|"(?>[ !#-\[\]-~]|\\\[ -~])*")@(?!.*[^.]{64,})(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)(?>\.(?2)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?3)){7}|(?!(?:.*[a-f0-9][:\]]){8,})((?3)(?>:(?3)){0,6})?::(?4)?))|(?>(?>IPv6:(?>(?3)(?>:(?3)){5}:|(?!(?:.*[a-f0-9]:){6,})(?5)?::(?>((?3)(?>:(?3)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?>\.(?6)){3}))\])$/iD'

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

यह तय करते हुए कि कौन से पात्रों की अनुमति है, कृपया अपने apostrophed और hyphenated दोस्तों को याद रखें। मेरा इस तथ्य पर कोई नियंत्रण नहीं है कि मेरी कंपनी एचआर सिस्टम से मेरे नाम का उपयोग करके अपना ईमेल पता उत्पन्न करती है। इसमें मेरे अंतिम नाम में एस्ट्रोफ़े शामिल हैं। मैं आपको यह नहीं बता सकता कि वेबसाइट के साथ बातचीत करने से मुझे कितनी बार अवरुद्ध किया गया है कि मेरा ईमेल पता "अमान्य" है।

सर्वश्रेष्ठ के बारे में नहीं जानते, लेकिन यह कम से कम सही है, जब तक कि पतों की टिप्पणियां छीन ली जाती हैं और सफेद जगह के साथ बदल दी जाती हैं।

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