วิธีตรวจสอบที่อยู่อีเมลใน JavaScript

มีการแสดงออกปกติเพื่อตรวจสอบที่อยู่อีเมลใน 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());
}

นี่คือตัวอย่างของการ expresion ปกติที่ยอมรับ unicode:

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

แต่โปรดจำไว้ว่าเราไม่ควรพึ่งพาการตรวจสอบ JavaScript เท่านั้น สามารถปิดใช้งาน 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(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>

ฉันได้แก้ไขคำตอบของ Jaymonเล็กน้อยสำหรับผู้ที่ต้องการการตรวจสอบที่ง่ายจริงๆในรูปแบบของ:

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

เพื่อความสมบูรณ์ที่นี่คุณมี regex ที่สอดคล้องกับ 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])?

การเปลี่ยนแปลงเพิ่มเติมที่คุณสามารถทำได้คืออนุญาตโดเมนระดับบนสุดของรหัสประเทศสองตัวอักษรและเฉพาะโดเมนระดับบนสุดทั่วไปเท่านั้น regex 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+$

มันมักจะจับข้อผิดพลาดที่ชัดเจนที่สุดที่ผู้ใช้ทำและยืนยันว่าแบบฟอร์มส่วนใหญ่ถูกต้องซึ่งเป็นสิ่งที่การตรวจสอบ JavaScript เป็นเรื่องเกี่ยวกับ

มีบางอย่างที่คุณต้องเข้าใจที่สองคุณตัดสินใจที่จะใช้การแสดงออกปกติไปยังอีเมลตรวจสอบเป็น: มันอาจจะไม่ได้เป็นความคิดที่ดี เมื่อคุณเห็นด้วยกับสิ่งนั้นมีการใช้งานมากมายที่คุณสามารถได้รับครึ่งทางบทความนี้จะสรุปพวกเขาอย่างดี

อย่างไรก็ตามในระยะสั้นวิธีเดียวที่จะมั่นใจได้อย่างแน่นอนในเชิงบวกว่าสิ่งที่ผู้ใช้ป้อนในความเป็นจริงอีเมลคือการส่งอีเมลจริงและดูสิ่งที่เกิดขึ้น นอกจากนั้นมันก็แค่เดา

HTML5 เองมีการตรวจสอบอีเมล หากเบราว์เซอร์ของคุณรองรับ HTML5 คุณสามารถใช้รหัสต่อไปนี้

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

ลิงก์jsFiddle

จากสเป็ค HTML5 :

ที่อยู่อีเมลที่ถูกต้องคือสตริงที่ตรงกับการemailผลิตของ ABNF ต่อไปนี้ซึ่งเป็นชุดอักขระซึ่งเป็น Unicode

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 >

ข้อกำหนดนี้เป็นการละเมิดโดยเจตนาของ RFC 5322 ซึ่งกำหนดไวยากรณ์สำหรับที่อยู่อีเมลที่เข้มงวดเกินไปพร้อมกัน (ก่อนอักขระ "@") คลุมเครือเกินไป (หลังอักขระ "@") และหละหลวมเกินไป (อนุญาตให้ข้อคิดเห็น อักขระช่องว่างและสตริงที่อ้างอิงในลักษณะที่ไม่คุ้นเคยกับผู้ใช้ส่วนใหญ่) เพื่อการใช้งานจริงที่นี่

นิพจน์ทั่วไปที่เข้ากันได้กับ JavaScript และ Perl ต่อไปนี้คือการนำไปใช้งานของคำนิยามข้างต้น

/^[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. prettyandsimple@example.com
2. very.common@example.com
3. Disposable.style.email.with+symbol@example.com
4. other.email-with-dash@example.com
9. #!$%&'*+-/=?^_`{}|~@example.org
6. "() []:,; @ \\\"! # $% & '* + - / =? ^ _ `{} | ~ .a "@ example.org
7. "" @ example.org (เว้นวรรคระหว่างเครื่องหมายคำพูด)
8. üñîçøðé@example.com (อักขระ Unicode ในส่วนท้องถิ่น)
9. üñîçøðé@üñîçøðé.com (อักขระ Unicode ในส่วนของโดเมน)
10. Pelé@example.com (ละติน)
11. δοκιμή@παράδειγμα.δοκιμή (กรีก)
12. 我買 @ 屋企. 香港 (ภาษาจีน)
13. 甲斐 @ 黒川. 日本 (ภาษาญี่ปุ่น)
14. чебурашка@ящик-с-апельсинами.рф (Cyrillic)

เห็นได้ชัดว่ามีความหลากหลายและช่วยให้ตัวละครนานาชาติที่สำคัญในขณะที่ยังคงบังคับใช้รูปแบบพื้นฐานอะไรก็ได้ @anything.anything มันจะปิดกั้นช่องว่างที่ RFC อนุญาตทางเทคนิค แต่พวกมันหายากมากที่ฉันยินดีที่จะทำเช่นนี้

ในเบราว์เซอร์สมัยใหม่คุณสามารถสร้างคำตอบของ @ Sushil ได้ด้วย JavaScript และDOM :

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/ เมื่อรวมกับการตรวจจับคุณสมบัติและการตรวจสอบความถูกต้องของกระดูกจากคำตอบของ Squirtleมันจะปลดปล่อยคุณจากการสังหารหมู่ที่แสดงออกเป็นประจำและไม่รบกวนกับเบราว์เซอร์รุ่นเก่า

นี่คือรุ่น 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);
}

JavaScript สามารถจับคู่นิพจน์ทั่วไป:

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' (ie @) ทดสอบเงื่อนไขที่จำเป็น:

email.indexOf("@") > 0

อย่ากังวลกับสิ่งที่ซับซ้อนกว่านี้ แม้ว่าคุณจะสามารถระบุได้อย่างสมบูรณ์ว่าอีเมลนั้นมีผล RFC-syntactically หรือไม่นั้นจะไม่บอกคุณว่ามันเป็นของผู้ให้บริการหรือไม่ นั่นคือสิ่งที่สำคัญจริงๆ

เพื่อทดสอบว่าส่งข้อความตรวจสอบ

การตรวจสอบความถูกต้องของที่อยู่อีเมลตาม RFC ไม่ใช่สิ่งที่สามารถเกิดขึ้นได้ด้วยนิพจน์ทั่วไปแบบซับในหนึ่งบรรทัด บทความที่มีทางออกที่ดีที่สุดที่ฉันพบใน PHP คือที่อยู่อีเมลที่ถูกต้องคืออะไร . เห็นได้ชัดว่ามันได้รับการแจ้งความกับ Java ฉันคิดว่าฟังก์ชั่นนั้นซับซ้อนเกินกว่าที่จะรับส่งและใช้งานใน JavaScript ได้ JavaScript / พอร์ต Node.js: https://www.npmjs.com/package/email-addresses

แนวปฏิบัติที่ดีคือการตรวจสอบความถูกต้องของข้อมูลของคุณบนไคลเอ็นต์ แต่ให้ตรวจสอบความถูกต้องอีกครั้งบนเซิร์ฟเวอร์ เมื่อคำนึงถึงสิ่งนี้คุณสามารถตรวจสอบได้ว่าสตริงดูเหมือนที่อยู่อีเมลที่ถูกต้องบนไคลเอนต์และทำการตรวจสอบอย่างเข้มงวดบนเซิร์ฟเวอร์

นี่คือฟังก์ชัน JavaScript ที่ฉันใช้ตรวจสอบว่าสตริงดูเหมือนที่อยู่อีเมลที่ถูกต้องหรือไม่:

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ซึ่งเป็นที่อยู่อีเมลมาตรฐานทั้งหมดต้องเป็นไปตาม และฉันไม่แน่ใจว่าทำไมคุณถึงต้องใส่ใจกับบางสิ่งที่ "เรียบง่าย" ... คุณจะคัดลอกและวางต่อไป

บ่อยครั้งเมื่อจัดเก็บที่อยู่อีเมลในฐานข้อมูลฉันทำให้ที่นี่เป็นตัวพิมพ์เล็กและในทางปฏิบัติ regexs สามารถทำเครื่องหมายตัวพิมพ์เล็กและตัวพิมพ์เล็กได้ ในกรณีเหล่านี้จะสั้นกว่าเล็กน้อย:

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

นี่คือตัวอย่างของการใช้งานใน JavaScript (ที่มีการตั้งค่าสถานะ insensitive case 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,})$/

ที่จะผ่านตัวอย่างในวิกิพีเดียที่อยู่อีเมล

และคุณสามารถเห็นผลในที่นี่

คุณไม่ควรใช้นิพจน์ทั่วไปเพื่อตรวจสอบความถูกต้องของสตริงอินพุตเพื่อตรวจสอบว่าเป็นอีเมลหรือไม่ มันซับซ้อนเกินไปและจะไม่ครอบคลุมทุกกรณี

ขณะนี้เนื่องจากคุณสามารถครอบคลุมเฉพาะ 90% ของกรณีเขียนสิ่งที่ชอบ:

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

คุณสามารถปรับแต่งได้ ตัวอย่างเช่น 'aaa @' ถูกต้อง แต่โดยรวมแล้วคุณจะได้รับส่วนสำคัญ และอย่าหลงทาง ... โซลูชัน 90% แบบง่ายดีกว่าโซลูชัน 100% ที่ใช้งานไม่ได้

โลกต้องการรหัสที่ง่ายกว่า ...

เพียงตรวจสอบว่าที่อยู่อีเมลที่ป้อนนั้นถูกต้องหรือไม่ใช้ HTML

<input type="email"/>

ไม่จำเป็นต้องเขียนฟังก์ชันเพื่อตรวจสอบความถูกต้อง

มันยากที่จะได้รับการตรวจสอบอีเมลที่ถูกต้อง 100% วิธีการแก้ไขที่ถูกต้องคือการส่งอีเมลทดสอบไปยังบัญชี ที่กล่าวว่ามีการตรวจสอบขั้นพื้นฐานเล็กน้อยที่สามารถช่วยตรวจสอบให้แน่ใจว่าคุณได้รับสิ่งที่สมเหตุสมผล

บางสิ่งที่ต้องปรับปรุง:

แทนที่จะเป็นเรื่องใหม่RegExpลองเขียนสิ่งต่อregexpไปนี้:

if (reg.test(/@/))

ประการที่สองตรวจสอบเพื่อให้แน่ใจว่ามีจุดที่มาหลัง@เครื่องหมายและตรวจสอบให้แน่ใจว่ามีตัวอักษรระหว่าง@s และจุด

นี่คือวิธีตรวจสอบความถูกต้องของโหนด :

/^(?:[\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 อัพเดทปี 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');
}

เวอร์ชันของ typscript สมบูรณ์แล้ว

//
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 มีอยู่ไม่สมบูรณ์

คำตอบสำหรับคำถามนี้เกือบทั้งหมดแนะนำให้ใช้ Regex เพื่อตรวจสอบที่อยู่อีเมล ฉันคิดว่า Regex นั้นดีสำหรับการตรวจสอบเบื้องต้นเท่านั้น ดูเหมือนว่าการตรวจสอบความถูกต้องของที่อยู่อีเมลเป็นปัญหาที่แยกกันสองอย่าง:

1- การตรวจสอบความถูกต้องของรูปแบบอีเมล:ตรวจสอบให้แน่ใจว่าอีเมลเป็นไปตามรูปแบบและรูปแบบของอีเมลใน RFC 5322 และหาก TLD มีอยู่จริง รายการ TLDs ที่ถูกต้องทั้งหมดสามารถพบได้ที่นี่

ตัวอย่างเช่นแม้ว่าที่อยู่example@example.cccจะผ่าน regex แต่ไม่ใช่อีเมลที่ถูกต้องเนื่องจากcccไม่ใช่ IANA โดเมนระดับบนสุด

2- การทำให้แน่ใจว่าอีเมลที่มีอยู่จริง:สำหรับการทำเช่นนี้เป็นตัวเลือกเดียวคือการส่งอีเมลผู้ใช้

Regex สำหรับการตรวจสอบที่อยู่อีเมล

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

นี่คือการสนทนาที่ดีมากเกี่ยวกับการใช้นิพจน์ทั่วไปเพื่อตรวจสอบที่อยู่อีเมล "การเปรียบเทียบที่อยู่อีเมลเพื่อตรวจสอบนิพจน์ปกติ "

นี่คือนิพจน์ยอดนิยมปัจจุบันที่เข้ากันได้กับ JavaScript เพื่อการอ้างอิง:

/^[-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 ต.ค. 53

แต่แน่นอนว่าไม่สนใจความเป็นสากล

ตรงกันข้ามกับsquirtleนี่เป็นวิธีการแก้ปัญหาที่ซับซ้อน แต่มันก็เป็นงานที่ดีในการตรวจสอบอีเมลที่ถูกต้อง:

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>

ฉันกำลังมองหา Regex ใน JS ที่ผ่านทุกกรณีทดสอบที่อยู่อีเมล:

• 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.jpDot ในชื่อโดเมนระดับบนยังถือว่าถูกต้อง (ใช้co.jpเป็นตัวอย่างที่นี่)

• firstname-lastname@example.com ช่องที่อยู่ในช่องนั้นถูกต้อง

ไปเลย :

http://regexr.com/3f07j

หรือ regex:

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

นิพจน์ปกติที่จัดทำโดย Microsoft ภายในASP.NET MVCคือ

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

ซึ่งฉันโพสต์ที่นี่ในกรณีที่มีข้อบกพร่อง - แม้ว่ามันจะสมบูรณ์แบบสำหรับความต้องการของฉัน