regex - একটি নিয়মিত অভিব্যক্তি ব্যবহার করে একটি ইমেইল ঠিকানা যাচাই কিভাবে?




validation email (20)

বছরের পর বছর ধরে আমি ধীরে ধীরে একটি নিয়মিত অভিব্যক্তি গড়ে তুলেছি যা সর্বাধিক ইমেল ঠিকানাগুলি সঠিকভাবে যাচাই করে, তারা আইপি ঠিকানাটি সার্ভারের অংশ হিসাবে ব্যবহার করে না বলে মনে করে।

আমি বিভিন্ন পিএইচপি প্রোগ্রামে এটি ব্যবহার করি, এবং এটি বেশিরভাগ সময় কাজ করে। যাইহোক, সময়ে সময়ে আমি এমন কোনও ব্যক্তির সাথে যোগাযোগ করি যা এটি ব্যবহার করে এমন কোনও সাইটের সাথে সমস্যা হয় এবং আমি কিছু সমন্বয় সাধন করতে শেষ হয়ে যাই (সম্প্রতি আমি বুঝতে পেরেছি যে আমি 4-অক্ষর টিএলডিগুলিকে অনুমতি দিচ্ছি না)।

আপনার কাছে থাকা সেরা নিয়মিত অভিব্যক্তি বা ইমেল যাচাই করার জন্য কী দেখানো হয়েছে?

আমি বেশ কয়েকটি সমাধান দেখেছি যা বিভিন্ন ছোট্ট এক্সপ্রেশন ব্যবহার করে, কিন্তু জটিলতর ফাংশনে কয়েকটি ছোট অভিব্যক্তি পরিবর্তে একটি সাধারণ ফাংশনে আমি দীর্ঘতর জটিল অভিব্যক্তি চাই।


দ্রুত উত্তর

ইনপুট যাচাইকরণের জন্য নিম্নলিখিত regex ব্যবহার করুন:

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)*]))*

এই regex দ্বারা মিলিত ঠিকানা:

  • একটি স্থানীয় অংশ (অর্থাৎ @ -ign এর আগে অংশ) যা RFC 5321/5322 এর সাথে কঠোরভাবে সঙ্গতিপূর্ণ,
  • একটি ডোমেন অংশ (অর্থাত্ @ -সাইনের পরে অংশ) যা কমপক্ষে দুটি লেবেল সহ একটি হোস্ট নাম, যার মধ্যে সর্বাধিক 63 অক্ষর দীর্ঘ।

দ্বিতীয় সীমা RFC 5321/5322 এ একটি সীমাবদ্ধতা।

বিস্তারিত উত্তর

নিয়মিত অভিব্যক্তি ব্যবহার করে যা ইমেল ঠিকানাগুলিকে স্বীকৃতি দেয় বিভিন্ন পরিস্থিতিতে দরকারী হতে পারে: উদাহরণস্বরূপ, কোনও নথিতে ইমেল ঠিকানাগুলি স্ক্যান করতে, ব্যবহারকারী ইনপুট যাচাই করতে, বা একটি ডেটা সংগ্রহস্থলের অখণ্ডতা সীমাবদ্ধতা হিসাবে।

তবে এটি উল্লেখ করা উচিত যে ঠিকানাটি যদি বিদ্যমান মেলবক্সের সাথে সম্পর্কিত হয় তবে ঠিকানাটিতে একটি বার্তা পাঠানোর বিকল্প নেই। যদি আপনি শুধুমাত্র একটি ঠিকানা ব্যাকরণগতভাবে সঠিক কিনা তা পরীক্ষা করতে চান তবে আপনি একটি নিয়মিত অভিব্যক্তি ব্যবহার করতে পারেন, তবে মনে রাখবেন এটি ""@[]একটি ব্যাকরণগতভাবে সঠিক ইমেল ঠিকানা যা অবশ্যই একটি বিদ্যমান মেলবক্সের উল্লেখ করে না।

ইমেল ঠিকানাগুলির সিনট্যাক্স বিভিন্ন RFCs , বিশেষত RFC 822 এবং RFC 5322 সংজ্ঞায়িত করা হয়েছে । RFC 822টি সর্বশেষ মানের হিসাবে "মূল" স্ট্যান্ডার্ড এবং RFC 5322 হিসাবে দেখা উচিত। আরএফসি 8২২ এ সংজ্ঞায়িত সিনট্যাক্স সবচেয়ে লেনদেন এবং পরবর্তী মানগুলি সিনট্যাক্সটিকে আরো এবং আরও সীমিত করে দিয়েছে, যেখানে নতুন সিস্টেম বা পরিষেবাদিগুলি অপ্রচলিত সিনট্যাক্সকে চিনতে হবে, কিন্তু এটি কখনই তৈরি করবে না।

এই উত্তরে আমি addr-specRFCs (অর্থাত্ [email protected], কিন্তু না "John Doe"<[email protected]>, না some-group:[email protected],[email protected];) হিসাবে সংজ্ঞায়িত অর্থ হিসাবে "ইমেল ঠিকানা" গ্রহণ করব ।

There's one problem with translating the RFC syntaxes into regexes: the syntaxes are not regular! This is because they allow for optional comments in email addresses that can be infinitely nested, while infinite nesting can't be described by a regular expression. To scan for or validate addresses containing comments you need a parser or more powerful expressions. (Note that languages like Perl have constructs to describe context free grammars in a regex-like way.) In this answer I'll disregard comments and only consider proper regular expressions.

The RFCs define syntaxes for email messages, not for email addresses as such. Addresses may appear in various header fields and this is where they are primarily defined. When they appear in header fields addresses may contain (between lexical tokens) whitespace, comments and even linebreaks. Semantically this has no significance however. By removing this whitespace, etc. from an address you get a semantically equivalent canonical representation . Thus, the canonical representation of first. last (comment) @ [3.5.7.9] is [email protected][3.5.7.9] .

Different syntaxes should be used for different purposes. If you want to scan for email addresses in a (possibly very old) document it may be a good idea to use the syntax as defined in RFC 822. On the other hand, if you want to validate user input you may want to use the syntax as defined in RFC 5322, probably only accepting canonical representations. You should decide which syntax applies to your specific case.

I use POSIX "extended" regular expressions in this answer, assuming an ASCII compatible character set.

RFC 822

I arrived at the following regular expression. I invite everyone to try and break it. If you find any false positives or false negatives, please post them in a comment and I'll try to fix the expression as soon as possible.

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^-~]*])

I believe it's fully complient with RFC 822 including the errata . It only recognizes email addresses in their canonical form. For a regex that recognizes (folding) whitespace see the derivation below.

The derivation shows how I arrived at the expression. I list all the relevant grammar rules from the RFC exactly as they appear, followed by the corresponding regex. Where an erratum has been published I give a separate expression for the corrected grammar rule (marked "erratum") and use the updated version as a subexpression in subsequent regular expressions.

As stated in paragraph 3.1.4. of RFC 822 optional linear white space may be inserted between lexical tokens. Where applicable I've expanded the expressions to accommodate this rule and marked the result with "opt-lwsp".

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^-~]+)])

RFC 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

আমি বিশ্বাস করি বোঝায় যা RFC 5322 সহ সঙ্গে সম্পূর্ণরূপে complient এর errata । এটি শুধুমাত্র তাদের ক্যানোনিকাল ফর্ম ইমেল ঠিকানা স্বীকৃতি দেয়। একটি regex যে স্বীকৃতি (ভাঁজ) হোয়াইটস্পেস নীচের derivation দেখতে।

Derivation দেখায় কিভাবে আমি অভিব্যক্তি এ পৌঁছেছেন। আমি RFC থেকে ঠিক একই প্রাসঙ্গিক ব্যাকরণ নিয়মগুলি তালিকাভুক্ত করি, তারপরে সংশ্লিষ্ট রেজেক্স অনুসরণ করে। নিয়মসম্মতভাবে অপ্রাসঙ্গিক (ভাঁজ করা) হোয়াইটস্পেস অন্তর্ভুক্ত নিয়মগুলির জন্য, আমি একটি পৃথক রেজেক্স চিহ্নিত করেছি "(স্বাভাবিককৃত)" যা এই হোয়াইটস্পেসটি গ্রহণ করে না।

আমি আরএফসি থেকে সমস্ত "অ-" নিয়ম উপেক্ষা। এর অর্থ হল রেজ্যাক্সগুলি শুধুমাত্র ইমেল ঠিকানাগুলির সাথে মেলে যা কঠোরভাবে RFC 5322 সঙ্গতিপূর্ণ। যদি আপনাকে "পুরানো" ঠিকানাগুলি মিলতে হয় (যেমন "অশোভন" বিধিগুলি সহ লুপার ব্যাকরণ হিসাবে), আপনি পূর্ববর্তী অনুচ্ছেদ থেকে RFC 822 রেজেক্সগুলির একটি ব্যবহার করতে পারেন।

filter_var($value, FILTER_VALIDATE_EMAIL)

উল্লেখ্য যে কিছু উত্স (উল্লেখযোগ্যভাবে w3c ) দাবি করে যে RFC 5322 স্থানীয় অংশে (যেমন- সাইন-এর আগে অংশ) খুব কঠোর। কারণ "..", "a..b" এবং "a।" হয় না বৈধ ডট পরমাণু যখন তারা ডাকবাক্স নাম হিসাবে ব্যবহার করা যেতে পারে। জন্য RFC অবশ্য নেই এই মতো স্থানীয় অংশের জন্য অনুমতি ছাড়া উদ্ধৃত করা থাকতে হবে যে, তারা। সুতরাং আপনার পরিবর্তে [email protected]লিখতে হবে "a..b"@example.net, যা semantically সমান।

আরও সীমাবদ্ধতা

SMTP (যেমন RFC 5321 এ সংজ্ঞায়িত ) আরও বৈধ ইমেল ঠিকানাগুলির (অথবা আসলে: মেইলবক্সের নাম) সেটকে সীমিত করে। এই কঠোর ব্যাকরণ প্রয়োগ করা যুক্তিসঙ্গত মনে হচ্ছে, যাতে মেলযুক্ত ইমেল ঠিকানাটি আসলেই একটি ইমেল পাঠাতে ব্যবহার করা যেতে পারে।

RFC 5321 মূলত "স্থানীয়" অংশটিকে ছেড়ে দেয় (অর্থাত @ সাইন-এর আগে অংশটি), তবে ডোমেন অংশে (অর্থাৎ @ -ign এর পরে অংশ) কঠোর। এটি ডোমেন লিটারেলের পরিবর্তে ডট-পরমাণু এবং ঠিকানা লিখনগুলির পরিবর্তে কেবল হোস্ট নামগুলি অনুমোদন করে।

হোস্টের নাম এবং আইপি ঠিকানা উভয় ক্ষেত্রেই RFC 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 ঠিকানায় মেলে ধরার জন্য আমি চূড়ান্ত রেজেক্সে নেতিবাচক চেহারাটি ব্যবহার করেছি । কিছু regex প্রসেসর নেতিবাচক lookheadhead সমর্থন করে না। |(?!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 ফর্ম। এই ক্ষেত্রে এটি ঠিকানা-লিখনগুলিকে আটকাতে এবং হোস্টনামটিতে কমপক্ষে দুটি লেবেল প্রয়োজন হয়। পূর্ববর্তী অধ্যায় থেকে উন্নত RFC 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| ইত্যাদি ... )

যদি আপনি স্পষ্ট শীর্ষ-স্তরের ডোমেন যাচাইকরণের পথটি নিচে যাওয়ার সিদ্ধান্ত নিচ্ছেন তবে আপনার রেজেক্ট আপ-টু-ডেট রাখতে ভুলবেন না।

আরও বিবেচ্য বিষয়

ডোমেইন অংশে শুধুমাত্র হোস্ট নামগুলি গ্রহণ করার পরে (@ -ign এর পরে), উপরের রেজেক্সগুলি কেবলমাত্র 63 অক্ষরের সাথে লেবেলগুলিকে গ্রহণ করতে হবে, যেমনটি করা উচিত। যাইহোক, তারা এই সত্যটি প্রয়োগ করে না যে পুরো হোস্টের নামটি অবশ্যই ২53 অক্ষর দীর্ঘ (ডটস সহ) থাকতে হবে। যদিও এই সীমাবদ্ধতা কঠোরভাবে এখনও নিয়মিত বলছে, তবে এই নিয়মটি অন্তর্ভুক্ত করে এমন একটি রেজেক্স তৈরি করা সম্ভব নয়।

আরেকটি বিবেচনা, বিশেষ করে যখন ইনপুট যাচাইকরণের জন্য regexes ব্যবহার করা, ব্যবহারকারীর প্রতিক্রিয়া। একটি ব্যবহারকারী একটি ভুল ঠিকানা প্রবেশ করে, একটি সহজ "বাক্যযুক্তভাবে ভুল ঠিকানা" চেয়ে একটু বেশি মতামত দিতে চমৎকার হবে। "ভ্যানিলা" Regexes সঙ্গে এই সম্ভব নয়।

এই দুটি বিবেচনার ঠিকানা বিশ্লেষণ দ্বারা মোকাবেলা করা যেতে পারে। হোস্ট নামগুলির উপর অতিরিক্ত দৈর্ঘ্য সীমাবদ্ধতা কিছু ক্ষেত্রেও এটি একটি অতিরিক্ত রেজেক্স ব্যবহার করে সংশোধন করা যেতে পারে এবং উভয় এক্সপ্রেশনগুলির বিরুদ্ধে ঠিকানার সাথে মেলে।

এই উত্তর regexes কোন কর্মক্ষমতা জন্য অপ্টিমাইজ করা হয়। পারফরম্যান্স একটি সমস্যা হলে, আপনি দেখতে পাবেন (এবং কীভাবে) আপনার পছন্দের রেজেক্ট অপ্টিমাইজ করা যায়।


[আপডেট] আমি এখানে ইমেল ঠিকানা যাচাইকরণ সম্পর্কে যা কিছু জানি তা আমি সংযোজন করেছি: http://isemail.info/ , যা এখন কেবল বৈধ নয় তবে ইমেল ঠিকানাগুলির সমস্যাগুলিও নির্ণয় করে। আমি এখানে মন্তব্যের সাথে একমত যে বৈধতা উত্তরটির একটি অংশ মাত্র। http://isemail.info/about এ আমার প্রবন্ধ দেখুন।

is_email () অবশেষে, যতদূর আমি জানি, একমাত্র বৈধতা যা আপনাকে নির্দিষ্টভাবে বলবে যে প্রদত্ত স্ট্রিং একটি বৈধ ইমেল ঠিকানা কিনা বা না। আমি http://isemail.info/ এ একটি নতুন সংস্করণ আপলোড করেছি

আমি ক্যাল হেন্ডারসন, ডেভ চাইল্ড, ফিল হ্যাক, ডগ Lovell, RFC5322 এবং RFC 3696 থেকে পরীক্ষার ক্ষেত্রে collated। 275 পরীক্ষার ঠিকানা সব। আমি খুঁজে পেতে পারে সব বিনামূল্যে বৈধতা বিরুদ্ধে এই সব পরীক্ষা চালানো।

আমি এই পৃষ্ঠাটিকে আপ-টু-ডেট রাখতে চেষ্টা করব কারণ লোকেরা তাদের বৈধতাগুলি উন্নত করে। ক্যাল, মাইকেল, ডেভ, পল এবং ফিলকে ধন্যবাদ এবং এই পরীক্ষাগুলি এবং আমার নিজের বৈধতার গঠনমূলক সমালোচনার সংকলনে সহায়তা ও সহযোগিতা করার জন্য।

জনগণকে বিশেষ করে RFC 3696 এর বিরুদ্ধে ত্রুটি - বিচ্যুতি সম্পর্কে অবগত থাকা উচিত। ক্যানোনিকাল উদাহরণ তিনটি আসলে অবৈধ ঠিকানা। এবং একটি ঠিকানা সর্বোচ্চ দৈর্ঘ্য 254 বা 256 অক্ষর, 320 নয়


এই প্রশ্নটি অনেকটা জিজ্ঞাসা করা হয়েছে, তবে আমার মনে হয় আপনাকে পিছনে পদক্ষেপ নিতে হবে এবং নিজেকে জিজ্ঞেস করুন কেন আপনি ইমেল ঠিকানাগুলি সিন্ট্যাক্টিকভাবে বৈধ করতে চান? সত্যিই বেনিফিট কি?

  • এটা সাধারণ টাইপস ধরা হবে না।
  • এটি লোকেদের অবৈধ বা তৈরি ইমেল ঠিকানাগুলি প্রবেশ করতে বা অন্য কারো ঠিকানা লিখতে বাধা দেয় না।

যদি আপনি কোনও ইমেলটি বৈধ করতে চান তবে আপনার কাছে কোনও নিশ্চিতকরণ ইমেল পাঠানোর চেয়ে আর কোনও বিকল্প নেই এবং ব্যবহারকারীর কাছে এটির উত্তর দিতে হবে। অনেক ক্ষেত্রে আপনাকে নিরাপত্তার কারণে বা নৈতিক কারণে (যেমন আপনি তাদের ইচ্ছার বিরুদ্ধে কোনও পরিষেবাতে সাইন ইন করতে পারবেন না) এর জন্য কোনও নিশ্চয়তা মেল পাঠাতে হবে।


এটা সব আপনি হতে চান কিভাবে সঠিক উপর নির্ভর করে। আমার উদ্দেশ্যগুলির জন্য, যেখানে আমি bob @ aol.com (ইমেলগুলিতে স্পেস) বা steve (কোন ডোমেইন নেই) অথবা [email protected] (.com এর আগে কোন সময়কাল) এর মতো জিনিসগুলি সংরক্ষণ করার চেষ্টা করছি, আমি ব্যবহার করি

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

অবশ্যই, এটি এমন বৈধ জিনিসগুলির সাথে মেলে যা বৈধ ইমেল ঠিকানা নয়, তবে এটি 90/10 রুল খেলার কথা।


এটি সর্বোত্তমভাবে আপনি কী বোঝাতে চান তার উপর নির্ভর করে: যদি আপনি প্রতিটি বৈধ ইমেল ঠিকানাটি ধরার বিষয়ে কথা বলছেন তবে নিম্নলিখিতগুলি ব্যবহার করুন:

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ 
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
 \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
 \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
 \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
?:\r\n)?[ \t])*))*)?;\s*)

( http://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html ) আপনি যদি কিছু সহজ খুঁজছেন তবে এটি সবচেয়ে কার্যকর ইমেল ঠিকানাগুলি ধরবে এমন কিছু করার চেষ্টা করুন:

"^[a-zA-Z0-9_.+-][email protected][a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"

সম্পাদনা করুন: লিঙ্ক থেকে:

এই নিয়মিত অভিব্যক্তিটি শুধুমাত্র এমন কোনও ঠিকানা যাচাই করবে যা কোনও মন্তব্য বন্ধ করে দেওয়া হবে এবং হোয়াইট স্পেস দিয়ে প্রতিস্থাপিত হবে (এটি মডিউল দ্বারা করা হয়)।


সম্পূর্ণ RFC 822 সম্মিলিত Regex তার দৈর্ঘ্য কারণে অক্ষম এবং অস্পষ্ট। সৌভাগ্যবশত, আরএফসি 8২২ দুবার স্থানান্তরিত হয়েছিল এবং ইমেল ঠিকানাগুলির জন্য বর্তমান স্পেসিফিকেশন RFC 5322 । RFC 5322 একটি রেজেক্সের দিকে পরিচালিত করে যা কয়েক মিনিটের জন্য অধ্যয়ন করা হয় এবং প্রকৃত ব্যবহারের জন্য যথেষ্ট দক্ষ কিনা তা বোঝা যায়।

একটি RFC 5322 অনুবর্তী রেজেক্সটি http://emailregex.com/ এ পৃষ্ঠার শীর্ষে পাওয়া যেতে পারে তবে আইপি ঠিকানা প্যাটার্নটি ব্যবহার করে যা ইন্টারনেটের চারপাশে ভাসমান একটি বাগ যা 00 অনির্দিষ্ট বাইটি দশমিক মানগুলির জন্য একটি বিন্দু-সীমিত ঠিকানা, যা অবৈধ। বাকিটি RFC 5322 ব্যাকরণের সাথে সামঞ্জস্যপূর্ণ বলে মনে হয় এবং grep -Po ব্যবহার করে বেশ কয়েকটি পরীক্ষা পাস করে, যার মধ্যে ডোমেন নামগুলি, আইপি ঠিকানা, খারাপগুলি এবং অ্যাকাউন্ট নামগুলি এবং কোট ছাড়াও রয়েছে।

আইপি প্যাটার্নে 00 বাগ সংশোধন করা, আমরা একটি কাজ এবং মোটামুটি দ্রুত regex প্রাপ্ত। (প্রকৃত কোডের জন্য প্রদত্ত সংস্করণটি চিহ্নিত করুন, মার্কডাউন নয়।)

(: [একটি 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]) + +) \])

এখানে diagram জন্য সীমাবদ্ধ রাষ্ট্র মেশিনের diagram যা regexp এর চেয়ে আরও স্পষ্ট

পার্ল এবং পিসিআরএতে আরো পরিশীলিত নিদর্শনগুলি (পিএইচপি-তে ব্যবহৃত রেজেক্স লাইব্রেরি) সঠিকভাবে RFC 5322 ব্যবধান ছাড়াই পার্স করতে পারে। পাইথন এবং সি # এগুলিও করতে পারে, তবে তারা প্রথম দুটি থেকে ভিন্ন সিনট্যাক্স ব্যবহার করে। তবে, যদি আপনাকে অনেক কম শক্তিশালী প্যাটার্ন-মিলযুক্ত ভাষাগুলির একটি ব্যবহার করতে বাধ্য করা হয়, তবে একটি বাস্তব প্যাসারার ব্যবহার করা ভাল।

RFC এর মাধ্যমে এটি যাচাই করাও এটি গুরুত্বপূর্ণ যে সরবরাহকৃত ডোমেনে ঠিকানাটি আসলেই বিদ্যমান কিনা বা ঠিকানাটি প্রবেশকারী ব্যক্তি তার প্রকৃত মালিক কিনা তা সম্পর্কে একেবারে কিছুই জানাবেন না। মানুষ এই ভাবে সব সময় মেইলিং তালিকা আপ সাইন আপ। ফিক্সিংয়ের জন্য এমন ফ্যানাসিয়ার ধরনের বৈধতা দরকার যা ঠিকানাটি প্রেরণ করে এমন একটি বার্তা যা একটি নিশ্চিতকরণ টোকেন অন্তর্ভুক্ত করে যা একই ওয়েবপৃষ্ঠাতে প্রবেশ করার অর্থ ছিল ঠিকানা হিসাবে।

নিশ্চিতকরণ টোকেন আপনি প্রবেশকারী ব্যক্তির ঠিকানা পেয়েছেন জানতে একমাত্র উপায়। এই কারণে অধিকাংশ মেইলিং তালিকা এখন সাইন-আপ নিশ্চিত করার জন্য সেই প্রক্রিয়াটি ব্যবহার করে। সব পরে, কেউ [email protected] @ whitehouse.gov নিচে দিতে পারেন, এবং যে এমনকি আইনী হিসাবে বিশ্লেষণ করা হবে, কিন্তু এটি অন্য দিকে ব্যক্তি হতে পারে না।

পিএইচপি এর জন্য, পিএইচপি সহ একটি ই-মেইল ঠিকানা যাচাই করতে দেওয়া প্যাটার্নটি ব্যবহার করা উচিত নয় , যা আমি উদ্ধৃত করছি:

কিছু বিপদ রয়েছে যা সাধারণ ব্যবহার এবং বিস্তৃত পঙ্কিল কোডিং ইমেলের ঠিকানাগুলির জন্য একটি সত্যিকারের মান স্থাপন করবে যা রেকর্ডকৃত আনুষ্ঠানিক মানের চেয়ে বেশি বিধিনিষেধযুক্ত।

এটি অন্য সমস্ত অ-আরএফসি নকশার চেয়ে ভাল নয়। এমনকি RFC 822 এমনকি এটি RFC 5322 এও চালানোর জন্য যথেষ্ট স্মার্ট নয়। এটি এক , তবে।

আপনি অভিনব এবং pedantic পেতে চান, একটি সম্পূর্ণ রাষ্ট্র ইঞ্জিন বাস্তবায়ন । একটি নিয়মিত অভিব্যক্তি শুধুমাত্র একটি প্রাথমিক ফিল্টার হিসাবে কাজ করতে পারেন। নিয়মিত এক্সপ্রেশনগুলির সমস্যাটি হল যে কাউকে বলছে যে তাদের পুরোপুরি বৈধ ইমেল ঠিকানাটি অবৈধ (একটি মিথ্যা ইতিবাচক) কারণ আপনার নিয়মিত অভিব্যক্তিটি হ্যান্ডেল করতে পারে না এটি কেবল ব্যবহারকারীর দৃষ্টিকোণ থেকে অভদ্র এবং অসম্পূর্ণ। এই উদ্দেশ্যর জন্য একটি রাষ্ট্র ইঞ্জিন উভয়ই ই-মেইল ঠিকানাগুলি বৈধ এবং সঠিক করতে পারে যা অন্যথায় অবৈধ হিসাবে বিবেচিত হবে কারণ এটি প্রতিটি RFC অনুসারে ইমেল ঠিকানাটিকে পৃথক করে। এটি একটি সম্ভাব্য আরো আনন্দদায়ক অভিজ্ঞতা, যেমন

নির্দিষ্ট ইমেল ঠিকানা 'ম্যাইমেইল @ ঠিকানা, কম' অবৈধ। আপনি কি '[email protected]' বলতে চাচ্ছেন?

এছাড়াও মন্তব্য সহ ইমেল ঠিকানা বৈধতা দেখুন। অথবা নিয়মিত এক্সপ্রেশন যাচাই বৈধ ইমেইল ঠিকানা তুলনা

Debuggex ডেমো


W3C HTML5 স্পেক প্রতি:

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

প্রসঙ্গ:

একটি বৈধ ই-মেইল ঠিকানা একটি স্ট্রিং যা ABNF উত্পাদনের সাথে মেলে [...]।

দ্রষ্টব্য: এই প্রয়োজনীয়তাটি RFC 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])?)*$/


RFC 5322 মানক:

ডট-পারমাণবিক স্থানীয় অংশ, উদ্ধৃত-স্ট্রিং স্থানীয়-অংশ, অপ্রচলিত (মিশ্র বিন্দু-পরমাণু এবং উদ্ধৃত-স্ট্রিং) স্থানীয়-অংশ, ডোমেন নাম ডোমেন, (IPv4, IPv6, এবং IPv4- ম্যাপযুক্ত IPv6 ঠিকানা) ডোমেইন আক্ষরিক ডোমেন, এবং (ন্যস্ত) CFWS।

 '/^(?!(?>(?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' 

RFC 5321 মানক:

ডট-পারমাণবিক স্থানীয় অংশ, উদ্ধৃত-স্ট্রিং স্থানীয়-অংশ, ডোমেন নাম ডোমেন, এবং (IPv4, IPv6, এবং IPv4- ম্যাপযুক্ত IPv6 ঠিকানা) ডোমেইন আক্ষরিক ডোমেনকে অনুমতি দেয়।

 '/^(?!(?>"?(?>\\\[ -~]|[^"])"?){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' 

বেসিক:

ডট-পারমাণবিক স্থানীয়-অংশ এবং ডোমেন নাম ডোমেইনকে অনুমতি দেয় (টিএলডি সহ অন্তত দুটি ডোমেন নাম লেবেলগুলি 2-6 বর্ণমালা অক্ষর সীমাবদ্ধ)।

 "/^(?!.{255,})(?!.{65,}@)([!#-'*+\/-9=?^-~-]+)(?>\.(?1))*@(?!.*[^.]{64,})(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?\.){1,126}[az]{2,6}$/iD" 

আমি ব্যবহার করি

^\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$

RegularExpressionValidator দ্বারা ASP.NET এ ব্যবহৃত কোনটি।


একটি উজ্জ্বল বিক্ষোভের জন্য, নিম্নলিখিত দৈত্যটি বেশ ভাল তবে এখনও সার্টিফিক্যাল বৈধ ইমেল ঠিকানাগুলি সঠিকভাবে সনাক্ত করে না: এটি চার স্তরের গভীরে নেস্টেড মন্তব্যগুলিকে স্বীকৃতি দেয়।

এটি একটি পসারের জন্য একটি কাজ, তবে একটি ঠিকানা সিনট্যাক্টিক্যাল বৈধ হলেও এমনকি এটি প্রদানযোগ্য হতে পারে না। কখনও কখনও আপনাকে হিলিবিলি পদ্ধতিতে অবলম্বন করতে হবে "আরে, হ্যাঁ, ঘড়ি দেখুন!"

'/^(?!(?>(?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'

HTML5 এর বৈশিষ্ট প্রস্তাব দেওয়া ইমেল ঠিকানাগুলি যাচাই করার জন্য একটি সহজ 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 অক্ষর, RFC 3696 ইরাট 1690 প্রতি সীমাবদ্ধ হতে পারে ।


অদ্ভুত যে আপনি 4 অক্ষর টিএলডিগুলিকে অনুমতি দিতে পারবেন না। আপনি থেকে মানুষ নিষিদ্ধ করা হয় .info এবং .name , এবং দৈর্ঘ্য সীমাবদ্ধতা স্টপ .travel এবং .museum কিন্তু হ্যাঁ, তারা 2 অক্ষর TLDs এ এবং 3 টি অক্ষর TLDs এ কম সাধারণ।

আপনি খুব বড় হাতের অক্ষর অনুমতি দেওয়া উচিত। ইমেল সিস্টেম স্থানীয় অংশ এবং ডোমেইন অংশ স্বাভাবিক করা হবে।

ডোমেন অংশ আপনার regex জন্য, ডোমেইন নাম '-' দিয়ে শুরু হতে পারে না এবং '-' দিয়ে শেষ হতে পারে না। ড্যাশ শুধুমাত্র মধ্যে থাকতে পারে।

আপনি যদি পিয়ার লাইব্রেরি ব্যবহার করেন তবে তাদের মেইল ​​ফাংশনটি পরীক্ষা করুন (সঠিক নাম / লাইব্রেরি ভুলে যান)। আপনি একটি ফাংশন কল করে ইমেল ঠিকানা যাচাই করতে পারেন এবং এটি RFC822 এ সংজ্ঞা অনুসারে ইমেল ঠিকানাটি বৈধ করে।


আমি যে ইমেইল ঠিকানাগুলি যাচাই করতে চাইছি সেগুলির একটি তালিকাতে ইমেল পাঠাতে System.Net.Mail নামস্থান ব্যবহার করে একটি ASP.NET ওয়েব অ্যাপ্লিকেশন দ্বারা ব্যবহার করা হবে। সুতরাং, কিছু জটিল নিয়মিত এক্সপ্রেশন ব্যবহার করার পরিবর্তে, আমি ঠিকানা থেকে একটি মেলআড্রেস উদাহরণ তৈরি করার চেষ্টা করি। ঠিকানা সঠিকভাবে গঠিত না হলে MailAddress কনস্ট্রাক্টর একটি ব্যতিক্রম নিক্ষেপ করবে। এই ভাবে, আমি অন্তত দরজা থেকে ইমেল পেতে পারেন জানি। অবশ্যই এই সার্ভার-পার্শ্ব বৈধতা কিন্তু একটি সর্বনিম্ন আপনি যে যাইহোক প্রয়োজন।

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

উল্লেখ্য যে অ-ল্যাটিন (চীনা, আরবি, গ্রিক, হিব্রু, সিরিলিক ইত্যাদি) ডোমেন নামগুলি নিকট ভবিষ্যতে অনুমোদিত হবে । প্রত্যেকেরই ব্যবহৃত ইমেল regex পরিবর্তন করতে হবে, কারণ যারা অক্ষর অবশ্যই দ্বারা আচ্ছাদিত করা হবে [az]/iনা \w। তারা সব ব্যর্থ হবে।

সব পরে, সেরা ইমেল ঠিকানা যাচাই করতে পথ আসলে এখনও নেই পাঠাতে ঠিকানা যাচাই করতে প্রশ্নে ঠিকানায় একটি ইমেল। যদি ইমেইল ঠিকানাটি ব্যবহারকারী প্রমাণীকরণের অংশ হয় (নিবন্ধন / লগইন / ইত্যাদি) তবে আপনি ব্যবহারকারী অ্যাক্টিভেশন সিস্টেমের সাথে পুরোপুরি একত্রিত করতে পারেন। আমি নির্দিষ্ট ইমেল ঠিকানাতে একটি অনন্য অ্যাক্টিভেশন কী সহ একটি লিঙ্ক সহ একটি ইমেল পাঠান এবং ইমেলটিতে লিঙ্কটি ব্যবহার করে ব্যবহারকারী দ্বারা তৈরি হওয়া অ্যাকাউন্টটি সক্রিয় করে লগইন করার অনুমতি দিন।

যদি রেজেক্সের উদ্দেশ্যটি UI- এ ব্যবহারকারীকে দ্রুত অবহিত করা হয় যে নির্দিষ্ট ইমেল ঠিকানাটি সঠিক বিন্যাসে দেখায় না তবে এটি মূলত নিম্নলিখিত রেজেক্সের সাথে মিলছে কিনা তা পরীক্ষা করার জন্য সেরা:

(?:[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 যে কভার করতে পারেন।


একটি ইমেল ঠিকানা যাচাই করার জন্য সেরা নিয়মিত অভিব্যক্তির সর্বাধিক ব্যাপক মূল্যায়নের জন্য দয়া করে এই লিঙ্কটি দেখুন; " নিয়মিত এক্সপ্রেশন যাচাই করা ই-মেইল ঠিকানা তুলনা "

এখানে রেফারেন্স উদ্দেশ্যে বর্তমান শীর্ষ অভিব্যক্তি:

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

একটি সহজ নিয়মিত অভিব্যক্তি যা কমপক্ষে কোনও বৈধ ইমেল ঠিকানা প্রত্যাখ্যান করবে না তার জন্য কিছু চেক করা হবে, তারপরে একটি @ চিহ্ন এবং তারপরে কিছু সময়ের সাথে এবং অন্তত 2 টি ঘটনা অনুসরণ করা হবে। এটি কিছু প্রত্যাখ্যান করবে না, তবে স্পিকারটি পর্যালোচনা করার পরে আমি কোনও ইমেল খুঁজে পাচ্ছি না যা বৈধ এবং প্রত্যাখ্যাত হবে।

ইমেইল = ~ /[email protected][^@]+\.[^@]{2,}$/


কোন অক্ষর অনুমতি দেওয়া হয় তা নির্ধারণ করার সময়, আপনার apostrophed এবং hyphenated বন্ধুদের মনে রাখবেন। আমার কোম্পানি এইচআর সিস্টেম থেকে আমার নাম ব্যবহার করে আমার ইমেল ঠিকানা জেনারেট করে যে কোন নিয়ন্ত্রণ নেই। যে আমার শেষ নাম apostrophe অন্তর্ভুক্ত। আমার ইমেল ঠিকানাটি "অবৈধ" এমন একটি ওয়েবসাইটের সাথে মিথস্ক্রিয়া থেকে কতবার আমি অবরুদ্ধ হয়েছি তা আমি আপনাকে বলতে পারছি না।


নেটতে এটির প্রচুর উদাহরণ রয়েছে (এবং আমি মনে করি RFC সম্পূর্ণরূপে বৈধ করে এমন একটিও - কিন্তু মেমরিটি যদি এটির দশমিক / লম্বা লম্বা লাইন থাকে তবে)। মানুষ জিনিস এই সাজানোর বৈধ দূরে বাহিত পেতে ঝোঁক। কেন শুধু এটি একটি @ এবং অন্তত এক চেক না। এবং কিছু সহজ সর্বনিম্ন দৈর্ঘ্য পূরণ করে। এটি একটি জাল ইমেল প্রবেশ করতে তুচ্ছ এবং এখনও যেকোন বৈধ regex মেলে। আমি মিথ্যা ইতিবাচক মিথ্যা নেতিবাচক তুলনায় ভাল অনুমান করবে।


সরকারী মান RFC 2822 অনুযায়ী বৈধ ইমেল regex হয়

"/^(?!.{255,})(?!.{65,}@)([!#-'*+\/-9=?^-~-]+)(?>\.(?1))*@(?!.*[^.]{64,})(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?\.){1,126}[a-z]{2,6}$/iD"

যদি আপনি জাভাতে এটি ব্যবহার করতে চান তবে এটি সত্যিই খুব সহজ

public bool ValidateEmail(string sEmail)
{
    if (sEmail == null)
    {
        return false;
    }

    int nFirstAT = sEmail.IndexOf('@');
    int nLastAT = sEmail.LastIndexOf('@');

    if ((nFirstAT > 0) && (nLastAT == nFirstAT) && (nFirstAT < (sEmail.Length - 1)))
    {
        return (Regex.IsMatch(sEmail, @"^[a-z|0-9|A-Z]*([_][a-z|0-9|A-Z]+)*([.][a-z|0-9|A-Z]+)*([.][a-z|0-9|A-Z]+)*(([_][a-z|0-9|A-Z]+)*)[email protected][a-z][a-z|0-9|A-Z]*\.([a-z][a-z|0-9|A-Z]*(\.[a-z][a-z|0-9|A-Z]*)?)$"));
    }
    else
    {
        return false;
    }
}

সেরা সম্পর্কে জানা নেই, তবে এটি অন্তত সঠিক, যতক্ষণ না ঠিকানাগুলি তাদের মন্তব্যগুলি ফাঁকা করে এবং হোয়াইটস্পেস দিয়ে প্রতিস্থাপিত হয়।

সিরিয়াসলি।আপনি ইমেল যাচাই করার জন্য একটি লিখিত লাইব্রেরি ব্যবহার করা উচিত। সর্বোত্তম উপায়টি সম্ভবত সেই ঠিকানায় একটি যাচাইকরণ ইমেল পাঠানো।







string-parsing