JavaScript හි විද්‍යුත් තැපැල් ලිපිනයක් වලංගු කරන්නේ කෙසේද

ජාවාස්ක්‍රිප්ට් හි විද්‍යුත් තැපැල් ලිපිනයක් වලංගු කිරීම සඳහා සාමාන්‍ය ප්‍රකාශනයක් තිබේද?

සාමාන්‍ය ප්‍රකාශන භාවිතා කිරීම හොඳම ක්‍රමයයි. ඔබට මෙහි පරීක්ෂණ පොකුරක් දැකිය හැකිය ( ක්‍රෝමියම් වලින් ගත් )

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

යුනිකෝඩ් පිළිගන්නා නිත්‍ය අපනයනය පිළිබඳ උදාහරණය මෙන්න:

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

නමුත් යමෙකු ජාවාස්ක්‍රිප්ට් වලංගුකරණය මත පමණක් රඳා නොසිටිය යුතු බව මතක තබා ගන්න. ජාවාස්ක්‍රිප්ට් පහසුවෙන් අක්‍රිය කළ හැකිය. මෙය සේවාදායක පැත්තේ ද වලංගු කළ යුතුය.

ඉහත ක්‍රියාවෙහි උදාහරණයක් මෙන්න:

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

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

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

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

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

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

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

ඇත්තෙන්ම සරල වලංගු භාවයක් අවශ්‍ය පුද්ගලයින් සඳහා මම ජේමන්ගේ පිළිතුර තරමක් වෙනස් කර ඇත:

anystring@anystring.anystring

නිත්‍ය ප්‍රකාශනය:

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

උදාහරණ JavaScript ශ්‍රිතය:

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

සම්පූර්ණත්වය සඳහා, මෙන්න ඔබට තවත් RFC 2822 අනුකූල රීජෙක්ස් එකක් තිබේ

නිල ප්‍රමිතිය RFC 2822 ලෙස හැඳින්වේ . වලංගු ඊමේල් ලිපින පිළිපැදිය යුතු වාක්‍ය ඛණ්ඩය එය විස්තර කරයි. ඔබට හැකි ( නමුත් ඔබ නොකළ යුතු - කියවීමට ) පහත ප්රකාශන සමග එය ක්රියාත්මක:

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

(...) ද්විත්ව උපුටා දැක්වීම් සහ වර්ග වරහන් භාවිතා කරමින් වාක්‍ය ඛණ්ඩය මඟ හැරියහොත් අපට RFC 2822 වඩාත් ප්‍රායෝගිකව ක්‍රියාත්මක වේ. එය අදටත් සැබෑ භාවිතයේ ඇති සියලුම විද්‍යුත් තැපැල් ලිපිනයන්ගෙන් 99.99% ට ගැලපේ.

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

ඔබට කළ හැකි තවත් වෙනසක් වන්නේ ඕනෑම අකුරු දෙකකින් යුත් රටක කේත ඉහළ මට්ටමේ වසමකට ඉඩ දීම සහ විශේෂිත සාමාන්‍ය ඉහළ මට්ටමේ වසම් වලට පමණි. මෙම රීජෙක්ස් වැනි ව්‍යාජ ඊමේල් ලිපින පෙරහන්asdf@adsf.adsf කරයි. ඔබ නව ඉහල මට්ටමේ වසම් එකතු ලෙස එය යාවත්කාලීන කිරීමට අවශ්ය වනු ඇත .

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

එබැවින් නිල ප්‍රමිතීන් අනුගමනය කරන විට පවා වෙළඳාම් කළ යුතුව ඇත. සබැඳි පුස්තකාලවලින් හෝ සාකච්ඡා සංසදවලින් නිත්‍ය ප්‍රකාශන අන්ධ ලෙස පිටපත් නොකරන්න. ඔබේම දත්ත සහ ඔබේම යෙදුම් සමඟ ඒවා නිතරම පරීක්ෂා කරන්න.

_{මගේ අවධාරණය}

ඇවැත්නි, මෙහි සංකීර්ණතා රාශියක් ඇත. ඔබට කිරීමට අවශ්‍ය වන්නේ වඩාත්ම පැහැදිලිව පෙනෙන සින්ටැක්ස් දෝෂ හසුකර ගැනීම පමණි, මම මේ වගේ දෙයක් කරමි:

^\S+@\S+$

එය සාමාන්‍යයෙන් පරිශීලකයා විසින් සිදුකරන වඩාත්ම පැහැදිලි දෝෂ හඳුනාගෙන පෝරමය බොහෝ දුරට නිවැරදි බව සහතික කරයි, එය ජාවාස්ක්‍රිප්ට් වලංගුකරණය වේ.

ඊමේල් වලංගු කිරීම සඳහා සාමාන්‍ය ප්‍රකාශනයක් භාවිතා කිරීමට ඔබ තීරණය කළ දෙවැන්න ඔබ තේරුම් ගත යුතු දෙයක් තිබේ: එය බොහෝ විට හොඳ අදහසක් නොවේ . ඔබ එය සමඟ එකඟ වූ පසු, ඔබව අඩක් දුරට ගෙන යා හැකි බොහෝ ක්‍රියාත්මක කිරීම් තිබේ, මෙම ලිපිය ඒවා මනාව සාරාංශ කරයි.

කෙසේ වෙතත්, කෙටියෙන් කිවහොත්, පරිශීලකයා ඇතුළු කළ දෙය ඇත්ත වශයෙන්ම විද්‍යුත් තැපෑලක් බව නියත වශයෙන්ම ධනාත්මකව විශ්වාස කළ හැකි එකම ක්‍රමය ඊමේල් පණිවිඩයක් යැවීම සහ සිදුවන්නේ කුමක්ද යන්න බැලීමයි. ඒ හැරෙන්නට එය සියල්ලම අනුමාන පමණි.

HTML5 හි විද්‍යුත් තැපැල් වලංගුතාවයක් ඇත. ඔබගේ බ්‍රව්සරය HTML5 සඳහා සහය දක්වන්නේ නම් ඔබට පහත කේතය භාවිතා කළ හැකිය.

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

jsFiddle සබැඳිය

සිට HTML5 පිරිවිතර :

ඒ , වලංගු විද්යුත්-තැපැල් ලිපිනය ද ගැලපෙන වැලක් වේ emailපහත සඳහන් ABNF, එය සඳහා යුනිකෝඩ් අක්ෂර කට්ටලය නිෂ්පාදනය.

email   = 1*( atext / "." ) "@" label *( "." label )
label   = let-dig [ [ ldh-str ] let-dig ]  ; limited to a length of 63 characters by RFC 1034 section 3.5
atext   = < as defined in RFC 5322 section 3.2.3 >
let-dig = < as defined in RFC 1034 section 3.5 >
ldh-str = < as defined in RFC 1034 section 3.5 >

මෙම අවශ්‍යතාවය හිතාමතා උල්ලං is නය කිරීමකි RFC 5322 උල්ලං වන අතර, එය එකවරම දැඩි ("@" අක්ෂරයට පෙර), නොපැහැදිලි ("@" අක්‍ෂරයෙන් පසුව), සහ ඉතා ලිහිල් (අදහස් දැක්වීමට ඉඩ දෙන) විද්‍යුත් ලිපිනයන් සඳහා වාක්‍ය ඛණ්ඩයක් අර්ථ දක්වයි. , වයිට්ස්පේස් අක්ෂර, සහ බොහෝ පරිශීලකයින්ට නුහුරු පුරුදු වලින් උපුටා ගත් නූල්) මෙහි ප්‍රායෝගික භාවිතයට ගත යුතුය.

පහත දැක්වෙන ජාවාස්ක්‍රිප්ට් සහ පර්ල්-අනුකූල නිත්‍ය ප්‍රකාශනය ඉහත අර්ථ දැක්වීම ක්‍රියාත්මක කිරීමකි.

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

මෙය හොඳම විසඳුම බව මම සොයාගෙන ඇත:

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

එය පහත ආකෘති වලට ඉඩ දෙයි:

1. beautifulandsimple@example.com
2. very.common@example.com
3. dispable.style.email.with+symbol@example.com
4. other.email-with-dash@example.com
9. #!$%&'*+-/=?^_` {==||@example.org
6. "() []:,; @ \\\"! # $% & '* + - / =? ^ _ `{} | ~ .a "@ example.org
7. "" @ example.org (උපුටා දැක්වීම් අතර අවකාශය)
8. xexample.com (දේශීය කොටසෙහි යුනිකෝඩ් අක්ෂර)
9. .comé@üñîçøðé.com (ඩොමේන් කොටසෙහි යුනිකෝඩ් අක්ෂර)
10. Pelé@example.com (ලතින්)
11. δοκιμή@παράδειγμα.δοκιμή (ග්‍රීක)
12. 我 買 @ 屋企. 香港 (චීන)
13. 甲 斐 @ 黒 川. Japanese (ජපන්)
14. чебурашка@ящик-с-апельсинами.рф (සිරිලික්)

එය පැහැදිලිවම බහුකාර්ය වන අතර මූලික ඕනෑම දෙයක් ක්‍රියාත්මක කරන අතරම සියලු වැදගත් ජාත්‍යන්තර චරිත සඳහා ඉඩ ලබා දේ. එය RFC විසින් තාක්‍ෂණිකව අවසර දී ඇති අවකාශයන් අවහිර කරනු ඇත, නමුත් ඒවා ඉතා දුර්ලභ බැවින් මෙය කිරීමට මම සතුටු වෙමි.

නවීන බ්‍රව්සර් වලදී ඔබට පිරිසිදු ජාවාස්ක්‍රිප්ට් සහ ඩොම් සමඟ සුෂිල්ගේ පිළිතුර මත ගොඩනගා ගත හැකිය :

function validateEmail(value) {
  var input = document.createElement('input');

  input.type = 'email';
  input.required = true;
  input.value = value;

  return typeof input.checkValidity === 'function' ? input.checkValidity() : /\S+@\S+\.\S+/.test(value);
}

මම වීණාවක් උදාහරණයක් ලෙස එකට දානවා http://jsfiddle.net/boldewyn/2b6d5/ . විශේෂාංග අනාවරණය කර ගැනීම සහ ස්කොවිල්ගේ පිළිතුරෙන් හිස් ඇටකටු වලංගු කිරීම සමඟ ඒකාබද්ධව , එය නිත්‍ය ප්‍රකාශන සංහාරයෙන් ඔබව නිදහස් කරන අතර පැරණි බ්‍රව්සර් මත නොගැලපේ.

මෙය නිවැරදි RFC822 අනුවාදයයි.

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

  var reValidEmail = new RegExp(sValidEmail);

  return reValidEmail.test(emailAddress);
}

ජාවාස්ක්‍රිප්ට් සාමාන්‍ය ප්‍රකාශනයකට ගැලපේ:

emailAddress.match( / some_regex /);

ඊමේල් සඳහා RFC22 නිත්‍ය ප්‍රකාශනයක් මෙන්න :

^((?>[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+\x20*|"((?=[\x01-\x7f])[^"\\]|\\[\x01-\x7f])*
"\x20*)*(?<angle><))?((?!\.)(?>\.?[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+)+|"((?=[\x01-\x
7f])[^"\\]|\\[\x01-\x7f])*")@(((?!-)[a-zA-Z\d\-]+(?<!-)\.)+[a-zA-Z]{2,}|\[(((?(?<
!\[)\.)(25[0-5]|2[0-4]\d|[01]?\d?\d)){4}|[a-zA-Z\d\-]*[a-zA-Z\d]:((?=[\x01-\x7f])
[^\\\[\]]|\\[\x01-\x7f])+)\])(?(angle)>)$

සියලුම විද්‍යුත් තැපැල් ලිපිනයන්හි 'at' (එනම් @) සංකේතය අඩංගු වේ. අවශ්‍ය කොන්දේසිය පරීක්ෂා කරන්න:

email.indexOf("@") > 0

වඩා සංකීර්ණ කිසිවක් සමඟ කරදර නොවන්න. ඊ-තැපෑලක් RFC- කෘතිමව වලංගු ද යන්න ඔබට හොඳින් තීරණය කළ හැකි වුවද, එය එය සැපයූ පුද්ගලයාට අයිති දැයි ඔබට නොකියයි. ඇත්තෙන්ම වැදගත් වන්නේ එයයි.

එය පරීක්ෂා කිරීම සඳහා, වලංගු පණිවිඩයක් යවන්න.

RFC වලට අනුකූලව විද්‍යුත් තැපැල් ලිපිනය නිවැරදිව වලංගු කිරීම එක්-ලයිනර් නිත්‍ය ප්‍රකාශනයකින් ලබා ගත හැකි දෙයක් නොවේ. PHP හි මා සොයාගත් හොඳම විසඳුම සහිත ලිපියක් වන්නේ වලංගු විද්‍යුත් තැපැල් ලිපිනයක් යනු කුමක්ද? . නිසැකවම, එය ජාවා වෙත වරාය කර ඇත. මම හිතන්නේ මෙම කාර්යය ජාවාස්ක්‍රිප්ට් හි ගෙනයාමට හා භාවිතා කිරීමට නොහැකි තරම් සංකීර්ණ ය. JavaScript / node.js port: https://www.npmjs.com/package/email-addresses .

හොඳ පුරුද්දක් වන්නේ සේවාදායකයාගේ දත්ත වලංගු කිරීම ය, නමුත් සේවාදායකයේ වලංගුභාවය දෙවරක් පරීක්ෂා කරන්න. මෙය මනසේ තබාගෙන, ඔබට නූලක් සේවාදායකයාගේ වලංගු ඊමේල් ලිපිනයක් සේ පෙනේ දැයි පරීක්ෂා කර සේවාදායකයේ දැඩි පරීක්ෂාව සිදු කළ හැකිය.

නූලක් වලංගු තැපැල් ලිපිනයක් සේ පෙනේදැයි පරීක්ෂා කිරීමට මා භාවිතා කරන ජාවාස්ක්‍රිප්ට් කාර්යය මෙන්න:

function looksLikeMail(str) {
    var lastAtPos = str.lastIndexOf('@');
    var lastDotPos = str.lastIndexOf('.');
    return (lastAtPos < lastDotPos && lastAtPos > 0 && str.indexOf('@@') == -1 && lastDotPos > 2 && (str.length - lastDotPos) > 2);
}

පැහැදිලි කිරීම:

• lastAtPos < lastDotPos: අවසන් වරට @පසුගිය පෙර විය යුතුය .සිට @හැකි සේවාදායකයේ නම (මම දන්න තරමින්) කොටසක් විය.

• lastAtPos > 0: අන්තිමයට පෙර යමක් (විද්‍යුත් තැපැල් පරිශීලක නාමය) තිබිය යුතුය @.

• str.indexOf('@@') == -1: @@ලිපිනයේ කිසිවක් නොතිබිය යුතුය . පවා නම් @ඊ-තැපැල් පරිශීලක නාමය අවසන් අක්ෂරය දර්ශණය වන විට, එය එසේ උපුටා කළ යුතු වේ "බව අතර වනු ඇති @අතර, අවසන් වරට @මෙම ලිපිනය.

• lastDotPos > 2: අවසාන තිතට පෙර අවම වශයෙන් අක්ෂර තුනක් වත් තිබිය යුතුය a@b.com.

• (str.length - lastDotPos) > 2: අන්තිම තිතට පසුව අක්ෂර දෙකක වසමක් සෑදීම සඳහා ප්‍රමාණවත් අක්ෂර තිබිය යුතුය. වරහන් අවශ්‍ය දැයි මට විශ්වාස නැත.

මෙය http://codesnippets.joyent.com/posts/show/1917 වෙතින් සොරකම් කරන ලදි

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

මෙය කරන්න:

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

මන්ද? එය RFC 2822 මත පදනම් වේ අතර එය සම්මත සියලුම විද්‍යුත් තැපැල් ලිපිනයන් පිළිපැදිය යුතුය. ඔබ "සරල" දෙයකට කරදර වන්නේ මන්දැයි මට විශ්වාස නැත ... ඔබ එය කෙසේ හෝ පිටපත් කර අලවන්නට යන්නේ;)

බොහෝ විට දත්ත සමුදායේ ඊමේල් ලිපින ගබඩා කිරීමේදී මම ඒවා කුඩා අකුරක් බවට පත් කරමි. ප්‍රායෝගිකව රීජෙක්ස් සාමාන්‍යයෙන් සිද්ධි සංවේදී නොවන ලෙස සලකුණු කළ හැකිය. එවැනි අවස්ථාවල මෙය තරමක් කෙටි වේ:

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

ජාවාස්ක්‍රිප්ට් හි එය භාවිතා කිරීම පිළිබඳ උදාහරණයක් මෙන්න ( iඅවසානයේ දී සංවේදී නොවන ධජය සමඟ).

var emailCheck=/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;
console.log( emailCheck.test('some.body@domain.co.uk') );

සටහන :
තාක්ෂණික සමහර ඊමේල් පෙර කොටසේ මිල කැඳවීම් ඇතුලත් කර ගත හැක @මේ ආකාරයටම තුල පැන චරිත සමග සංකේතය (ඔබගේ ඊ-තැපැල් ලිපිනය පරිශීලක පත්කරයි විය යුතු අතර, බයෙන් වගේ අඩංගු විය හැක එසේ @සහ "..."එය උපුටා ලියා තියෙන්නේ තාක් කල්). කිසිවෙකු මෙය කරන්නේ නැත! එය යල්පැන ඇත. නමුත්, එය සත්‍ය RFC 2822 ප්‍රමිතියට ඇතුළත් කර ඇති අතර මෙහි අතහැර දමා ඇත.

වැඩි විස්තර: http://www.regular-expressions.info/email.html

මෙම ගැටළුව විසඳීමට මම සැබවින්ම බලා සිටිමි. එබැවින් මම ඉහත ඊමේල් වලංගු කිරීමේ සාමාන්‍ය ප්‍රකාශනය වෙනස් කළෙමි

• මුල්
  /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/

• වෙනස් කරන ලදි
  /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+[^<>()\.,;:\s@\"]{2,})$/

විකිපීඩියා ඊමේල් ලිපිනයේ උදාහරණ යැවීමට .

මෙහි ප්‍රති result ලය ඔබට දැක ගත හැකිය .

ආදාන නූලක් වලංගු කිරීම සඳහා ඔබ සාමාන්‍ය ප්‍රකාශන භාවිතා නොකළ යුතුය. එය ඉතා සංකීර්ණ වන අතර සියලු අවස්ථා ආවරණය නොකරයි.

දැන් ඔබට ආවරණය කළ හැක්කේ 90% ක් පමණි, එවැනි දෙයක් ලියන්න:

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

ඔබට එය ශෝධනය කළ හැකිය. උදාහරණයක් ලෙස, 'aaa @' වලංගු වේ. නමුත් සමස්තයක් ලෙස ඔබ සාරාංශය ලබා ගනී. රැගෙන නොයන්න ... සරල 90% විසඳුමක් 100% විසඳුමට වඩා හොඳය.

ලෝකයට සරල කේතයක් අවශ්‍යයි ...

ඇතුළත් කළ විද්‍යුත් තැපැල් ලිපිනය වලංගු ද නැතිනම් HTML භාවිතා නොකරන්නේ දැයි පරීක්ෂා කරන්න.

<input type="email"/>

වලංගු කිරීම සඳහා ශ්‍රිතයක් ලිවීමේ අවශ්‍යතාවයක් නොමැත.

100% නිවැරදි ඊමේල් වලංගු කරන්නෙකු ලබා ගැනීම දුෂ්කර ය. එය නිවැරදි කර ගැනීමට ඇති එකම සැබෑ ක්‍රමය වන්නේ පරීක්ෂණ විද්‍යුත් තැපෑලක් ගිණුමට යැවීමයි. එයින් කියැවෙන්නේ ඔබට සාධාරණ දෙයක් ලැබෙනවාද යන්න තහවුරු කර ගත හැකි මූලික චෙක්පත් කිහිපයක් තිබේ.

වැඩිදියුණු කළ යුතු කරුණු කිහිපයක්:

අළුත් වෙනුවට RegExp, මේ ආකාරයට ලිවීමට උත්සාහ කරන්න regexp:

if (reg.test(/@/))

දෙවනුව, @ලකුණට පසුව යම් කාල පරිච්ඡේදයක් පැමිණේදැයි පරීක්ෂා කර බලා, කාල @හා කාල අතර අක්ෂර ඇති බවට වග බලා ගන්න .

මෙම ආකාරය වේ node එකක් මතම ඊට අදාල-validator එය:

/^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+@(?:(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-](?!\.)){0,61}[a-zA-Z0-9]?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9\-](?!$)){0,61}[a-zA-Z0-9]?)|(?:\[(?:(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\]))$/

ඔබගේ වලංගුකරණ ශ්‍රිතය තුළ මෙම කේතය භාවිතා කරන්න:

var emailID = document.forms["formName"]["form element id"].value;
atpos = emailID.indexOf("@");
dotpos = emailID.lastIndexOf(".");
if (atpos < 1 || ( dotpos - atpos < 2 ))
{
    alert("Please enter correct email ID")
    return false;
}

නැතිනම් ඔබට jQuery භාවිතා කළ හැකිය . ඇතුළත නීති අර්ථ දක්වන්නේ:

eMailId: {
    required: true,
    email: true
}

Regex update 2018! මේක උත්සාහ කරන්න

let val = 'email@domain.com';
if(/^[a-z0-9][a-z0-9-_\.]+@([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[a-z]{2,10})?$/.test(val)) {
   console.log('passed');
}

යතුරු ලියනය අනුවාදය සම්පූර්ණයි

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

වැඩි විස්තර https://git.io/vhEfc

TLD හි පැවැත්ම පරීක්ෂා නොකරන විසඳුමක් අසම්පූර්ණයි.

මෙම ප්‍රශ්න සඳහා සෑම පිළිතුරක්ම පාහේ යෝජනා කරන්නේ ඊමේල් ලිපින වලංගු කිරීම සඳහා රීජෙක්ස් භාවිතා කිරීමයි. මම හිතන්නේ රෙජෙක්ස් හොඳ වන්නේ වලංගු වලංගු භාවයකට පමණි. ඊමේල් ලිපින වලංගු කිරීම සත්‍ය වශයෙන්ම වෙනම ගැටළු දෙකක් බව පෙනේ:

1- විද්‍යුත් තැපැල් ආකෘතිය වලංගු කිරීම: ආර්එෆ්සී 5322 හි ඊමේල් ආකෘතිය හා රටාව සමඟ විද්‍යුත් තැපෑල අනුකූලද යන්න සහ ටීඑල්ඩී සැබවින්ම පවතින්නේද යන්න තහවුරු කර ගැනීම. සියලුම වලංගු TLD ලැයිස්තුවක් මෙහි සොයාගත හැකිය .

උදාහරණයක් ලෙස, ලිපිනය example@example.cccරීජෙක්ස් පසුකර ගියද , එය වලංගු විද්‍යුත් තැපෑලක් නොවේ, මන්ද cccඑය IANA විසින් ඉහළ මට්ටමේ වසමක් නොවන බැවිනි .

: 2- වග ඇත්තටම ඊ-තැපැල් පවතී කිරීම මේ දේ සඳහා, එකම විකල්පය වන්නේ පරිශීලකයන් ඊ-තැපැල් යැවීමට .

ඊමේල් ලිපිනය වලංගු කිරීම සඳහා රීජෙක්ස්

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

ඊමේල් ලිපින වලංගු කිරීම සඳහා සාමාන්‍ය ප්‍රකාශන භාවිතා කිරීම පිළිබඳ ඉතා හොඳ සාකච්ඡාවක් මෙන්න; " නිත්‍ය ප්‍රකාශන වලංගු කරන විද්‍යුත් තැපැල් ලිපිනය සංසන්දනය කිරීම "

යොමු අරමුණු සඳහා ජාවාස්ක්‍රිප්ට් අනුකූල වන වත්මන් ඉහළ ප්‍රකාශනය මෙන්න:

/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+)*\.(aero|arpa|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org|pro|travel|mobi|[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i

පෙනෙන විදිහට, එය එයයි:

/^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+[a-z]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$/i

Http://fightingforalostcause.net/misc/2006/compare-email-regex.php වෙතින් ලබා ගත්ඔක්තෝබර් 1 '10 දින ඇත.

එහෙත්, ඇත්ත වශයෙන්ම, එය ජාත්‍යන්තරකරණය නොසලකා හැරේ.

ඊට වෙනස්ව ලේනුන්ට , මෙන්න සංකීර්ණ විසඳුමක්, නමුත් එය ඊමේල් නිසි ලෙස වලංගු කිරීමේ ප්‍රබල කාර්යයක් කරයි:

function isEmail(email) { 
    return /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i.test(email);
} 

එසේ භාවිතා කරන්න:

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

මගේ දැනුම නිත්‍ය ප්‍රකාශන එතරම් හොඳ නැත. ඒ නිසාම මම සාමාන්‍ය සින්ටැක්ස් එක සරල නිත්‍ය ප්‍රකාශනයකින් පළමුව පරීක්ෂා කර පසුව වෙනත් කාර්යයන් සමඟ වඩාත් නිශ්චිත විකල්ප පරීක්ෂා කරමි. මෙය හොඳම තාක්ෂණික විසඳුම නොවිය හැකි නමුත් මේ ආකාරයෙන් මම වඩාත් නම්‍යශීලී හා වේගවත් වෙමි.

මට හමු වූ වඩාත් සුලභ දෝෂ වන්නේ අවකාශයන් (විශේෂයෙන් ආරම්භයේ සහ අවසානයේ) සහ ඉඳහිට ද්විත්ව තිතක්.

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

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

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

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

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

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

සියලුම ඊමේල් ලිපින පරීක්ෂණ අවස්ථා සමත් ජේඑස් හි රීජෙක්ස් එකක් මම සොයමින් සිටියෙමි:

• email@example.com වලංගු ඊමේල්

• firstname.lastname@example.com ලිපින ක්ෂේත්‍රයේ තිතක් ඊමේල් හි අඩංගු වේ

• email@subdomain.example.com ඊමේල් හි උප ඩොමේන් සමඟ තිතක් අඩංගු වේ

• firstname+lastname@example.com ප්ලස් ලකුණ වලංගු චරිතයක් ලෙස සැලකේ

• email@192.0.2.123 වසම වලංගු IP ලිපිනයකි

• email@[192.0.2.123] IP ලිපිනය වටා ඇති වර්ග වරහන වලංගු යැයි සැලකේ

• “email”@example.com විද්‍යුත් තැපෑල වටා ඇති මිල ගණන් වලංගු යැයි සැලකේ

• 1234567890@example.com ලිපිනයේ ඉලක්කම් වලංගු වේ

• email@domain-one.example ඩොමේන් නාමයේ ඉරක් වලංගු වේ

• _______@example.com ලිපින ක්ෂේත්‍රයෙහි යටි ඉරි වලංගු වේ

• email@example.name .name වලංගු ඉහළ මට්ටමේ වසම් නාමයකි

• email@example.co.jp ඉහළ මට්ටමේ ඩොමේන් නාමය වලංගු යැයි සලකනු ලැබේ (භාවිතා කිරීම co.jp මෙහි උදාහරණයක් ලෙස )

• firstname-lastname@example.com ලිපින ක්ෂේත්‍රයේ ඉරක් වලංගු වේ

මෙන්න අපි යනවා :

http://regexr.com/3f07j

හෝ රීජෙක්ස්:

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

ASP.NET MVC තුළ මයික්‍රොසොෆ්ට් විසින් සපයනු ලබන නිත්‍ය ප්‍රකාශනය වේ

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

මා මෙහි පළ කරන්නේ එය දෝෂ සහිත අවස්ථාවක - එය සැමවිටම මගේ අවශ්‍යතා සඳහා පරිපූර්ණ වූවත්.