Cách xác thực địa chỉ email trong JavaScript

Có một biểu thức chính quy để xác thực một địa chỉ email trong JavaScript không?

Sử dụng các biểu thức thông thường có lẽ là cách tốt nhất. Bạn có thể thấy một loạt các bài kiểm tra ở đây (lấy từ crom )

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

Đây là ví dụ về expresion thường xuyên chấp nhận unicode:

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

Nhưng hãy nhớ rằng người ta không nên chỉ dựa vào xác thực JavaScript. JavaScript có thể dễ dàng bị vô hiệu hóa. Điều này cũng nên được xác nhận ở phía máy chủ.

Đây là một ví dụ về hành động trên:

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>

Tôi đã sửa đổi một chút câu trả lời của Jaymon cho những người muốn xác nhận thực sự đơn giản dưới dạng:

anystring@anystring.anystring

Biểu thức chính quy:

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

Hàm JavaScript ví dụ:

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

Để hoàn thiện, ở đây bạn có một biểu thức chính quy tuân thủ RFC 2822 khác

Tiêu chuẩn chính thức được gọi là RFC 2822 . Nó mô tả cú pháp mà các địa chỉ email hợp lệ phải tuân thủ. Bạn có thể ( nhưng bạn không nên - đọc tiếp ) thực hiện nó với biểu thức chính quy này:

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

(...) Chúng tôi nhận được triển khai RFC 2822 thực tế hơn nếu chúng tôi bỏ qua cú pháp bằng dấu ngoặc kép và dấu ngoặc vuông. Nó vẫn sẽ phù hợp với 99,99% của tất cả các địa chỉ email trong sử dụng thực tế ngày hôm nay.

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

Một thay đổi nữa mà bạn có thể thực hiện là cho phép bất kỳ tên miền cấp cao nhất gồm hai chữ cái mã quốc gia và chỉ các tên miền cấp cao chung cụ thể. Regex này lọc địa chỉ email giả như thế nàoasdf@adsf.adsf . Bạn sẽ cần cập nhật nó khi các tên miền cấp cao mới được thêm vào .

[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

Vì vậy, ngay cả khi tuân theo các tiêu chuẩn chính thức, vẫn có sự đánh đổi được thực hiện. Đừng mù quáng sao chép các biểu thức thông thường từ các thư viện trực tuyến hoặc các diễn đàn thảo luận. Luôn kiểm tra chúng trên dữ liệu của riêng bạn và với các ứng dụng của riêng bạn.

_{Nhấn mạnh mỏ}

Wow, có rất nhiều phức tạp ở đây. Nếu tất cả những gì bạn muốn làm chỉ là bắt những lỗi cú pháp rõ ràng nhất, tôi sẽ làm một cái gì đó như thế này:

^\S+@\S+$

Nó thường nắm bắt các lỗi rõ ràng nhất mà người dùng mắc phải và đảm bảo rằng biểu mẫu hầu hết là đúng, đó là tất cả những gì về xác thực JavaScript.

Có điều gì đó bạn phải hiểu lần thứ hai bạn quyết định sử dụng biểu thức chính quy để xác thực email: Có lẽ đó không phải là một ý tưởng hay . Một khi bạn đã đồng ý với điều đó, có rất nhiều triển khai ngoài kia có thể giúp bạn đi được nửa đường, bài viết này tổng hợp chúng một cách độc đáo.

Tuy nhiên, trong ngắn hạn, cách duy nhất để hoàn toàn chắc chắn, tích cực chắc chắn rằng những gì người dùng nhập vào thực tế là một email là thực sự gửi email và xem điều gì sẽ xảy ra. Ngoài ra, tất cả chỉ là phỏng đoán.

Bản thân HTML5 đã xác thực email. Nếu trình duyệt của bạn hỗ trợ HTML5 thì bạn có thể sử dụng mã sau đây.

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

jsFiddleliên kết

Từ thông số HTML5 :

Một địa chỉ e-mail hợp lệ là một chuỗi phù hợp với emailsản xuất của ABNF sau, bộ ký tự cho đó là 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 >

Yêu cầu này là vi phạm cố ý RFC 5322, định nghĩa cú pháp cho các địa chỉ email đồng thời quá nghiêm ngặt (trước ký tự "@"), quá mơ hồ (sau ký tự "@") và quá lỏng lẻo (cho phép nhận xét , các ký tự khoảng trắng và các chuỗi được trích dẫn theo cách cư xử xa lạ với hầu hết người dùng) sẽ được sử dụng thực tế ở đây.

Biểu thức chính quy tương thích với JavaScript và Perl sau đây là cách triển khai định nghĩa trên.

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

Tôi đã tìm thấy đây là giải pháp tốt nhất:

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

Nó cho phép các định dạng sau:

1. beautifulandsimple@example.com
2. Very.common@example.com
3. dùng một lần.style.email.with + symbol@example.com
4. other.email-with-dash@example.com
9. #!$%&'*+-/=?ucci_` nbspl|~@example.org
6. "() []:,; @ \\\"! # $% & '* + - / =? ^ _ `{} | ~ .a "@ example.org
7. "" @ example.org (khoảng trắng giữa các trích dẫn)
8. üñîçøðé@example.com (Ký tự Unicode trong phần cục bộ)
9. üñîçøðé@üñîçøðé.com (Ký tự Unicode trong phần tên miền)
10. Pelé@example.com (tiếng Latin)
11. δ κ π Greek Greek Greek
12. 我 買 @. 香港 (tiếng Trung)
13. 甲 斐 @ 川. 日本 (tiếng Nhật)
14. чебурашкакаяяяяяяяя

Nó rõ ràng linh hoạt và cho phép các nhân vật quốc tế quan trọng, trong khi vẫn thực thi định dạng any@anything.anything cơ bản. Nó sẽ chặn các không gian được RFC cho phép về mặt kỹ thuật, nhưng chúng hiếm đến nỗi tôi rất vui khi làm điều này.

Trong các trình duyệt hiện đại, bạn có thể xây dựng dựa trên câu trả lời của @ Sushil với JavaScript thuần túy và 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);
}

Tôi đã đưa ra một ví dụ trong fiddle http://jsfiddle.net/boldewyn/2b6d5/ . Kết hợp với phát hiện tính năng và xác thực xương cốt từ Câu trả lời của Squirtle , nó giải phóng bạn khỏi cuộc thảm sát biểu hiện thông thường và không làm phiền trên các trình duyệt cũ.

Đây là phiên bản RFC822 chính xác.

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 có thể khớp với biểu thức chính quy:

emailAddress.match( / some_regex /);

Đây là biểu thức chính quy RFC22 cho email:

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

Tất cả các địa chỉ email đều chứa ký hiệu 'at' (tức là @). Kiểm tra điều kiện cần thiết:

email.indexOf("@") > 0

Đừng bận tâm với bất cứ điều gì phức tạp hơn. Ngay cả khi bạn có thể xác định một cách hoàn hảo liệu email có hợp lệ về mặt cú pháp hay không, điều đó sẽ không cho bạn biết liệu nó có thuộc về người đã cung cấp hay không. Đó là những gì thực sự quan trọng.

Để kiểm tra điều đó, gửi tin nhắn xác nhận.

Xác nhận chính xác địa chỉ email tuân thủ RFC không phải là điều có thể đạt được với biểu thức chính quy một lớp. Một bài viết với giải pháp tốt nhất tôi tìm thấy trong PHP là Địa chỉ email hợp lệ là gì? . Rõ ràng, nó đã được chuyển sang Java. Tôi nghĩ rằng chức năng này quá phức tạp để được chuyển và sử dụng trong JavaScript. Cổng JavaScript / node.js: https://www.npmjs.com/package/email-addresses .

Một thực hành tốt là xác thực dữ liệu của bạn trên máy khách, nhưng kiểm tra kỹ xác thực trên máy chủ. Với suy nghĩ này, bạn chỉ cần kiểm tra xem một chuỗi có giống địa chỉ email hợp lệ trên máy khách hay không và thực hiện kiểm tra nghiêm ngặt trên máy chủ.

Đây là hàm JavaScript tôi sử dụng để kiểm tra xem một chuỗi có giống địa chỉ thư hợp lệ không:

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

Giải trình:

• lastAtPos < lastDotPos: Last @nên là trước cuối cùng .vì @không thể là một phần của tên máy chủ (theo như tôi biết).

• lastAtPos > 0: Cần có một cái gì đó (tên người dùng email) trước cuối cùng @.

• str.indexOf('@@') == -1: Không nên có @@trong địa chỉ. Ngay cả khi @xuất hiện dưới dạng ký tự cuối cùng trong tên người dùng email, nó phải được trích dẫn vì vậy "sẽ nằm giữa ký tự đó @và cuối cùng @trong địa chỉ.

• lastDotPos > 2: Nên có ít nhất ba ký tự trước dấu chấm cuối cùng a@b.com.

• (str.length - lastDotPos) > 2: Cần có đủ các ký tự sau dấu chấm cuối cùng để tạo thành một miền có hai ký tự. Tôi không chắc chắn nếu dấu ngoặc là cần thiết.

Điều này đã bị đánh cắp từ 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;}

Làm cái này:

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

Tại sao? Nó dựa trên RFC 2822 , đây là một địa chỉ email TẤT CẢ tiêu chuẩn PHẢI tuân thủ. Và tôi không chắc tại sao bạn lại bận tâm với thứ gì đó "đơn giản" hơn ... dù sao bạn cũng sẽ sao chép và dán nó;)

Thông thường khi lưu trữ địa chỉ email trong cơ sở dữ liệu, tôi đặt chúng thành chữ thường và trong thực tế, regex thường có thể được đánh dấu không phân biệt chữ hoa chữ thường. Trong những trường hợp này, nó hơi ngắn hơn:

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

Đây là một ví dụ về nó đang được sử dụng trong JavaScript (với cờ không phân biệt chữ hoa chữ thường iở cuố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') );

Lưu ý :
Về mặt kỹ thuật, một số email có thể bao gồm dấu ngoặc kép trong phần trước @biểu tượng có ký tự thoát bên trong dấu ngoặc kép (vì vậy người dùng email của bạn có thể đáng ghét và chứa nội dung như @và "..."miễn là nó được viết trong dấu ngoặc kép). NOBODY LÀM ĐIỀU NÀY! Nó đã lỗi thời. Nhưng, nó được bao gồm trong tiêu chuẩn RFC 2822 thực sự , và được bỏ qua ở đây.

Thêm thông tin: http://www.THER-expressions.info/email.html

Tôi thực sự mong muốn giải quyết vấn đề này. Vì vậy, tôi đã sửa đổi biểu thức xác thực email thường xuyên ở trên

• Nguyên
  /^(([^<>()\[\]\\.,;:\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ửa đổi
  /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+[^<>()\.,;:\s@\"]{2,})$/

để vượt qua các ví dụ trong Địa chỉ Email Wikipedia .

Và bạn có thể thấy kết quả ở đây .

Bạn không nên sử dụng các biểu thức thông thường để xác thực chuỗi đầu vào để kiểm tra xem đó có phải là email không. Nó quá phức tạp và sẽ không bao gồm tất cả các trường hợp.

Bây giờ vì bạn chỉ có thể bao gồm 90% các trường hợp, hãy viết một cái gì đó như:

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

Bạn có thể tinh chỉnh nó. Chẳng hạn, 'aaa @' là hợp lệ. Nhưng nhìn chung bạn có được ý chính. Và đừng mang đi ... Một giải pháp 90% đơn giản tốt hơn giải pháp 100% không hiệu quả.

Thế giới cần mã đơn giản hơn ...

Chỉ cần kiểm tra xem địa chỉ email đã nhập có hợp lệ hay không sử dụng HTML.

<input type="email"/>

Không cần phải viết một hàm để xác nhận.

Thật khó để có được một trình xác nhận email chính xác 100%. Cách thực sự duy nhất để làm cho nó chính xác là gửi email kiểm tra đến tài khoản. Điều đó nói rằng, có một vài kiểm tra cơ bản có thể giúp đảm bảo rằng bạn đang nhận được một cái gì đó hợp lý.

Một số điều cần cải thiện:

Thay vì mới RegExp, chỉ cần thử viết regexpra như thế này:

if (reg.test(/@/))

Thứ hai, kiểm tra để đảm bảo rằng một khoảng thời gian xuất hiện sau @dấu hiệu và đảm bảo rằng có các ký tự giữa @s và dấu chấm.

Đây là cách trình xác nhận nút thực hiện:

/^(?:[\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])\]))$/

Sử dụng mã này trong chức năng trình xác nhận của bạn:

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

Khác bạn có thể sử dụng jQuery . Quy tắc bên trong xác định:

eMailId: {
    required: true,
    email: true
}

Cập nhật Regex 2018! thử cái này

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

hoàn thành phiên bản 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);

thêm thông tin https://git.io/vhEfc

Một giải pháp không kiểm tra sự tồn tại của TLD là không đầy đủ.

Hầu như tất cả các câu trả lời cho câu hỏi này đề nghị sử dụng Regex để xác thực địa chỉ email. Tôi nghĩ Regex chỉ tốt cho việc xác nhận thô sơ. Có vẻ như việc kiểm tra xác thực địa chỉ email thực sự là hai vấn đề riêng biệt:

1- Xác thực định dạng email: Đảm bảo nếu email tuân thủ định dạng và mẫu email trong RFC 5322 và nếu TLD thực sự tồn tại. Một danh sách tất cả các TLD hợp lệ có thể được tìm thấy ở đây .

Ví dụ: mặc dù địa chỉ example@example.cccsẽ vượt qua regex, nhưng đó không phải là một email hợp lệ, bởi vì cccIANA không phải là một tên miền cấp cao nhất.

2- Đảm bảo email thực sự tồn tại: Để thực hiện việc này, tùy chọn duy nhất là gửi email cho người dùng .

Regex để xác nhận địa chỉ email

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

Đây là một cuộc thảo luận rất tốt về việc sử dụng các biểu thức thông thường để xác nhận địa chỉ email; " So sánh địa chỉ email xác thực biểu thức chính quy "

Đây là biểu thức hàng đầu hiện tại, tương thích với JavaScript, cho mục đích tham khảo:

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

Rõ ràng, đó là:

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

Lấy từ http://fightingforalostcause.net/misc/2006/compare-email-regex.php vào ngày 1 tháng 10.

Nhưng, tất nhiên, đó là bỏ qua quốc tế hóa.

Ngược lại với squirtle , đây là một giải pháp phức tạp, nhưng nó thực sự rất tốt trong việc xác nhận email đúng cách:

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

Sử dụng như vậy:

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

Kiến thức của tôi về biểu thức chính quy là không tốt. Đó là lý do tại sao tôi kiểm tra cú pháp chung bằng một biểu thức chính quy đơn giản trước và kiểm tra các tùy chọn cụ thể hơn với các hàm khác sau đó. Đây có thể không phải là giải pháp kỹ thuật tốt nhất, nhưng theo cách này tôi linh hoạt hơn và nhanh hơn.

Các lỗi phổ biến nhất mà tôi gặp phải là khoảng trắng (đặc biệt là ở đầu và cuối) và đôi khi là một dấu chấm kép.

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>

Tôi đang tìm kiếm một Regex trong JS vượt qua tất cả các trường hợp kiểm tra Địa chỉ Email:

• email@example.com Email hợp lệ

• firstname.lastname@example.com Email chứa dấu chấm trong trường địa chỉ

• email@subdomain.example.com Email chứa dấu chấm với tên miền phụ

• firstname+lastname@example.com Dấu cộng được coi là ký tự hợp lệ

• email@192.0.2.123 Tên miền là địa chỉ IP hợp lệ

• email@[192.0.2.123] Dấu ngoặc vuông quanh địa chỉ IP được coi là hợp lệ

• “email”@example.com Báo giá xung quanh email được coi là hợp lệ

• 1234567890@example.com Chữ số trong địa chỉ là hợp lệ

• email@domain-one.example Dấu gạch ngang trong tên miền là hợp lệ

• _______@example.com Gạch dưới trong trường địa chỉ là hợp lệ

• email@example.name .name là tên miền cấp cao nhất hợp lệ

• email@example.co.jpDấu chấm trong tên miền cấp cao nhất cũng được coi là hợp lệ (sử dụng co.jpví dụ ở đây)

• firstname-lastname@example.com Dấu gạch ngang trong trường địa chỉ là hợp lệ

Ở đây chúng tôi đi:

http://regexr.com/3f07j

HOẶC regex:

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

Biểu thức chính quy được cung cấp bởi Microsoft trong ASP.NET MVC là

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

Mà tôi đăng ở đây trong trường hợp nó còn thiếu sót - mặc dù nó luôn hoàn hảo cho nhu cầu của tôi.