지난 몇 년 동안 나는 IP 주소를 서버 부분으로 사용하지 않는다고 가정하면서 MOST 전자 메일 주소의 유효성을 올바르게 검사 하는 정규식 을 천천히 개발했습니다 .

여러 PHP 프로그램에서 사용하며 대부분 작동합니다. 그러나 때때로 나는 그것을 사용하는 사이트에 문제가있는 누군가와 연락을 취하고 조정해야합니다 (가장 최근에는 4 자 TLD를 허용하지 않는다는 것을 깨달았습니다).

이메일 확인에있어 가장 좋은 정규 표현은 무엇입니까?

여러 개의 짧은 표현식을 사용하는 함수를 사용하는 여러 솔루션을 보았지만 더 복잡한 함수의 여러 짧은 표현식 대신 간단한 함수에서 하나의 긴 복잡한 표현식을 사용하고 싶습니다.

완전히 RFC 822 호환 정규 표현식은 비효율적 때문에 길이의 불분명. 다행히 RFC 822가 두 번 대체되었으며 현재 이메일 주소 사양은 RFC 5322 입니다. RFC 5322는 몇 분 동안 연구하면 이해할 수 있고 실제 사용하기에 충분히 효율적인 정규식으로 이어집니다.

하나의 RFC 5322 호환 정규 표현식은 http://emailregex.com/ 페이지 상단에서 찾을 수 있지만 00부호없는 바이트 10 진수 값 을 허용하는 버그로 인터넷 주위에 떠있는 IP 주소 패턴을 사용합니다 . 점으로 구분 된 주소로, 불법입니다. 나머지는 RFC 5322 문법과 일치하는 것으로 보이며 grep -Po도메인 이름, IP 주소, 잘못된 것, 따옴표가 있거나없는 계정 이름 등을 사용하여 몇 가지 테스트를 통과했습니다 .

00IP 패턴 의 버그를 수정하여 작동하고 상당히 빠른 정규식을 얻습니다. (실제 코드의 경우 마크 다운이 아닌 렌더링 된 버전을 폐기합니다.)

(? : [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])? | \ [(? :(? :( 2 (5 [0-5] | [0-4] [0-9]) | 1 [0-9] [0-9] | [1-9]? [0-9])) \.) {3} ( ? :( 2 (5 [0-5] | [0-4] [0-9]) | 1 [0-9] [0-9] | [1-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]) +) \])

또는:

(?:[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])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-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])+)\])

다음은 정규 표현식 자체보다 명확한 정규 표현식 위 의 유한 상태 머신 다이어그램 입니다.

Perl 및 PCRE의보다 정교한 패턴 (예 : PHP에서 사용되는 정규식 라이브러리)은 장애없이 RFC 5322를 올바르게 구문 분석 할 수 있습니다 . 파이썬과 C #도 그렇게 할 수 있지만 처음 두 가지와 다른 구문을 사용합니다. 그러나 덜 강력한 패턴 일치 언어 중 하나를 사용해야하는 경우 실제 구문 분석기를 사용하는 것이 가장 좋습니다.

또한 RFC에 따라 유효성을 검사하면 해당 주소가 제공된 도메인에 실제로 존재하는지 또는 주소를 입력 한 사람이 실제 소유자인지 여부를 전혀 알 수 없음을 이해하는 것이 중요합니다. 사람들은 항상 이런 방식으로 다른 사람들에게 메일 링리스트에 서명합니다. 주소와 동일한 웹 페이지에 입력되어야하는 확인 토큰을 포함하는 메시지를 해당 주소로 전송하는 것과 같은보다 강력한 종류의 유효성 검사가 필요한 수정.

확인 토큰은 입력 한 사람의 주소를 알 수있는 유일한 방법입니다. 이것이 대부분의 메일 링리스트가 가입을 확인하기 위해이 메커니즘을 사용하는 이유입니다. 결국, 누구나 내려 놓을 수 있고 president@whitehouse.gov, 그것은 합법적으로 파싱 될 것이지만, 다른 쪽 사람은 아닐 것입니다.

PHP의 경우 PHP 로 전자 메일 주소 확인에 제공된 패턴을 사용 해서는 안됩니다 .

일반적인 사용법과 광범위하게 조잡한 코딩이 기록 된 공식 표준보다 더 제한적인 전자 메일 주소에 대한 사실상의 표준을 확립 할 위험이 있습니다.

그것은 다른 모든 비 RFC 패턴보다 낫지 않습니다. RFC 5322는 물론 RFC 822 조차도 처리하기에 충분히 똑똑하지는 않습니다 . 그러나 이것은 하나 입니다.

화려하고 번거롭기를 원한다면 완전한 상태 엔진을 구현하십시오 . 정규식은 기초 필터로만 작동 할 수 있습니다. 정규 표현식의 문제점은 정규 표현식이 처리 할 수 ​​없기 때문에 완벽하게 유효한 전자 메일 주소가 유효하지 않다고 잘못 판단한다는 것입니다 (사용자의 입장에서는 무례하고 무례합니다). 목적을위한 상태 엔진은 각 RFC에 따라 전자 우편 주소를 분해 할 때 유효하지 않은 전자 우편 주소를 검증하고 정정 할 수 있습니다. 이것은 잠재적으로 더 즐거운 경험을 허용합니다.

지정된 이메일 주소 'myemail @ address, com'이 유효하지 않습니다. 'myemail@address.com'을 의미 했습니까?

주석을 포함하여 이메일 주소 확인 도 참조하십시오 . 또는 정규식 확인 이메일 주소 비교 .

Debuggex 데모

이메일 주소의 유효성을 검사하기 위해 정규식을 사용해서는 안됩니다.

대신 다음과 같이 MailAddress 클래스를 사용하십시오 .

try {
    address = new MailAddress(address).Address;
} catch(FormatException) {
    // address is invalid
}

이 MailAddress클래스는 BNF 파서를 사용하여 RFC822에 따라 주소의 전체 유효성을 검사합니다.

를 사용하여 MailAddress전자 메일 주소의 유효성을 검사하려는 경우이 방법 을 사용하면 전자 메일 주소의 표시 이름 부분도 허용되므로 정확하게 달성하려는 것이 아닐 수도 있습니다. 예를 들어 다음 문자열을 유효한 전자 메일 주소로 허용합니다.

• "user1@hotmail.com; user2@gmail.com"
• "user1@hotmail.com; user2@gmail.com; user3@company.com"
• "사용자 표시 이름 user3@company.com"
• "user4 @ company.com"

이러한 경우 중 일부에서는 문자열의 마지막 부분 만 주소로 구문 분석됩니다. 그 전의 나머지는 표시 이름입니다. 표시 이름없이 일반 전자 메일 주소를 얻으려면 정규화 된 주소를 원래 문자열과 비교하여 확인할 수 있습니다.

bool isValid = false;

try
{
    MailAddress address = new MailAddress(emailAddress);
    isValid = (address.Address == emailAddress);
    // or
    // isValid = string.IsNullOrEmpty(address.DisplayName);
}
catch (FormatException)
{
    // address is invalid
}

또한, 끝에 같은 점이있는 주소도 user@company.MailAddress에 의해 허용됩니다.

당신이 정말로 정규식을 사용하려면, 여기있다 :

(? : (? : \ r \ n)? [\ t]) * (? : (? : (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031 ] + (? : (? : (? : \ r \ n)? [\ t]
) + | \ Z | (? = [\ [ "() <> @,; :: \\". \ [\]])) | "(? : [^ \"\ r \\] | \\. | (? : (? : \ r \ n)? [\ t])) * "(? :( ?:
\ r \ n)? [\ t]) *) (? : \. (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \ \ ". \ [\] \ 000- \ 031] + (? :(? :(
? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [\]])) | "(? : [ ^ \ "\ r \\] | \\. | (? : (? : \ r \ n)? [ 
\ t])) * "(? : (? : \ r \ n)? [\ t]) *)) * @ (? : (? : \ r \ n)? [\ t]) * (?: [^ () <> @,; : \\ ". \ [\] \ 000- \ 0
31] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [\ ]])) | \ [([^ \ [\] \ r \\] | \\.) * \
] (? : (? : \ r \ n)? [\ t]) *) (? : \. (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] +
(? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; :: \\". \ [\]]) ) | \ [([^ \ [\] \ r \\] | \\.) * \] (?:
(? : \ r \ n)? [\ t]) *)) * | (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (?: (? : (? : \ r \ n)? [\ t]) + | \ Z
| (? = [\ [ "() <> @,; : \\". \ [\]])) | "(? : [^ \"\ r \\] | \\. | (? :( ? : \ r \ n)? [\ t])) * "(? : (? : \ r \ n)
? [\ t]) *) * \ <(? : (? : \ r \ n)? [\ t]) * (? : @ (? : [^ () <> @,; : \\ "). \ [\] \ 000- \ 031] + (? : (? : (? : \
r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; :: \\". \ [\]])) | \ [([^ \ [\ ] \ r \\] | \\.) * \] (? : (? : \ r \ n)? [
 \ t]) *) (? : \. (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)
? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [\]])) | \ [([^ \ [\] \ r \ \] | \\.) * \] (? : (? : \ r \ n)? [\ t]
) *)) * (? : ,, @ (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [
 \ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [\]])) | \ [([^ \ [\] \ r \\] | \\.) * \] (? : (? : \ r \ n)? [\ t]) *
) (? : \. (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031 ] + (? : (? : (? : \ r \ n)? [\ t]
) + | \ Z | (? = [\ [ "() <> @,; :: \\". \ [\]])) | \ [([^ \ [\] \ r \\] | \\ .) * \] (? : (? : \ r \ n)? [\ t]) *)) *)
* : (? : (? : \ r \ n)? [\ t]) *)? (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) +
| \ Z | (? = [\ [ "() <> @,; : \\". \ [\]]))] "(? : [^ \"\ r \\] | \\. | ( ? : (? : \ r \ n)? [\ t])) * "(? : (? : \ r
\ n)? [\ t]) *) (? : \. (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ " . \ [\] \ 000- \ 031] + (? :(? :( ?:
\ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [\]]))] ((:: [^ \ "\ r \\] | \\. | (? : (? : \ r \ n)? [\ t
])) * "(? : (? : \ r \ n)? [\ t]) *)) * @ (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031
] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [\] ])) | \ [([^ \ [\] \ r \\] | \\.) * \] (
? : (? : \ r \ n)? [\ t]) *) (? : \. (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (?
: (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [\]])) | \ [([^ \ [\] \ r \\] | \\.) * \] (? :(?
: \ r \ n)? [\ t]) *)) * \> (? : (? : \ r \ n)? [\ t]) *) | (? : [^ () <> @ ,; : \\ ". \ [\] \ 000- \ 031] + (? :(?
: (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [\]])) | "(? : [^ \ "\ r \\] | \\. | (? : (? : \ r \ n)?
[\ t])) * "(? : (? : \ r \ n)? [\ t]) *) * : (? : (? : \ r \ n)? [\ t]) * (?: (? : (? : [^ () <> @,; : \\ ". \ [\] 
\ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\" . \ [\]])) | "(? : [^ \"\ r \\] |
\\. | (? : (? : \ r \ n)? [\ t])) * "(? : (? : \ r \ n)? [\ t]) *) (? : \. (? : (? : \ r \ n)? [\ t]) * (? : [^ () <>

@,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [\]])) | "
(? : [^ \ "\ r \\] | \\. | (? : (? : \ r \ n)? [\ t])) *"(? : (? : \ r \ n)? [ \ t]) *)) * @ (? : (? : \ r \ n)? [\ t]
) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\
". \ [\]])) | \ [([^ \ [\] \ r \\] | \\.) * \] (? : (? : (? : \ r \ n)? [\ t]) * ) (? : \. (? : (? : \ r \ n)? [\ t]) * (?
: [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [
\]])) | \ [([^ \ [\] \ r \\] | \\.) * \] (? : (? : \ r \ n)? [\ t]) *)) * | (? : [^ () <> @,; : \\ ". \ [\] \ 000-
\ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [ \]])) | "(? : [^ \"\ r \\] | \\. | (
? : (? : \ r \ n)? [\ t])) * "(? : (? : \ r \ n)? [\ t]) *) * \ <(? : (? : \ r \ n)? [\ t]) * (? : @ (? : [^ () <> @ ,;
: \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ ["() <> @,; : \\ ". \ [\]])) | \ [([
^ \ [\] \ r \\] | \\.) * \] (? : (? : \ r \ n)? [\ t]) *) (? : \. (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ "
. \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @, ; : \\ ". \ [\]])) \ [([^ \ [\
] \ r \\] | \\.) * \] (? : (? : \ r \ n)? [\ t]) *)) * (? :, @ (? : (? : \ r \ n )? [\ t]) * (? : [^ () <> @,; : \\ ". \
[\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\ ". \ [\]])) | \ [([^ \ [\] \
r \\] | \\.) * \] (? : (? : \ r \ n)? [\ t]) *) (? : \. (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] 
\ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\" . \ [\]])) | \ [([^ \ [\] \ r \\]
| \\.) * \] (? : (? : \ r \ n)? [\ t]) *)) *) * : (? : (? : \ r \ n)? [\ t]) * )? (? : [^ () <> @,; : \\ ". \ [\] \ 0
00- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [\]])) | "(? : [^ \"\ r \\] | \\
. | (? : (? : \ r \ n)? [\ t])) * "(? : (? : (? : \ r \ n)? [\ t]) *) (? : \. (? :( ? : \ r \ n)? [\ t]) * (? : [^ () <> @,
; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ ["( ) <> @,; : \\ ". \ [\]]))" "(?
: [^ \ "\ r \\] | \\. | (? : (? : \ r \ n)? [\ t])) *"(? : (? : \ r \ n)? [\ t ]) *)) * @ (? : (? : \ r \ n)? [\ t]) *
(? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\".
\ [\]])) | \ [([^ \ [\] \ r \\] | \\.) * \] (? : (? : \ r \ n)? [\ t]) *) ( ? : \. (? : (? : \ r \ n)? [\ t]) * (? : [
^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | ( ? = [\ [ "() <> @,; : \\". \ [\]
])) | \ [([^ \ [\] \ r \\] | \\.) * \] (? : (? : \ r \ n)? [\ t]) *)) * \> ( ? : (? : \ r \ n)? [\ t]) *) (? :, \ s * (
? : (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\
". \ [\]])) |"(? : [^ \ "\ r \\] | \\. | (? : (? : \ r \ n)? [\ t])) *"(? : (? : \ r \ n)? [\ t]) *) (? : \. (? :(
? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? :(? :(? : \ r \ n)? [\ t]) + | \ Z | (? = [
\ [ "() <> @,; : \\". \ [\]]))] "(? : [^ \"\ r \\] | \\. | (? : (? : \ r \ n)? [\ t])) * "(? : (? : \ r \ n)? [\ t
]) *)) * @ (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n) ?? [\ t
]) + | \ Z | (? = [\ [ "() <> @,; :: \\". \ [\]])) | \ [([^ \ [\] \ r \\]] \ \.) * \] (? : (? : \ r \ n)? [\ t]) *) (?
: \. (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + ( ? : (? : (? : \ r \ n)? [\ t]) + |
\ Z | (? = [\ [ "() <> @,; :: \\". \ [\]])) | \ [([^ \ [\] \ r \\] | \\.) * \] (? : (? : \ r \ n)? [\ t]) *)) * | (?:
[^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\". \ [\
]]))] "(? : [^ \"\ r \\] | \\. | (? : (? : \ r \ n)? [\ t])) * "(? : (? : \ r \ n)? [\ t]) *) * \ <(? : (? : \ r \ n)
? [\ t]) * (? : @ (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "
() <> @,; :: \\ ". \ [\]])) | \ [([^ \ [\] \ r \\] | \\.) * \] (? : (? : \ r \ n)? [\ t]) *) (? : \. (? : (? : \ r \ n)
? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <>

@,; : \\ ". \ [\]])) | \ [([^ \ [\] \ r \\] | \\.) * \] (? : (? : \ r \ n)? [\ t]) *)) * (? :, @ (? : (? : \ r \ n)? [
 \ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,
; : \\ ". \ [\]]))] \ [([^ \ [\] \ r \\] | \\.) * \] (? : (? : \ r \ n)? [\ t]) *) (? : \. (? : (? : \ r \ n)? [\ t]
) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\
". \ [\]])) | \ [([^ \ [\] \ r \\] | \\.) * \] (? : (? : (? : \ r \ n)? [\ t]) * )) *) * : (? : (? : \ r \ n)? [\ t]) *)?
(? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [ "() <> @,; : \\".
\ [\]])) | "(? : [^ \"\ r \\] | \\. | (? : (? : \ r \ n)? [\ t])) * "(? :( ? : \ r \ n)? [\ t]) *) (? : \. (? :( ?:
\ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t]) + | \ Z | (? = [\ [
"() <> @,; : \\". \ [\]]))] "(? : [^ \"\ r \\] | \\. | (? : (? : \ r \ n) ? [\ t])) * "(? : (? : \ r \ n)? [\ t])
*)) * @ (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (? : (? : (? : \ r \ n)? [\ t])
+ | \ Z | (? = [\ [ "() <> @,; :: \\". \ [\]])) | \ [([^ \ [\] \ r \\] | \\. ) * \] (? : (? : \ r \ n)? [\ t]) *) (? : \
. (? : (? : \ r \ n)? [\ t]) * (? : [^ () <> @,; : \\ ". \ [\] \ 000- \ 031] + (?: (? : (? : \ r \ n)? [\ t]) + | \ Z
| (? = [\ [ "() <> @,; : \\". \ [\]])) | \ [([^ \ [\] \ r \\] | \\.) * \] (? : (? : \ r \ n)? [\ t]) *)) * \> (? :(
? : \ r \ n)? [\ t]) *)) *)?; \ s *)

이 질문은 많이 제기되지만 이메일 주소를 구문 적으로 검증하고 싶은 이유는 무엇입니까? 실제로 어떤 이점이 있습니까?

• 일반적인 오타는 잡을 수 없습니다.
• 사람들이 유효하지 않거나 구성한 전자 메일 주소를 입력하거나 다른 사람의 주소를 입력하는 것을 막지 않습니다.

전자 메일이 올바른지 확인하려면 확인 전자 메일을 보내서 사용자가 답장을 보내도록 선택할 수 있습니다. 많은 경우에 당신이 것 이 보안상의 이유로 윤리적 이유로 어쨌든 확인 메일을 보내 (그래서 할 수 있습니다 자신의 의지와 서비스까지하지 예를 들어, 기호 누군가).

그것은 모두 당신이 얼마나 정확한지에 달려 있습니다. 내 목적을 위해 bob @ aol.com(이메일에 공백) 또는 steve(도메인이 전혀 없음) 또는 mary@aolcom(.com 이전에는 없음 ) 과 같은 것을 차단하려는 경우

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

물론 유효하지 않은 이메일 주소와 일치하지만 일반적인 간단한 오류가 발생합니다.

해당 정규 표현식에 대해 많은 변경 사항이 있으며 일부는이 답변에 대한 의견에 있지만 간단하고 이해하기 쉽고 첫 번째 시도입니다.

그것은 당신이 가장 의미하는 바에 달려 있습니다 : 유효한 모든 이메일 주소를 잡는 것에 대해 이야기하고 있다면 다음을 사용하십시오 :

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ 
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
 \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
 \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
 \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
?:\r\n)?[ \t])*))*)?;\s*)

( http://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html ) 더 간단한 것을 찾고 있지만 가장 유효한 이메일 주소를 찾으려면 다음과 같이 시도하십시오.

"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"

편집 : 링크에서 :

이 정규식은 주석이 제거되고 공백으로 대체 된 주소 만 유효성을 검사합니다 (모듈에서 수행함).

[업데이트 됨] 이메일 주소 확인에 대해 내가 아는 모든 것을 여기에 정리했습니다 : http://isemail.info , 이제 이메일 주소의 문제를 검증 할뿐만 아니라 진단합니다. 유효성 검사는 답변의 일부일 뿐이라는 많은 의견에 동의합니다. http://isemail.info/about 에서 내 에세이를 참조하십시오 .

is_email ()은 내가 아는 한 주어진 문자열이 유효한 이메일 주소인지 아닌지를 확실하게 알려주는 유일한 유효성 검사기입니다. http://isemail.info/ 에서 새 버전을 업로드했습니다.

Cal Henderson, Dave Child, Phil Haack, Doug Lovell, RFC5322 및 RFC 3696에서 테스트 사례를 수집했습니다. 내가 찾은 모든 무료 유효성 검사기에 대해 이러한 모든 테스트를 실행했습니다.

사람들이 유효성 검사기를 향상시킬 때이 페이지를 최신 상태로 유지하려고합니다. 이 테스트를 컴파일하고 내 검증 자의 건설적인 비판에 도움을 주신 Cal, Michael, Dave, Paul 및 Phil에게 감사의 말을 전 합니다.

사람들은 특히 RFC 3696 에 대한 정오표를 알고 있어야합니다 . 정식 예제 중 3 개는 실제로 잘못된 주소입니다. 주소의 최대 길이는 320이 아닌 254 자 또는 256 자 입니다.

당 은 W3C HTML5 사양 :

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

문맥:

유효한 이메일 주소 생산 ABNF [...]을 일치하는 문자열이다.

참고 :이 요구 사항은 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])?)*$/

Perl 5.10 이상에서는 쉽습니다.

/(?(DEFINE)
   (?<address>         (?&mailbox) | (?&group))
   (?<mailbox>         (?&name_addr) | (?&addr_spec))
   (?<name_addr>       (?&display_name)? (?&angle_addr))
   (?<angle_addr>      (?&CFWS)? < (?&addr_spec) > (?&CFWS)?)
   (?<group>           (?&display_name) : (?:(?&mailbox_list) | (?&CFWS))? ;
                                          (?&CFWS)?)
   (?<display_name>    (?&phrase))
   (?<mailbox_list>    (?&mailbox) (?: , (?&mailbox))*)

   (?<addr_spec>       (?&local_part) \@ (?&domain))
   (?<local_part>      (?&dot_atom) | (?&quoted_string))
   (?<domain>          (?&dot_atom) | (?&domain_literal))
   (?<domain_literal>  (?&CFWS)? \[ (?: (?&FWS)? (?&dcontent))* (?&FWS)?
                                 \] (?&CFWS)?)
   (?<dcontent>        (?&dtext) | (?&quoted_pair))
   (?<dtext>           (?&NO_WS_CTL) | [\x21-\x5a\x5e-\x7e])

   (?<atext>           (?&ALPHA) | (?&DIGIT) | [!#\$%&'*+-/=?^_`{|}~])
   (?<atom>            (?&CFWS)? (?&atext)+ (?&CFWS)?)
   (?<dot_atom>        (?&CFWS)? (?&dot_atom_text) (?&CFWS)?)
   (?<dot_atom_text>   (?&atext)+ (?: \. (?&atext)+)*)

   (?<text>            [\x01-\x09\x0b\x0c\x0e-\x7f])
   (?<quoted_pair>     \\ (?&text))

   (?<qtext>           (?&NO_WS_CTL) | [\x21\x23-\x5b\x5d-\x7e])
   (?<qcontent>        (?&qtext) | (?&quoted_pair))
   (?<quoted_string>   (?&CFWS)? (?&DQUOTE) (?:(?&FWS)? (?&qcontent))*
                        (?&FWS)? (?&DQUOTE) (?&CFWS)?)

   (?<word>            (?&atom) | (?&quoted_string))
   (?<phrase>          (?&word)+)

   # Folding white space
   (?<FWS>             (?: (?&WSP)* (?&CRLF))? (?&WSP)+)
   (?<ctext>           (?&NO_WS_CTL) | [\x21-\x27\x2a-\x5b\x5d-\x7e])
   (?<ccontent>        (?&ctext) | (?&quoted_pair) | (?&comment))
   (?<comment>         \( (?: (?&FWS)? (?&ccontent))* (?&FWS)? \) )
   (?<CFWS>            (?: (?&FWS)? (?&comment))*
                       (?: (?:(?&FWS)? (?&comment)) | (?&FWS)))

   # No whitespace control
   (?<NO_WS_CTL>       [\x01-\x08\x0b\x0c\x0e-\x1f\x7f])

   (?<ALPHA>           [A-Za-z])
   (?<DIGIT>           [0-9])
   (?<CRLF>            \x0d \x0a)
   (?<DQUOTE>          ")
   (?<WSP>             [\x20\x09])
 )

 (?&address)/x

나는 사용한다

^\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$

RegularExpressionValidator가 ASP.NET에서 사용하는 것입니다.

가장 잘 모르지만 주소에 주석이 제거되고 공백으로 대체되는 한 이것은 정확합니다.

진심으로. 이메일 유효성 검사를 위해 이미 작성된 라이브러리를 사용해야합니다. 가장 좋은 방법은 해당 주소로 확인 이메일을 보내는 것입니다.

유효성을 검사하려는 전자 메일 주소는 System.Net.Mail 네임 스페이스를 사용하여 ASP.NET 웹 응용 프로그램에서 사람들 목록으로 전자 메일을 보내는 데 사용됩니다. 따라서 매우 복잡한 정규식을 사용하는 대신 주소에서 MailAddress 인스턴스를 만들려고합니다. 주소가 올바르게 구성되지 않으면 MailAddress 구성자가 예외를 처리합니다. 이런 식으로, 나는 최소한 이메일을 문 밖으로 가져올 수 있다는 것을 알고 있습니다. 물론 이것은 서버 측 유효성 검사이지만 최소한 어쨌든 필요합니다.

protected void emailValidator_ServerValidate(object source, ServerValidateEventArgs args)
{
    try
    {
        var a = new MailAddress(txtEmail.Text);
    }
    catch (Exception ex)
    {
        args.IsValid = false;
        emailValidator.ErrorMessage = "email: " + ex.Message;
    }
}

빠른 답변

입력 검증에 다음 정규식을 사용하십시오.

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)+

이 정규식과 일치하는 주소 :

• RFC 5321/5322를 엄격히 준수하는 로컬 부분 (예 : @ 기호 앞 부분)이 있어야합니다.
• 최소한 두 개의 레이블이있는 호스트 이름 인 도메인 부분 (예 : @ 기호 뒤의 부분)이 있으며 각 레이블은 최대 63 자입니다.

두 번째 제약은 RFC 5321/5322에 대한 제한입니다.

정교한 답변

전자 메일 주소를 인식하는 정규식을 사용하면 문서에서 전자 메일 주소를 검색하거나 사용자 입력을 확인하거나 데이터 저장소의 무결성 제약 조건과 같은 다양한 상황에서 유용 할 수 있습니다.

그러나 주소가 실제로 기존 사서함을 참조하는지 확인하려면 해당 주소로 메시지를 보내는 대신 사용할 수 없습니다. 주소가 문법적으로 정확한지 확인하려면 정규식을 사용할 수 있지만 ""@[]기존 사서함을 참조하지 않는 문법적으로 정확한 전자 메일 주소입니다.

이메일 주소의 구문은 다양한 RFC , 특히 RFC 822 및 RFC 5322 에서 정의되었습니다 . RFC 822는 "원본"표준으로, RFC 5322는 최신 표준으로 간주해야합니다. RFC 822에 정의 된 구문은 가장 관대하며 그 이후의 표준으로 인해 새로운 시스템이나 서비스가 더 이상 사용되지 않는 구문을 인식해야하지만 구문을 생성하지 않아야합니다.

이 대답에 나는 의미하는 "이메일 주소"를 할게요 addr-specRFC의 정의 (예로서 jdoe@example.org,하지만 "John Doe"<jdoe@example.org>,도 some-group:jdoe@example.org,mrx@exampel.org;).

RFC 구문을 정규식으로 변환하는 데 한 가지 문제점이 있습니다. 구문이 규칙적이지 않습니다! 무한 중첩은 정규 표현식으로 설명 할 수 없지만 무한 중첩 될 수있는 이메일 주소에 선택적 주석을 허용하기 때문입니다. 주석이 포함 된 주소를 스캔하거나 확인하려면 구문 분석기 또는보다 강력한 표현식이 필요합니다. Perl과 같은 언어에는 컨텍스트 프리 문법을 정규식과 같은 방식으로 설명하는 구문이 있습니다.이 답변에서는 주석을 무시하고 적절한 정규식 만 고려합니다.

RFC는 이메일 주소가 아닌 이메일 메시지의 구문을 정의합니다. 주소는 다양한 헤더 필드에 나타날 수 있으며 여기에서 주로 정의됩니다. 헤더 필드에 나타날 때 주소에는 어휘 토큰 사이에 공백, 주석 및 줄 바꿈이 포함될 수 있습니다. 그러나 의미 상 이것은 의미가 없습니다. 주소에서이 공백 등을 제거하면 의미 적으로 동등한 표준 표현 을 얻을 수 있습니다. 따라서의 표준 표현은 first. last (comment) @ [3.5.7.9]입니다 first.last@[3.5.7.9].

다른 목적으로 다른 구문을 사용해야합니다. 매우 오래된 문서에서 전자 메일 주소를 검색하려면 RFC 822에 정의 된 구문을 사용하는 것이 좋습니다. 반면에 사용자 입력의 유효성을 검사하려면 RFC 5322에 정의 된 구문으로, 정규 표현 만 허용합니다. 특정 사례에 적용 할 구문을 결정해야합니다.

ASCII 호환 문자 집합을 가정하여 POSIX "확장 된"정규식을이 답변에 사용합니다.

RFC 822

나는 다음 정규식에 도착했다. 나는 모든 사람들이 그것을 시도하고 깨뜨 리도록 초대합니다. 오탐 또는 오탐을 발견하면 의견에 게시하고 가능한 빨리 식을 수정하도록 노력하겠습니다.

([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]))*(\\\r)*")(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]))*(\\\r)*"))*@([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]))*(\\\r)*])(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]))*(\\\r)*]))*

나는 그것이 정오표를 포함하여 RFC 822를 완전히 준수한다고 생각합니다 . 표준 형식의 전자 메일 주소 만 인식합니다. 공백을 인식 (접기)하는 정규식에 대해서는 아래 파생을 참조하십시오.

파생은 내가 어떻게 표현에 도착했는지 보여줍니다. RFC의 모든 관련 문법 규칙을 표시된대로 정확하게 나열한 다음 해당 정규식을 나열합니다. 정오표가 게시 된 곳에서는 수정 된 문법 규칙 ( "erratum"으로 표시)에 대해 별도의 식을 제공하고 후속 정규식에서 업데이트 된 버전을 하위 식으로 사용합니다.

단락 3.1.4에 명시된 바와 같이. RFC 822의 선택적 선형 공백은 어휘 토큰 사이에 삽입 될 수 있습니다. 해당되는 경우이 규칙을 수용하도록 표현식을 확장하고 결과를 "opt-lwsp"로 표시했습니다.

CHAR        =  <any ASCII character>
            =~ .

CTL         =  <any ASCII control character and DEL>
            =~ [\x00-\x1F\x7F]

CR          =  <ASCII CR, carriage return>
            =~ \r

LF          =  <ASCII LF, linefeed>
            =~ \n

SPACE       =  <ASCII SP, space>
            =~  

HTAB        =  <ASCII HT, horizontal-tab>
            =~ \t

<">         =  <ASCII quote mark>
            =~ "

CRLF        =  CR LF
            =~ \r\n

LWSP-char   =  SPACE / HTAB
            =~ [ \t]

linear-white-space =  1*([CRLF] LWSP-char)
                   =~ ((\r\n)?[ \t])+

specials    =  "(" / ")" / "<" / ">" / "@" /  "," / ";" / ":" / "\" / <"> /  "." / "[" / "]"
            =~ [][()<>@,;:\\".]

quoted-pair =  "\" CHAR
            =~ \\.

qtext       =  <any CHAR excepting <">, "\" & CR, and including linear-white-space>
            =~ [^"\\\r]|((\r\n)?[ \t])+

dtext       =  <any CHAR excluding "[", "]", "\" & CR, & including linear-white-space>
            =~ [^][\\\r]|((\r\n)?[ \t])+

quoted-string  =  <"> *(qtext|quoted-pair) <">
               =~ "([^"\\\r]|((\r\n)?[ \t])|\\.)*"
(erratum)      =~ "(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"

domain-literal =  "[" *(dtext|quoted-pair) "]"
               =~ \[([^][\\\r]|((\r\n)?[ \t])|\\.)*]
(erratum)      =~ \[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]

atom        =  1*<any CHAR except specials, SPACE and CTLs>
            =~ [^][()<>@,;:\\". \x00-\x1F\x7F]+

word        =  atom / quoted-string
            =~ [^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"

domain-ref  =  atom

sub-domain  =  domain-ref / domain-literal
            =~ [^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]

local-part  =  word *("." word)
            =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"))*
(opt-lwsp)  =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")(((\r\n)?[ \t])*\.((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"))*

domain      =  sub-domain *("." sub-domain)
            =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*])(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]))*
(opt-lwsp)  =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*])(((\r\n)?[ \t])*\.((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]))*

addr-spec   =  local-part "@" domain
            =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*"))*@([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*])(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]))*
(opt-lwsp)  =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")((\r\n)?[ \t])*(\.((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*")((\r\n)?[ \t])*)*@((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*])(((\r\n)?[ \t])*\.((\r\n)?[ \t])*([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]|(\r\n)?[ \t]))*(\\\r)*]))*
(canonical) =~ ([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]))*(\\\r)*")(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|"(\n|(\\\r)*([^"\\\r\n]|\\[^\r]))*(\\\r)*"))*@([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]))*(\\\r)*])(\.([^][()<>@,;:\\". \x00-\x1F\x7F]+|\[(\n|(\\\r)*([^][\\\r\n]|\\[^\r]))*(\\\r)*]))*

RFC 5322

나는 다음 정규식에 도착했다. 나는 모든 사람들이 그것을 시도하고 깨뜨 리도록 초대합니다. 오탐 또는 오탐을 발견하면 의견에 게시하고 가능한 빨리 식을 수정하도록 노력하겠습니다.

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|\[[\t -Z^-~]*])

나는 그것이 정오표를 포함하여 RFC 5322를 완전히 준수한다고 생각합니다 . 표준 형식의 전자 메일 주소 만 인식합니다. 공백을 인식 (접기)하는 정규식에 대해서는 아래 파생을 참조하십시오.

파생은 내가 어떻게 표현에 도착했는지 보여줍니다. RFC의 모든 관련 문법 규칙을 표시된대로 정확하게 나열한 다음 해당 정규식을 나열합니다. 의미 상 관련이없는 (접기) 공백을 포함하는 규칙의 경우이 공백을 허용하지 않는 "(정규화 된)"으로 표시된 별도의 정규식을 제공합니다.

RFC의 모든 "obs-"규칙을 무시했습니다. 이는 정규 표현식이 RFC 5322를 엄격하게 준수하는 이메일 주소와 만 일치 함을 의미합니다. "오래된"주소와 일치해야하는 경우 ( "obs-"규칙을 포함한 느슨한 문법처럼) 이전 단락의 RFC 822 정규식 중 하나를 사용할 수 있습니다.

VCHAR           =   %x21-7E
                =~  [!-~]

ALPHA           =   %x41-5A / %x61-7A
                =~  [A-Za-z]

DIGIT           =   %x30-39
                =~  [0-9]

HTAB            =   %x09
                =~  \t

CR              =   %x0D
                =~  \r

LF              =   %x0A
                =~  \n

SP              =   %x20
                =~  

DQUOTE          =   %x22
                =~  "

CRLF            =   CR LF
                =~  \r\n

WSP             =   SP / HTAB
                =~  [\t ]

quoted-pair     =   "\" (VCHAR / WSP)
                =~  \\[\t -~]

FWS             =   ([*WSP CRLF] 1*WSP)
                =~  ([\t ]*\r\n)?[\t ]+

ctext           =   %d33-39 / %d42-91 / %d93-126
                =~  []!-'*-[^-~]

("comment" is left out in the regex)
ccontent        =   ctext / quoted-pair / comment
                =~  []!-'*-[^-~]|(\\[\t -~])

(not regular)
comment         =   "(" *([FWS] ccontent) [FWS] ")"

(is equivalent to FWS when leaving out comments)
CFWS            =   (1*([FWS] comment) [FWS]) / FWS
                =~  ([\t ]*\r\n)?[\t ]+

atext           =   ALPHA / DIGIT / "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "/" / "=" / "?" / "^" / "_" / "`" / "{" / "|" / "}" / "~"
                =~  [-!#-'*+/-9=?A-Z^-~]

dot-atom-text   =   1*atext *("." 1*atext)
                =~  [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*

dot-atom        =   [CFWS] dot-atom-text [CFWS]
                =~  (([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*

qtext           =   %d33 / %d35-91 / %d93-126
                =~  []!#-[^-~]

qcontent        =   qtext / quoted-pair
                =~  []!#-[^-~]|(\\[\t -~])

(erratum)
quoted-string   =   [CFWS] DQUOTE ((1*([FWS] qcontent) [FWS]) / FWS) DQUOTE [CFWS]
                =~  (([\t ]*\r\n)?[\t ]+)?"(((([\t ]*\r\n)?[\t ]+)?([]!#-[^-~]|(\\[\t -~])))+(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?)"(([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  "([]!#-[^-~ \t]|(\\[\t -~]))+"

dtext           =   %d33-90 / %d94-126
                =~  [!-Z^-~]

domain-literal  =   [CFWS] "[" *([FWS] dtext) [FWS] "]" [CFWS]
                =~  (([\t ]*\r\n)?[\t ]+)?\[((([\t ]*\r\n)?[\t ]+)?[!-Z^-~])*(([\t ]*\r\n)?[\t ]+)?](([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  \[[\t -Z^-~]*]

local-part      =   dot-atom / quoted-string
                =~  (([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?"(((([\t ]*\r\n)?[\t ]+)?([]!#-[^-~]|(\\[\t -~])))+(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?)"(([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+"

domain          =   dot-atom / domain-literal
                =~  (([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?\[((([\t ]*\r\n)?[\t ]+)?[!-Z^-~])*(([\t ]*\r\n)?[\t ]+)?](([\t ]*\r\n)?[\t ]+)?
(normalized)    =~  [-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|\[[\t -Z^-~]*]

addr-spec       =   local-part "@" domain
                =~  ((([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?"(((([\t ]*\r\n)?[\t ]+)?([]!#-[^-~]|(\\[\t -~])))+(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?)"(([\t ]*\r\n)?[\t ]+)?)@((([\t ]*\r\n)?[\t ]+)?[-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*(([\t ]*\r\n)?[\t ]+)?|(([\t ]*\r\n)?[\t ]+)?\[((([\t ]*\r\n)?[\t ]+)?[!-Z^-~])*(([\t ]*\r\n)?[\t ]+)?](([\t ]*\r\n)?[\t ]+)?)
(normalized)    =~  ([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|\[[\t -Z^-~]*])

일부 소스 (특히 w3c )는 RFC 5322가 로컬 부분 (즉, @ 기호 앞 부분)에서 너무 엄격하다고 주장합니다. "..", "a..b"및 "a."때문입니다. 사서함 이름으로 사용될 수 있지만 유효한 점 원자 는 아닙니다 . 은 RFC 그러나 않습니다 그들이 인용하는 경우를 제외 해,이 같은 지역 부품 수 있습니다. 따라서 대신에 의미 론적으로 동등한을 a..b@example.net작성해야합니다 "a..b"@example.net.

추가 제한 사항

SMTP ( RFC 5321에 정의 된 대로 )는 유효한 이메일 주소 세트 (또는 실제로는 사서함 이름)를 제한합니다. 이 엄격한 문법을 ​​적용하는 것이 합리적이므로 일치하는 전자 메일 주소를 실제로 전자 메일을 보내는 데 사용할 수 있습니다.

RFC 5321은 기본적으로 "로컬"부분 (예 : @ 기호 앞 부분) 만 남겨두고 도메인 부분 (예 : @ 기호 뒤에있는 부분)에서 더 엄격합니다. 도트 원자 대신 호스트 이름 만 허용하고 도메인 리터럴 대신 주소 리터럴을 허용합니다.

RFC 5321에 제시된 문법은 호스트 이름과 IP 주소 모두에있어 너무 관대합니다. 이 초안 과 RFC 1034 를 지침으로 사용하여 문제의 규칙을 "수정"할 자유를 얻었습니다 . 결과 정규식은 다음과 같습니다.

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)*|\[((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)|(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+)])

유스 케이스에 따라 정규 표현식에서 "일반 주소 리터럴"을 허용하지 않을 수도 있습니다. 또한 (?!IPv6:)"General-address-literal"부분이 잘못된 IPv6 주소와 일치하지 않도록하기 위해 최종 정규식에서 부정적 예측 을 사용했습니다 . 일부 정규식 프로세서는 부정적 예측을 지원하지 않습니다. |(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+전체 "일반 주소-리터럴"부분을 꺼내려면 정규식 에서 하위 문자열 을 제거하십시오 .

파생은 다음과 같습니다.

Let-dig         =   ALPHA / DIGIT
                =~  [0-9A-Za-z]

Ldh-str         =   *( ALPHA / DIGIT / "-" ) Let-dig
                =~  [0-9A-Za-z-]*[0-9A-Za-z]

(regex is updated to make sure sub-domains are max. 63 charactes long - RFC 1034 section 3.5)
sub-domain      =   Let-dig [Ldh-str]
                =~  [0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?

Domain          =   sub-domain *("." sub-domain)
                =~  [0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)*

Snum            =   1*3DIGIT
                =~  [0-9]{1,3}

(suggested replacement for "Snum")
ip4-octet       =   DIGIT / %x31-39 DIGIT / "1" 2DIGIT / "2" %x30-34 DIGIT / "25" %x30-35
                =~  25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9]

IPv4-address-literal    =   Snum 3("."  Snum)
                        =~  [0-9]{1,3}(\.[0-9]{1,3}){3}

(suggested replacement for "IPv4-address-literal")
ip4-address     =   ip4-octet 3("." ip4-octet)
                =~  (25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}

(suggested replacement for "IPv6-hex")
ip6-h16         =   "0" / ( (%x49-57 / %x65-70 /%x97-102) 0*3(%x48-57 / %x65-70 /%x97-102) )
                =~  0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}

(not from RFC)
ls32            =   ip6-h16 ":" ip6-h16 / ip4-address
                =~  (0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}

(suggested replacement of "IPv6-addr")
ip6-address     =                                      6(ip6-h16 ":") ls32
                    /                             "::" 5(ip6-h16 ":") ls32
                    / [                 ip6-h16 ] "::" 4(ip6-h16 ":") ls32
                    / [ *1(ip6-h16 ":") ip6-h16 ] "::" 3(ip6-h16 ":") ls32
                    / [ *2(ip6-h16 ":") ip6-h16 ] "::" 2(ip6-h16 ":") ls32
                    / [ *3(ip6-h16 ":") ip6-h16 ] "::"   ip6-h16 ":"  ls32
                    / [ *4(ip6-h16 ":") ip6-h16 ] "::"                ls32
                    / [ *5(ip6-h16 ":") ip6-h16 ] "::"   ip6-h16
                    / [ *6(ip6-h16 ":") ip6-h16 ] "::"
                =~  (((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::

IPv6-address-literal    =   "IPv6:" ip6-address
                        =~  IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)

Standardized-tag        =   Ldh-str
                        =~  [0-9A-Za-z-]*[0-9A-Za-z]

dcontent        =   %d33-90 / %d94-126
                =~  [!-Z^-~]

General-address-literal =   Standardized-tag ":" 1*dcontent
                        =~  [0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+

address-literal =   "[" ( IPv4-address-literal / IPv6-address-literal / General-address-literal ) "]"
                =~  \[((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)|(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+)]

Mailbox         =   Local-part "@" ( Domain / address-literal )
                =~  ([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)*|\[((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)|(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+)])

사용자 입력 검증

일반적인 사용 사례는 사용자 입력 유효성 검사입니다 (예 : html 양식). 이 경우 일반적으로 주소 리터럴을 배제하고 호스트 이름에 두 개 이상의 레이블을 요구하는 것이 합리적입니다. 이전 섹션에서 개선 된 RFC 5321 정규식을 기본으로 사용하면 결과는 다음과 같습니다.

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)+

예를 들어 따옴표로 묶은 문자열을 제외하여 로컬 부분을 더 제한하지 않는 것이 좋습니다. 일부 호스트가 어떤 종류의 사서함 이름 (예 : "a..b"@example.net또는 "a b"@example.net)을 허용하는지 알 수 없기 때문 입니다.

또한 리터럴 최상위 도메인 목록에 대해 명시 적으로 유효성 검사를하거나 길이 제약 조건을 적용하는 것도 권장하지 않습니다 ( ".museum"이 무효화 된 방법 기억 [a-z]{2,4}).

([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?\.)*(net|org|com|info|기타...)

명시적인 최상위 도메인 유효성 검사 경로를 내려 가기로 결정한 경우 정규식을 최신 상태로 유지하십시오.

추가 고려 사항

@ 기호 뒤의 도메인 부분에서 호스트 이름 만 허용하는 경우 위의 정규 표현식은 최대 63 자의 레이블 만 허용합니다. 그러나 전체 호스트 이름이 최대 253 자 (점 포함) 여야한다는 사실을 강요하지 않습니다. 이 제약 조건은 여전히 ​​규칙적으로 말하지만이 규칙을 포함하는 정규식을 만드는 것은 불가능합니다.

특히 입력 유효성 검증을 위해 정규식을 사용할 때 고려해야 할 또 다른 사항은 사용자에게 피드백입니다. 사용자가 잘못된 주소를 입력하면 간단한 "구문 적으로 잘못된 주소"보다 약간 더 많은 피드백을 제공하는 것이 좋습니다. "vanilla"정규식으로는 불가능합니다.

이 두 가지 고려 사항은 주소를 구문 분석하여 해결할 수 있습니다. 호스트 이름에 대한 추가 길이 제한은 경우에 따라이를 확인하는 추가 정규식을 사용하고 주소를 두 표현식과 일치 시켜서 해결할 수도 있습니다.

이 답변의 정규식 중 어느 것도 성능에 최적화되어 있지 않습니다. 성능이 문제인 경우 선택한 정규식을 최적화 할 수 있는지 (및 방법) 확인해야합니다.

그물에 이것의 많은 예가 있습니다 (그리고 RFC를 완전히 검증하는 것조차 생각합니다-그러나 메모리가 제공된다면 수십 / 수백 줄입니다). 사람들은 이런 종류의 일을 확인하는 경향이 있습니다. 왜 @ 하나 이상이 있는지 확인하지 않는 것이 좋습니다. 간단한 최소 길이를 충족시킵니다. 가짜 이메일을 입력하고 여전히 유효한 정규식과 일치하는 것은 쉽지 않습니다. 나는 거짓 긍정이 거짓 부정보다 낫다고 생각합니다.

허용되는 문자를 결정할 때는 아포스트로피와 하이픈을 넣은 친구를 기억하십시오. 회사가 HR 시스템에서 내 이름을 사용하여 내 이메일 주소를 생성한다는 사실을 통제 할 수 없습니다. 내성에 아포스트로피가 포함되어 있습니다. 내 이메일 주소가 "유효하지 않다"는 사실로 웹 사이트와의 상호 작용이 차단 된 횟수를 알려 드릴 수 없습니다.

이 정규식은 Perl의 Email :: Valid 라이브러리에 있습니다. 나는 그것이 가장 정확하다고 생각합니다. 그것은 822 개 모두와 일치합니다. 그리고 그것은 O'Reilly 책의 정규식을 기반으로합니다.

정규식 마스터 링 ( http://www.ora.com/catalog/regexp/ ) 에서 Jeffrey Friedl의 예제를 사용하여 작성된 정규식 .

$RFC822PAT = <<'EOF';
[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\
xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xf
f\n\015()]*)*\)[\040\t]*)*(?:(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\x
ff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015
"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\
xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80
-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*
)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\
\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\
x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x8
0-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n
\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x
80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^
\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040
\t]*)*)*@[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([
^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\
\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\
x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-
\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()
]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\
x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\04
0\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\
n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\
015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?!
[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\
]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\
x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\01
5()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*|(?:[^(\040)<>@,;:".
\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]
)|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[^
()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037]*(?:(?:\([^\\\x80-\xff\n\0
15()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][
^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)|"[^\\\x80-\xff\
n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[^()<>@,;:".\\\[\]\
x80-\xff\000-\010\012-\037]*)*<[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?
:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-
\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:@[\040\t]*
(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015
()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()
]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\0
40)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\
[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\
xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*
)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80
-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x
80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t
]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\
\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])
*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x
80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80
-\xff\n\015()]*)*\)[\040\t]*)*)*(?:,[\040\t]*(?:\([^\\\x80-\xff\n\015(
)]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\
\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*@[\040\t
]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\0
15()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015
()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(
\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|
\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80
-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()
]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x
80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^
\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040
\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".
\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff
])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\
\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x
80-\xff\n\015()]*)*\)[\040\t]*)*)*)*:[\040\t]*(?:\([^\\\x80-\xff\n\015
()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\
\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)?(?:[^
(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-
\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\
n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|
\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))
[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff
\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\x
ff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(
?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\
000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\
xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\x
ff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)
*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*@[\040\t]*(?:\([^\\\x80-\x
ff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-
\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)
*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\
]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\]
)[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-
\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\x
ff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(
?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80
-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<
>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x8
0-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:
\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]
*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)
*\)[\040\t]*)*)*>)
EOF

PHP로 작성하는 동안 이메일에 PHP 내장 유효성 검사를 사용하는 것이 좋습니다.

filter_var($value, FILTER_VALIDATE_EMAIL)

5.3.6보다 낮은 php 버전을 실행하는 경우이 문제에 유의하십시오 : https://bugs.php.net/bug.php?id=53091

이 buid-in 유효성 검사 작동 방식에 대한 자세한 내용은 다음을 참조하십시오. PHP의 filter_var FILTER_VALIDATE_EMAIL이 실제로 작동합니까?

Cal Henderson (Flickr)은 PHP로 Parsing Email Adresses 라는 기사를 작성했으며 올바른 RFC (2) 822 호환 이메일 주소 구문 분석을 수행하는 방법을 보여줍니다. cc 라이센스 가 있는 php , python 및 ruby 에서 소스 코드를 얻을 수도 있습니다 .

다른 사람이 이미 더 나은 버전을 만들었을 가능성이 있기 때문에 나는 내 자신의 정규 표현식으로 작성하는 것을 귀찮게하지 않습니다. 나는 항상 regexlib 를 사용하여 원하는 것을 찾습니다.

실제로 사용할 수있는 것은 없습니다.
내에서 몇 가지 문제 논의 거기에 이메일 주소 확인을위한 PHP 라이브러리를 대답을? 전자 메일 주소의 정규식 인식에 대해서도 논의되어 있습니까?

간단히 말해서, 사용 가능한 단일 정규 표현식이 올바른 작업을 수행 할 것으로 기대하지 마십시오. 그리고 최고의 정규 표현식은 전자 메일의 유효성이 아닌 구문의 유효성을 검사합니다 (jhohn@example.com은 정확하지만 반송 될 것입니다 ...).

유효한 전자 메일 주소를 적어도 거부하지 않는 간단한 정규 표현식은 무언가를 확인한 다음 @ 기호를 사용한 다음 마침표와 적어도 2 개의 무언가를 확인하는 것입니다. 아무것도 거부하지 않지만 사양을 검토 한 후 유효하고 거부되는 이메일을 찾을 수 없습니다.

이메일 = ~ /.+@[^@]+\.[^@]{2,}$/

jQuery Validation 플러그인에서 사용하는 것을 사용할 수 있습니다.

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

이메일 주소 확인을위한 최상의 정규식에 대한 가장 포괄적 인 평가는이 링크를 참조하십시오. " 정규식을 검증하는 이메일 주소 비교 "

다음은 참조 용으로 현재 최상위 표현식입니다.

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

비 라틴어 (중국어, 아랍어, 그리스어, 히브리어, 키릴 어 등) 도메인 이름은 가까운 시일 내에 허용됩니다 . 이 문자들은 반드시 [a-z]/inor 로 덮여 있지 않기 때문에 모든 사람이 사용하는 이메일 정규식을 변경해야합니다 \w. 그들은 모두 실패합니다.

결국, 전자 메일 주소를 확인 하는 가장 좋은 방법은 실제로 해당 주소로 전자 메일을 보내 주소를 확인하는 것입니다. 이메일 주소가 사용자 인증 (등록 / 로그인 등)의 일부인 경우 사용자 활성화 시스템과 완벽하게 결합 할 수 있습니다. 즉, 고유 한 활성화 키가있는 링크가 포함 된 이메일을 지정된 이메일 주소로 보내고 사용자가 이메일의 링크를 사용하여 새로 만든 계정을 활성화 한 경우에만 로그인을 허용합니다.

정규식의 목적이 UI에서 지정된 이메일 주소가 올바른 형식으로 보이지 않음을 사용자에게 신속하게 알리는 것이라면 기본적으로 다음 정규식과 일치하는지 확인하는 것이 가장 좋습니다.

^([^.@]+)(\.[^.@]+)*@([^.@]+\.)+([^.@]+)$

그렇게 간단합니다. 왜 지구상에서 이름과 도메인에 사용 된 캐릭터에 관심이 있습니까? 서버가 아닌 유효한 이메일 주소를 입력하는 것은 고객의 책임입니다. 클라이언트가 와 같은 구문 상 유효한 이메일 주소를 입력하더라도 이것이 올바른 이메일 주소 aa@bb.cc임을 보장하지는 않습니다. 아무도 정규식으로 그것을 감당할 수 없습니다.

HTML5 스펙은 제안 이메일 주소를 검증하기위한 간단한 정규식 :

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

이것은 의도적으로 RFC 5322를 준수하지 않습니다 .

참고 : 이 요구 사항은 RFC 5322 의 고의적 인 위반 으로 , 동시에 너무 엄격한 ( 문자 앞 ), 너무 모호한 ( 문자 뒤에 ), 너무 느슨한 (주석, 공백 문자 허용) 이메일 주소에 대한 구문을 정의합니다 . 대부분의 사용자에게 익숙하지 않은 방식으로 인용 된 문자열)을 실제로 사용하십시오.@@

RFC 3696 에라타 1690에 따라 총 길이도 254 자로 제한 될 수 있습니다 .

생생한 시연을 위해 다음 몬스터는 훌륭하지만 구문 상 유효한 모든 이메일 주소를 올바르게 인식하지 못합니다. 중첩 된 주석은 최대 4 단계까지 인식합니다.

이것은 파서의 작업이지만 주소가 구문 적으로 유효한 경우에도 여전히 전달할 수 없습니다. 때때로 당신은 "이봐 요, ee-us!"

// derivative of work with the following copyright and license:
// Copyright (c) 2004 Casey West.  All rights reserved.
// This module is free software; you can redistribute it and/or
// modify it under the same terms as Perl itself.

// see http://search.cpan.org/~cwest/Email-Address-1.80/

private static string gibberish = @"
(?-xism:(?:(?-xism:(?-xism:(?-xism:(?-xism:(?-xism:(?-xism:\
s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^
\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))
|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+
|\s+)*[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s]+(?-xism:(?-xism:\
s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^
\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))
|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+
|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(
?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?
:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x
0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*<DQ>(?-xism:(?-xism:[
^\\<DQ>])|(?-xism:\\(?-xism:[^\x0A\x0D])))+<DQ>(?-xism:(?-xi
sm:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xis
m:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\
]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\
s*)+|\s+)*))+)?(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?
-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:
\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[
^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*<(?-xism:(?-xi
sm:(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^(
)\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(
?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))
|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()<
>\[\]:;@\,.<DQ>\s]+(?:\.[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s]
+)*)(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))
|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:
(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s
*\)\s*))+)*\s*\)\s*)+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((?
:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x
0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xi
sm:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*
<DQ>(?-xism:(?-xism:[^\\<DQ>])|(?-xism:\\(?-xism:[^\x0A\x0D]
)))+<DQ>(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\
]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-x
ism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+
)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*))\@(?-xism:(?-xism:(?-xism:(
?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?
-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^
()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s
*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s]+(
?:\.[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s]+)*)(?-xism:(?-xism:
\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[
^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+)
)|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)
+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:
(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((
?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\
x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*\[(?:\s*(?-xism:(?-x
ism:[^\[\]\\])|(?-xism:\\(?-xism:[^\x0A\x0D])))+)*\s*\](?-xi
sm:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:
\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(
?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+
)*\s*\)\s*)+|\s+)*)))>(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-
xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\
s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^
\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*))|(?-xism:(?-x
ism:(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^
()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*
(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D])
)|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()
<>\[\]:;@\,.<DQ>\s]+(?:\.[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s
]+)*)(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+)
)|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism
:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\
s*\)\s*))+)*\s*\)\s*)+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((
?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\
x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-x
ism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)
*<DQ>(?-xism:(?-xism:[^\\<DQ>])|(?-xism:\\(?-xism:[^\x0A\x0D
])))+<DQ>(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\
\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-
xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)
+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*))\@(?-xism:(?-xism:(?-xism:
(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(
?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[
^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\
s*\)\s*)+|\s+)*(?-xism:[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s]+
(?:\.[^\x00-\x1F\x7F()<>\[\]:;@\,.<DQ>\s]+)*)(?-xism:(?-xism
:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:
[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+
))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*
)+|\s+)*)|(?-xism:(?-xism:(?-xism:\s*\((?:\s*(?-xism:(?-xism
:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\(
(?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A
\x0D]))|)+)*\s*\)\s*))+)*\s*\)\s*)+|\s+)*\[(?:\s*(?-xism:(?-
xism:[^\[\]\\])|(?-xism:\\(?-xism:[^\x0A\x0D])))+)*\s*\](?-x
ism:(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism
:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:\s*(?-xism:(?-xism:
(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|)+)*\s*\)\s*))
+)*\s*\)\s*)+|\s+)*))))(?-xism:\s*\((?:\s*(?-xism:(?-xism:(?
>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0D]))|(?-xism:\s*\((?:
\s*(?-xism:(?-xism:(?>[^()\\]+))|(?-xism:\\(?-xism:[^\x0A\x0
D]))|)+)*\s*\)\s*))+)*\s*\)\s*)*)"
  .Replace("<DQ>", "\"")
  .Replace("\t", "")
  .Replace(" ", "")
  .Replace("\r", "")
  .Replace("\n", "");

private static Regex mailbox =
  new Regex(gibberish, RegexOptions.ExplicitCapture); 

공식 표준 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])+)\])

Java에서 사용하려면 정말 쉽습니다.

import java.util.regex.*;

class regexSample 
{
   public static void main(String args[]) 
   {
      //Input the string for validation
      String email = "xyz@hotmail.com";

      //Set the email pattern string
      Pattern p = Pattern.compile(" (?:[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])+)\\]");

      //Match the given string with the pattern
      Matcher m = p.matcher(email);

      //check whether match is found 
      boolean matchFound = m.matches();

      if (matchFound)
        System.out.println("Valid Email Id.");
      else
        System.out.println("Invalid Email Id.");
   }
}

내가 사용하는 PHP는 다음과 같습니다. 나는 다른 주석 작성자가 선언 한 것처럼 "거짓 긍정이 거짓 긍정보다 낫다"라는 정신 으로이 솔루션을 선택했으며 응답 시간을 늘리고 서버로드를 유지하는 것과 관련하여 서버 리소스를 낭비 할 필요가 없습니다. 이것이 가장 간단한 사용자 오류를 제거 할 때 정규 표현식. 원하는 경우 언제든지 테스트 이메일을 보내서이를 확인할 수 있습니다.

function validateEmail($email) {
  return (bool) stripos($email,'@');
}

RFC 5322 표준 :

dot-atom local-part, quoted-string local-part, 쓸모없는 (dot-atom 및 인용 문자열 혼합) local-part, 도메인 이름 도메인 (IPv4, IPv6 및 IPv4 매핑 된 IPv6 주소) 도메인 리터럴 도메인을 허용합니다. 그리고 (중첩 된) CFWS.

'/^(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){255,})(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){65,}@)((?>(?>(?>((?>(?>(?>\x0D\x0A)?[\t ])+|(?>[\t ]*\x0D\x0A)?[\t ]+)?)(\((?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-\'*-\[\]-\x7F]|\\\[\x00-\x7F]|(?3)))*(?2)\)))+(?2))|(?2))?)([!#-\'*+\/-9=?^-~-]+|"(?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\x7F]))*(?2)")(?>(?1)\.(?1)(?4))*(?1)@(?!(?1)[a-z0-9-]{64,})(?1)(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)(?>(?1)\.(?!(?1)[a-z0-9-]{64,})(?1)(?5)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?6)){7}|(?!(?:.*[a-f0-9][:\]]){8,})((?6)(?>:(?6)){0,6})?::(?7)?))|(?>(?>IPv6:(?>(?6)(?>:(?6)){5}:|(?!(?:.*[a-f0-9]:){6,})(?8)?::(?>((?6)(?>:(?6)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?>\.(?9)){3}))\])(?1)$/isD'

RFC 5321 표준 :

도트 원자 로컬 부분, 따옴표로 묶은 문자열 로컬 부분, 도메인 이름 도메인 및 (IPv4, IPv6 및 IPv4 매핑 IPv6 주소) 도메인 리터럴 도메인을 허용합니다.

'/^(?!(?>"?(?>\\\[ -~]|[^"])"?){255,})(?!"?(?>\\\[ -~]|[^"]){65,}"?@)(?>([!#-\'*+\/-9=?^-~-]+)(?>\.(?1))*|"(?>[ !#-\[\]-~]|\\\[ -~])*")@(?!.*[^.]{64,})(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)(?>\.(?2)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?3)){7}|(?!(?:.*[a-f0-9][:\]]){8,})((?3)(?>:(?3)){0,6})?::(?4)?))|(?>(?>IPv6:(?>(?3)(?>:(?3)){5}:|(?!(?:.*[a-f0-9]:){6,})(?5)?::(?>((?3)(?>:(?3)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?>\.(?6)){3}))\])$/iD'

기본:

도트 원자 로컬 부분 및 도메인 이름 도메인을 허용합니다 (TLD가 2-6 자의 알파벳 문자로 제한된 도메인 이름 레이블을 두 개 이상 필요).

"/^(?!.{255,})(?!.{65,}@)([!#-'*+\/-9=?^-~-]+)(?>\.(?1))*@(?!.*[^.]{64,})(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?\.){1,126}[a-z]{2,6}$/iD"

4 문자 TLD를 "수용 할 수 없습니다". .info 및 .name 에서는 사람들을 금지 하고 길이 제한은 .travel 및 .museum을 중지 하지만 그렇습니다. 2 자 TLD 및 3 자 TLD보다 덜 일반적입니다.

대문자 알파벳도 허용해야합니다. 이메일 시스템은 로컬 부분과 도메인 부분을 정규화합니다.

정규식 도메인 부분의 경우 도메인 이름은 '-'로 시작할 수 없으며 '-'로 끝날 수 없습니다. 대시는 사이에만있을 수 있습니다.

PEAR 라이브러리를 사용한 경우 메일 기능을 확인하십시오 (정확한 이름 / 라이브러리를 잊어 버렸습니다). 하나의 함수를 호출하여 이메일 주소를 검증 할 수 있으며 RFC822의 정의에 따라 이메일 주소를 검증합니다.

public bool ValidateEmail(string sEmail)
{
    if (sEmail == null)
    {
        return false;
    }

    int nFirstAT = sEmail.IndexOf('@');
    int nLastAT = sEmail.LastIndexOf('@');

    if ((nFirstAT > 0) && (nLastAT == nFirstAT) && (nFirstAT < (sEmail.Length - 1)))
    {
        return (Regex.IsMatch(sEmail, @"^[a-z|0-9|A-Z]*([_][a-z|0-9|A-Z]+)*([.][a-z|0-9|A-Z]+)*([.][a-z|0-9|A-Z]+)*(([_][a-z|0-9|A-Z]+)*)?@[a-z][a-z|0-9|A-Z]*\.([a-z][a-z|0-9|A-Z]*(\.[a-z][a-z|0-9|A-Z]*)?)$"));
    }
    else
    {
        return false;
    }
}