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

유니 코드를 허용하는 정규 표현식의 예는 다음과 같습니다.

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

완전성을 위해 여기에 다른 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])?

추가로 변경할 수있는 것은 2 문자 국가 코드 최상위 도메인과 특정 일반 최상위 도메인 만 허용하는 것입니다. 이 정규식은과 같은 더미 이메일 주소를 필터링합니다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의 생산을위한 문자 세트는 유니 코드입니다.

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 (로컬 부분의 유니 코드 문자)
9. üñîçøðé@üñîçøðé.com (도메인 부분의 유니 코드 문자)
10. Pelé@example.com (라틴)
11. δοκιμή@παράδειγμα.δοκιμή (그리스어)
12. 我 買 @ 屋企. 香港 (중국어)
13. 甲 斐 @ 黒 川. 日本 (일본어)
14. чебурашка@ящик-с-апельсинами.рф (키릴 자모)

그것은 분명히 다재다능하고 가장 중요한 국제 캐릭터를 허용하면서도 기본적인 everything@anything.anything 형식을 시행합니다. RFC에서 기술적으로 허용되는 공간을 차단하지만 너무 드물기 때문에이 작업을 수행 할 수 있습니다.

최신 브라우저에서는 순수한 JavaScript와 DOM을 사용 하여 @Sushil의 답변 위에 구축 할 수 있습니다 .

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 's Answer의 기능 탐지 및 베어 본 유효성 검사와 결합 하여 정규 표현식 대학살을 피하고 오래된 브라우저에서 멈출 수 없습니다.

이것은 올바른 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'(예 : @) 기호가 있습니다. 필요한 조건을 테스트하십시오.

email.indexOf("@") > 0

더 복잡한 것을 귀찮게하지 마십시오. 전자 메일이 RFC 구문에 유효한지 완벽하게 확인할 수 있더라도 전자 메일을 제공 한 사람의 것인지 여부는 알 수 없습니다. 그것이 정말로 중요한 것입니다.

이를 테스트하려면 유효성 검사 메시지를 보내십시오.

RFC를 준수하는 전자 메일 주소의 올바른 유효성 검사는 한 줄짜리 정규식으로 얻을 수있는 것이 아닙니다. PHP에서 찾은 최고의 솔루션을 가진 기사 는 유효한 이메일 주소 는 무엇입니까? . 분명히, 그것은 자바로 포팅되었습니다. 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: 마지막 점 앞에 3 자 이상이 있어야합니다 (예 :) 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])?

다음은 JavaScript에서 사용되는 예제입니다 ( 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,})$/

Wikipedia Email Address 의 예제를 전달합니다 .

그리고 당신은 여기에 결과를 볼 수 있습니다 .

전자 메일인지 확인하기 위해 정규식을 사용하여 입력 문자열의 유효성을 검사해서는 안됩니다. 너무 복잡해서 모든 경우를 다루지는 않습니다.

이제 사례의 90 % 만 처리 할 수 ​​있으므로 다음과 같이 작성하십시오.

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

다듬을 수 있습니다. 예를 들어, 'aaa @'는 유효합니다. 그러나 전반적으로 요점을 얻습니다. 그리고 해결하지 마십시오 ... 간단한 90 % 솔루션이 작동하지 않는 100 % 솔루션보다 낫습니다.

세상은 더 간단한 코드가 필요합니다 ...

입력 한 이메일 주소가 유효한지 HTML을 사용하지 않는지 확인하십시오.

<input type="email"/>

유효성 검사를 위해 함수를 작성할 필요가 없습니다.

이메일 유효성 검사기를 100 % 정확하게 얻는 것은 어렵습니다. 올바른 방법은 계정에 테스트 이메일을 보내는 것입니다. 즉, 합리적인 것을 얻는 데 도움이되는 몇 가지 기본 검사가 있습니다.

개선해야 할 사항 :

new 대신 다음과 같이 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
}

정규식 업데이트 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의 존재를 확인하지 않는 솔루션이 불완전합니다.

이 질문에 대한 거의 모든 답변은 Regex를 사용하여 이메일 주소를 확인하는 것이 좋습니다. Regex는 기본적인 검증에만 적합하다고 생각합니다. 이메일 주소의 확인 확인은 실제로 두 가지 별도의 문제인 것 같습니다.

1- 이메일 형식 확인 : 이메일이 RFC 5322의 이메일 형식 및 패턴을 준수하는지 그리고 TLD가 실제로 존재하는지 확인하십시오. 유효한 모든 TLD 목록은 여기 에서 찾을 수 있습니다 .

예를 들어, 주소 example@example.ccc가 정규식을 통과 하더라도 cccIANA의 최상위 도메인이 아니기 때문에 올바른 이메일 이 아닙니다.

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

다음은 정규식을 사용하여 전자 메일 주소의 유효성을 검사하는 방법에 대한 매우 유용한 토론입니다. " 정규식을 검증하는 이메일 주소 비교 "

다음은 참조 용으로 현재 최상위 표현식 (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 에서 가져온10 월 1 일 ' 에서 입니다.

물론 국제화를 무시하고 있습니다.

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>

모든 이메일 주소 테스트 사례를 통과하는 JS의 Regex를 찾고있었습니다.

• 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 내에서 Microsoft가 제공하는 정규식 은 다음과 같습니다.

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

결함이있는 경우 여기에 게시하지만 항상 내 요구에 완벽합니다.