programing

JavaScript에서 이메일 주소를 검증하려면 어떻게 해야 합니까?

sourcejob 2022. 9. 25. 00:20
반응형

JavaScript에서 이메일 주소를 검증하려면 어떻게 해야 합니까?

가장 기본적인 오타를 방지하기 위해 서버에 송신하거나 메일을 송신하기 전에 사용자 입력이 JavaScript의 이메일 주소인지 확인하고 싶습니다.어떻게 하면 이런 일을 할 수 있을까요?

정규 표현을 사용하는 것이 가장 좋은 방법일 것입니다.여기서 (크롬에서 채취한) 많은 테스트를 볼 수 있습니다.

const validateEmail = (email) => {
  return String(email)
    .toLowerCase()
    .match(
      /^(([^<>()[\]\\.,;:\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,}))$/
    );
};

다음은 Unicode를 받아들이는 정규 표현의 예입니다.

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

단, JavaScript 검증에만 의존해서는 안 됩니다.JavaScript는 쉽게 비활성화할 수 있습니다.이것은 서버측에서도 검증할 필요가 있습니다.

다음은 위의 예를 제시하겠습니다.

const validateEmail = (email) => {
  return email.match(
    /^(([^<>()[\]\\.,;:\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,}))$/
  );
};

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

$('#email').on('input', validate);
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<label for="email">Enter an email address: </label>
<input id="email" />
<h2 id="result"></h2>

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

anystring@anystring.anystring

정규 표현:

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

여러 개의 @ 기호가 일치하지 않도록 하려면:

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

JavaScript 함수의 예:

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

여기 RFC 2822에 준거한 regex가 하나 더 있습니다.

공식 표준은 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글자의 국가 코드 최상위 도메인과 특정 일반 최상위 도메인만 허용하도록 변경할 수 있습니다.이 regex는 와 같은 더미 전자 메일 주소를 필터링합니다.새로운 최상위 도메인이 추가되면 업데이트해야 합니다.

[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 검증의 전부입니다.

편집: 이메일에서 '.'를 확인할 수도 있습니다.

/^\S+@\S+\.\S+$/

이메일을 검증하기 위해 정규 표현을 사용하기로 결정한 순간 이해해야 할 사항이 있습니다.그건 좋은 생각이 아닌 것 같아.일단 이 문제를 받아들이면 중간까지 도달할 수 있는 구현이 많이 있습니다.이 기사에서는 그 내용을 잘 정리하고 있습니다.

단, 요컨대 사용자가 입력한 내용이 실제로 이메일을 보내 무슨 일이 일어나는지 확인하는 것 뿐이라는 것을 확실하게 알 수 있는 유일한 방법입니다.그것 말고는 다 추측일 뿐이야.

HTML5 자체에는 이메일 검증 기능이 있습니다.브라우저가 HTML5를 지원하는 경우 다음 코드를 사용할 수 있습니다.

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

jsFiddle 링크

HTML5 사양부터:

유효한 전자 메일주소는, 다음과 같은 문자열입니다.emailABNF

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에 대한 의도적인 위반입니다.이것에 의해, E-메일 주소의 구문은, 동시에 너무 엄격하고(@문자 뒤에), 너무 애매하고(대부분의 유저에게 익숙하지 않은 방법으로 코멘트, 공백 문자, 따옴표를 사용할 수 있는 스트링의 허용) 매우 느슨해, 실용적으로 사용할 수 없게 됩니다.

다음 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.com2. very.common@example.com3. 일회용.스타일.이메일+ symbol@example.com에서4. other.email-with-dash@example.com9. #!$%&'*+-/=?^_'{}|~@laughters.daughters6.  "()[]:,;@\\\"!#$%&'*+-/=?^_'{}| ~.a"@syslog.displaces7. "@timeout.displaces (따옴표 사이에 공백)8. ñîøexexex@example.com (로컬 부분의 유니코드 문자)9. ñîüü@üñîîøcomcom.com (도메인 부분의 유니코드 문자)10. Pelé@example.com (라틴어)11 μα @μα μα μα그리스어12. 我買@屋企.港 ( (중국어)13. 甲斐@黒川.本 ((일본어)14. чебурашка@ящик-с-апельсинами.키릴어

이것은 분명히 다재다능하며 기본적인 anything@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);
}

fielen http://jsfiddle.net/boldewyn/2b6d5/에 예를 들어봤습니다.기능검출과 Cwigtle's Answer의 베어본 검증이 조합되어 정규 표현의 대량학살로부터 해방되어 오래된 브라우저에서는 동작하지 않습니다.

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

RFC에 준거한 전자 메일주소의 올바른 검증은, 1 행의 정규 표현으로는 실행할 수 없습니다.내가 PHP에서 찾은 최고의 솔루션을 가진 기사는 "유효한 이메일 주소입니다.확실히 Java로 포팅되어 있습니다. 자바스크립트로 포팅하여 사용하기에는 기능이 너무 복잡하다고 생각합니다. 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: 마지막 점 뒤에 2글자 도메인을 형성하기에 충분한 문자가 있어야 합니다.브래킷이 필요한지 잘 모르겠어요.

모든 이메일 주소에는 'at'(@) 기호가 포함되어 있습니다.필요한 조건을 테스트합니다.

email.includes('@')

또는 IE/오래된 브라우저를 지원해야 하는 경우:

email.indexOf('@') > 0

더 복잡한 건 신경 쓰지 마세요.이메일이 RFC 구문상 유효한지 여부를 완벽하게 판단할 수 있다고 해도 이메일을 제공한 사람의 것인지 여부는 알 수 없습니다.그게 진짜 중요한 거야

그것을 테스트하려면 , 검증 메세지를 송신해 주세요.

이것은 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에 근거하고 있습니다.

https://regex101.com/r/857lzc/1에서 테스트합니다.

데이터베이스에 전자 메일 주소를 저장할 때 보통 소문자로 표시하고 실제로는 대소문자를 구분하지 않는 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에서와 소문자를 하지 않는 플래그 ） 。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') );

주의:
말하면, 메일에서는, 「인용」의 앞의 할 수 .@따옴표에 이스케이프 이 불쾌하게 할 수 ).@ ★★★★★★★★★★★★★★★★★」"..."(따옴표 안에 기재되어 있는 한)아무도 이런 짓 안 해!구식이야.단, IS는 진정한 RFC 2822 표준에 포함되어 있으며, 여기서는 생략되어 있습니다.

주의 2: 이메일 시작(@ 기호 앞)은 대소문자를 구분합니다(스펙을 사용).그러나 대소문자를 구분하는 이메일을 사용하는 사용자는 문제가 발생하는 데 익숙할 수 있으며 실제로 대소문자를 구분하지 않는 것이 안전합니다.상세 정보:이메일 주소는 대소문자를 구분합니까?

상세정보 : 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 E-메일 주소의 예시를 전달합니다.

그리고 여기서 결과를 볼 수 있습니다.

여기에 이미지 설명 입력

입력한 이메일 주소가 유효한지 HTML을 사용하지 않는지 확인만 하면 됩니다.

<input type="email"/>

검증을 위해 함수를 작성할 필요가 없습니다.

전자 메일인지 확인하기 위해 입력 문자열을 검증하는 데 정규식을 사용하면 안 됩니다.너무 복잡해서 모든 사건을 다루지는 못할 거예요.

케이스의 90%밖에 커버할 수 없기 때문에 다음과 같이 기입해 주십시오.

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

다듬을 수 있어요.예를 들어 'aaa@'는 유효합니다.하지만 전반적으로 당신은 요점을 이해한다.그리고 너무 흥분하지 말고...단순한 90% 솔루션이 작동하지 않는 100% 솔루션보다 낫습니다.

세상은 더 간단한 코드가 필요해

E-메일 검증기를 100% 맞히기는 어렵습니다.정확한 정보를 얻는 유일한 방법은 계정에 테스트 이메일을 보내는 것입니다.단, 합리적인 것을 얻을 수 있도록 몇 가지 기본적인 체크가 있습니다.

개선해야 할 점:

RegExp한 번 써보세요.regexp뭇매를 맞다

if (reg.test(/@/))

번째, 이 다음에 합니다.@ 기호에 있는지 합니다.@와 마침표

정규식이 업데이트되었습니다!이걸 시도해 보세요.

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 를 참조해 주세요.

정규식 테스트 케이스

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

유효한 이메일:

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

잘못된 이메일:

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

노드 검증자는 다음과 같이 동작합니다.

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

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

이 질문에 대한 거의 모든 답변에서 Regex를 사용하여 전자 메일 주소를 검증할 것을 제안합니다.내 생각에 Regex는 기본적인 검증에만 적합하다.이메일 주소 확인은 실제로는 두 가지 다른 문제로 보입니다.

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

를 들어, 「」는 「」입니다만,example@example.ccc는 regex를 는 유효하지 않습니다.regex는 regex가 아니기 입니다.유효한 이메일이 아니기 때문입니다.ccc는 IANA에이 아닙니다.

2- 이메일이 실제로 존재하는지 확인합니다.이 경우 유일한 옵션은 사용자에게 이메일을 보내는 것입니다.

검증자 함수 내에서 다음 코드를 사용합니다.

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
}

꼬부기와는 달리 복잡한 솔루션이 있지만 이메일을 적절히 검증할 수 있습니다.

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

이메일 주소의 유효성을 확인하기 위한 정규식

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


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

function checkbae() {
  if (document.layers || document.getElementById || document.all)
    return checkemail()
  else
    return 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>

다음은 정규식을 사용하여 전자 메일 주소를 확인하는 방법에 대한 매우 유용한 설명입니다. "정규식을 확인하는 전자 메일 주소 비교"

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

2010년 10월 1일에 http://fightingforalostcause.net/misc/2006/compare-email-regex.php 에서 취득.

하지만, 물론, 그것은 국제화를 무시하는 것이다.

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[대시 입력 주소(Dash in address 필드는 유효합니다.

여기 있습니다.

http://regexr.com/3f07j

또는 정규식:

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

언급URL : https://stackoverflow.com/questions/46155/how-can-i-validate-an-email-address-in-javascript

반응형

'programing' 카테고리의 다른 글

현재 디렉토리의 모든 하위 디렉토리 목록 가져오기  (0) 2022.09.25
전략 패턴과 명령 패턴의 차이  (0) 2022.09.25
여러 상속을 가진 부모 클래스 __init__를 호출하는 올바른 방법은 무엇입니까?  (0) 2022.09.25
SQL Chemy는 Django의 get_or_create와 동등한 기능을 가지고 있습니까?  (0) 2022.09.25
상수의 이름을 포함하는 단순 변수를 사용하여 클래스 상수에 액세스  (0) 2022.09.25

'programing'의 다른글

  • 현재글JavaScript에서 이메일 주소를 검증하려면 어떻게 해야 합니까?

관련글

댓글

티스토리툴바