JavaScript에서 이메일 주소를 확인하는 방법은 무엇입니까?

StackOverflow https://stackoverflow.com/questions/46155

문제

JavaScript에서 이메일 주소를 어떻게 확인할 수 있나요?

도움이 되었습니까?

해결책

사용 정규 표현식 아마도 가장 좋은 방법 일 것입니다.다양한 테스트를 볼 수 있습니다. 여기 (에서 가져옴 크롬)

function validateEmail(email) {
    var 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());
}

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

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

하지만 JavaScript 유효성 검사에만 의존해서는 안 된다는 점을 명심하세요.JavaScript는 쉽게 비활성화될 수 있습니다.이는 서버 측에서도 검증되어야 합니다.

위의 실제 사례는 다음과 같습니다.

function validateEmail(email) {
  var 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() {
  var $result = $("#result");
  var 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>

다른 팁

완전성을 위해, 여기에 또 다른 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

따라서 공식 표준을 따를 때에도 여전히 절충이 필요합니다. 온라인 라이브러리나 토론 포럼에서 정규식을 맹목적으로 복사하지 마세요.항상 자신의 데이터와 애플리케이션을 사용하여 테스트하세요.

강조 광산

다음과 같은 형식으로 매우 간단한 검증을 원하는 사람들을 위해 Jaymon의 답변을 약간 수정했습니다.

모든문자열@모든문자열.모든문자열

정규 표현식:

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

예제 JavaScript 함수:

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

와, 여기에는 많은 복잡성이 있습니다.당신이 하고 싶은 것이 가장 명백한 구문 오류를 잡는 것뿐이라면 나는 다음과 같이 할 것입니다:

^\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 (space between the quotes)
8.  üñîçøðé@example.com (Unicode characters in local part)
9.  üñîçøðé@üñîçøðé.com (Unicode characters in domain part)
10. Pelé@example.com (Latin)
11. δοκιμή@παράδειγμα.δοκιμή (Greek)
12. 我買@屋企.香港 (Chinese)
13. 甲斐@黒川.日本 (Japanese)
14. чебурашка@ящик-с-апельсинами.рф (Cyrillic)

이는 분명히 다목적이며 매우 중요한 국제 문자를 허용하는 동시에 기본적인 everything@anything.anything 형식을 적용합니다.이는 RFC에서 기술적으로 허용하는 공간을 차단하지만 매우 드물기 때문에 기꺼이 이 작업을 수행합니다.

최신 브라우저에서는 순수한 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/.기능 감지 및 기본 검증과 결합됨 꼬부기의 대답, 이는 정규식 대량 학살로부터 당신을 해방시키고 오래된 브라우저에서 지루하지 않습니다.

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)>)$

이는 올바른 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);
}

모든 이메일 주소에는 'at'(예:@) 기호.필요한 조건을 테스트합니다.

email.indexOf("@") > 0

더 복잡한 일로 고민하지 마세요.이메일이 RFC 구문상 유효한지 여부를 완벽하게 판단할 수 있더라도 이메일을 제공한 사람의 것인지 여부는 알 수 없습니다.그것이 정말로 중요한 것입니다.

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

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:마지막 점 앞에는 문자가 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;}

나는 이 문제가 해결되기를 정말로 기대하고 있습니다.그래서 위의 이메일 검증 정규식을 수정했습니다.

  • 원래의
    /^(([^<>()\[\]\\.,;:\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,})$/

예제를 전달하기 위해 위키피디아 이메일 주소.

그리고 결과는 다음에서 볼 수 있습니다. 여기.

enter image description here

이 작업을 수행:

[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

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

이제 사례의 90%만 다룰 수 있으므로 다음과 같이 작성하세요.

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

다듬을 수 있습니다.예를 들어 'aaa@'는 유효합니다.그러나 전반적으로 요점을 알 수 있습니다.그리고 휩쓸리지 마세요...단순한 90% 솔루션이 작동하지 않는 100% 솔루션보다 낫습니다.

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

입력한 이메일 주소가 유효한지 HTML을 사용하지 않는지 간단히 확인하세요.

<input type="email"/>

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

이것이 방법이다 노드 검증기 그것을 한다:

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

이메일 유효성 검사기를 100% 정확하게 만드는 것은 어렵습니다.정확한 정보를 얻을 수 있는 유일한 방법은 계정에 테스트 이메일을 보내는 것입니다.즉, 합리적인 결과를 얻고 있는지 확인하는 데 도움이 될 수 있는 몇 가지 기본 점검 사항이 있습니다.

개선해야 할 사항:

새로운 것 대신에 RegExp, 그냥 작성해 보세요 regexp 다음과 같이 나가세요:

if (reg.test(/@/))

둘째, 마침표 뒤에 마침표가 있는지 확인하십시오. @ 서명하고 사이에 문자가 있는지 확인하십시오. @s 및 마침표.

유효성 검사기 함수 내에서 다음 코드를 사용하세요.

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

RFC5322를 준수하는 최고의 정규식

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

TLD의 존재 여부를 확인하지 않는 솔루션은 불완전합니다.

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

1- 이메일 형식 검증: 이메일이 RFC 5322의 이메일 형식과 패턴을 준수하는지, TLD가 실제로 존재하는지 확인합니다.유효한 모든 TLD 목록을 찾을 수 있습니다. 여기.

예를 들어 주소는 example@example.ccc 정규식을 통과하므로 유효한 이메일이 아닙니다. ccc 은(는) IANA의 최상위 도메인이 아닙니다.

2- 이메일이 실제로 존재하는지 확인하십시오. 이를 위해, 유일한 옵션 ~이다 사용자에게 이메일을 보내려면.

분명히 그게 다야 :

/^([\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년 10월 1일.

그러나 물론 이는 국제화를 무시하는 것입니다.

대조적으로 꼬부라지다, 여기에 복잡한 솔루션이 있지만 이메일을 적절하게 검증하는 데 매우 훌륭한 작업을 수행합니다.

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

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

다음은 참조 목적으로 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

나의 지식 정규 표현식 그다지 좋지 않습니다.그렇기 때문에 먼저 간단한 정규식으로 일반적인 구문을 확인하고 나중에 다른 함수로 더 구체적인 옵션을 확인합니다.이것이 최고의 기술 솔루션은 아닐 수도 있지만 이렇게 하면 훨씬 더 유연하고 빠릅니다.

제가 접한 가장 일반적인 오류는 공백(특히 시작과 끝)과 때때로 이중 점입니다.

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>

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})?$/

결함이 있을 경우를 대비해 여기에 게시합니다. 하지만 항상 내 요구에 완벽했습니다.

Wikipedia 표준 메일 구문:

https://en.wikipedia.org/wiki/Email_address#Examples https://fr.wikipedia.org/wiki/Adresse_%C3%A9lectronique#Syntaxe_exacte

function validMail(mail)
{
    return /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+([^<>()\.,;:\s@\"]{2,}|[\d\.]+))$/.test(mail);
}

// VALID MAILS

validMail('Abc@example.com') // Return true
validMail('Abc@example.com.') // Return true
validMail('Abc@10.42.0.1') // Return true
validMail('user@localserver') // Return true
validMail('Abc.123@example.com') // Return true
validMail('user+mailbox/department=shipping@example.com') // Return true
validMail('"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com') // Return true
validMail('!#$%&\'*+-/=?^_`.{|}~@example.com') // Return true
validMail('"()<>[]:,;@\\\"!#$%&\'-/=?^_`{}| ~.a"@example.org') // Return true
validMail('"Abc@def"@example.com') // Return true
validMail('"Fred Bloggs"@example.com') // Return true
validMail('"Joe.\\Blow"@example.com') // Return true
validMail('Loïc.Accentué@voilà.fr') // Return true
validMail('" "@example.org') // Return true
validMail('user@[IPv6:2001:DB8::1]') // Return true

// INVALID MAILS

validMail('Abc.example.com') // Return false
validMail('A@b@c@example.com') // Return false
validMail('a"b(c)d,e:f;g<h>i[j\k]l@example.com') // Return false
validMail('just"not"right@example.com') // Return false
validMail('this is"not\allowed@example.com') // Return false
validMail('this\ still\"not\\allowed@example.com') // Return false
validMail('john..doe@example.com') // Return false
validMail('john.doe@example..com') // Return false

이 테스트를 보여주세요: https://regex101.com/r/LHJ9gU/1

라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top