regex - regulares - ¿Cómo validar una dirección de correo electrónico usando una expresión regular?

validar dominio de correo javascript (30)

Respuesta rápida

Utilice la siguiente expresión regular para la validación de entrada:

([-!#-''*+/-9=?AZ^-~]+(/.[-!#-''*+/-9=?AZ^-~]+)*|"([]!#-[^-~ /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])?)+

Direcciones emparejadas por esta expresión regular:

tener una parte local (es decir, la parte antes del signo-@) que cumple estrictamente con RFC 5321/5322,
tener una parte de dominio (es decir, la parte después de @ -sign) que es un nombre de host con al menos dos etiquetas, cada una de las cuales tiene una longitud máxima de 63 caracteres.

La segunda restricción es una restricción en RFC 5321/5322.

Respuesta elaborada

El uso de una expresión regular que reconozca las direcciones de correo electrónico podría ser útil en diversas situaciones: por ejemplo, buscar direcciones de correo electrónico en un documento, validar la entrada del usuario o como una restricción de integridad en un depósito de datos.

Sin embargo, debe tener en cuenta que si desea averiguar si la dirección realmente se refiere a un buzón existente, no hay sustituto para enviar un mensaje a la dirección. Si solo desea verificar si una dirección es gramaticalmente correcta, entonces podría usar una expresión regular, pero tenga en cuenta que ""@[]es una dirección de correo electrónico gramaticalmente correcta que ciertamente no se refiere a un buzón existente.

La sintaxis de las direcciones de correo electrónico se ha definido en varios RFCs , especialmente RFC 822 y RFC 5322 . RFC 822 debe verse como el estándar "original" y RFC 5322 como el estándar más reciente. La sintaxis definida en RFC 822 es la más indulgente y las normas subsiguientes han restringido aún más la sintaxis, donde los sistemas o servicios más nuevos deben reconocer la sintaxis obsoleta, pero nunca producirla.

En esta respuesta, tomaré "dirección de correo electrónico" addr-speccomo la definida en los RFC (es decir [email protected], pero no "John Doe"<[email protected]>, ni some-group:[email protected],[email protected];).

Hay un problema con la traducción de las sintaxis RFC a expresiones regulares: ¡las sintaxis no son regulares! Esto se debe a que permiten comentarios opcionales en direcciones de correo electrónico que se pueden anidar infinitamente, mientras que el anidamiento infinito no se puede describir con una expresión regular. Para buscar o validar direcciones que contienen comentarios, necesita un analizador o expresiones más potentes. (Tenga en cuenta que los lenguajes como Perl tienen construcciones para describir las gramáticas libres de contexto de una manera similar a una expresión regular). En esta respuesta, ignoraré los comentarios y solo consideraré las expresiones regulares adecuadas.

Los RFC definen sintaxis para mensajes de correo electrónico, no para direcciones de correo electrónico como tales. Las direcciones pueden aparecer en varios campos de encabezado y aquí es donde se definen principalmente. Cuando aparecen en los campos de encabezado, las direcciones pueden contener (entre tokens léxicos) espacios en blanco, comentarios e incluso saltos de línea. Semánticamente esto no tiene significado sin embargo. Al eliminar este espacio en blanco, etc. de una dirección, se obtiene una representación canónica semánticamente equivalente . Así, la representación canónica de first. last (comment) @ [3.5.7.9]es first.last@[3.5.7.9].

Deben utilizarse diferentes sintaxis para diferentes propósitos. Si desea buscar direcciones de correo electrónico en un documento (posiblemente muy antiguo), puede ser una buena idea usar la sintaxis como se define en RFC 822. Por otra parte, si desea validar la entrada del usuario, puede usar la la sintaxis definida en RFC 5322, probablemente solo acepte representaciones canónicas. Debe decidir qué sintaxis se aplica a su caso específico.

Yo uso POSIX "extendido" expresiones regulares en esta respuesta, asumiendo un conjunto de caracteres compatible con ASCII.

RFC 822

Llegué a la siguiente expresión regular. Invito a todos a tratar de romperlo. Si encuentra algún falso positivo o falso negativo, publíquelo en un comentario e intentaré corregir la expresión lo antes posible.

([^][()<>@,;://". /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)*]))*

Creo que es totalmente compatible con RFC 822 incluyendo la errata . Sólo reconoce las direcciones de correo electrónico en su forma canónica. Para una expresión regular que reconoce los espacios en blanco (plegables), consulte la derivación a continuación.

La derivación muestra cómo llegué a la expresión. Enumero todas las reglas gramaticales relevantes de la RFC exactamente como aparecen, seguidas de la expresión regular correspondiente. Cuando se ha publicado una errata, doy una expresión separada para la regla de gramática corregida (marcada "errata") y utilizo la versión actualizada como una subexpresión en expresiones regulares posteriores.

Como se indica en el párrafo 3.1.4. de RFC 822 se puede insertar un espacio en blanco lineal opcional entre las fichas léxicas. Donde corresponda, expandí las expresiones para acomodar esta regla y marqué el resultado con "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=?AZ^-~]+(/.[-!#-''*+/-9=?AZ^-~]+)*|"([]!#-[^-~ /t]|(//[/t -~]))+")@([-!#-''*+/-9=?AZ^-~]+(/.[-!#-''*+/-9=?AZ^-~]+)*|/[[/t -Z^-~]*])

Creo que es totalmente compatible con RFC 5322 incluyendo la errata . Sólo reconoce las direcciones de correo electrónico en su forma canónica. Para una expresión regular que reconoce los espacios en blanco (plegables), consulte la derivación a continuación.

La derivación muestra cómo llegué a la expresión. Enumero todas las reglas gramaticales relevantes de la RFC exactamente como aparecen, seguidas de la expresión regular correspondiente. Para las reglas que incluyen espacios en blanco semánticamente irrelevantes (plegables), doy un regex separado marcado "(normalizado)" que no acepta este espacio en blanco.

Ignoré todas las reglas "obs-" del RFC. Esto significa que las expresiones regulares solo coinciden con las direcciones de correo electrónico que son estrictamente compatibles con RFC 5322. Si tiene que coincidir con las direcciones "antiguas" (como lo hace la gramática más flexible que incluyen las reglas "obs-"), puede usar una de las expresiones regulares RFC 822 del párrafo anterior.

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^-~]*])

Tenga en cuenta que algunas fuentes (en particular, w3c ) afirman que RFC 5322 es demasiado estricto en la parte local (es decir, en la parte antes del signo-@). Esto se debe a que "..", "a..b" y "a". no son átomos de punto válidos, mientras que pueden usarse como nombres de buzones. El RFC, sin embargo, no permiten partes locales como estos, excepto en que tienen que ser citado. Así que en lugar de [email protected]ti deberías escribir "a..b"@example.net, que es semánticamente equivalente.

Restricciones adicionales

SMTP (como se define en RFC 5321 ) restringe aún más el conjunto de direcciones de correo electrónico válidas (o en realidad: nombres de buzones). Parece razonable imponer esta gramática más estricta, de modo que la dirección de correo electrónico coincidente pueda usarse para enviar un correo electrónico.

RFC 5321 básicamente deja solo la parte "local" (es decir, la parte antes del signo @), pero es más estricta en la parte del dominio (es decir, la parte después del signo @). Solo permite nombres de host en lugar de puntos-átomos y literales de direcciones en lugar de literales de dominio.

La gramática presentada en RFC 5321 es demasiado indulgente cuando se trata de nombres de host y direcciones IP. Me tomé la libertad de "corregir" las reglas en cuestión, utilizando este borrador y el RFC 1034 como pautas. Aquí está la expresión regular resultante.

([-!#-''*+/-9=?AZ^-~]+(/.[-!#-''*+/-9=?AZ^-~]+)*|"([]!#-[^-~ /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^-~]+)])

Tenga en cuenta que, dependiendo del caso de uso, es posible que no desee permitir un "literal de dirección general" en su expresión regular. También tenga en cuenta que usé un lookahead negativo (?!IPv6:)en la expresión regular final para evitar que la parte "General-literal-address-literal" coincida con las direcciones IPv6 mal formadas. Algunos procesadores de expresiones regulares no admiten lookahead negativo. Elimine la subcadena |(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+de la expresión regular si desea eliminar toda la parte "General-address-literal".

Aquí está la derivación:

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

Validación de entrada de usuario

Un caso de uso común es la validación de entrada del usuario, por ejemplo, en un formulario html. En ese caso, por lo general es razonable excluir los literales de direcciones y requerir al menos dos etiquetas en el nombre de host. Tomando como base la expresión regular RFC 5321 mejorada de la sección anterior, la expresión resultante sería:

([-!#-''*+/-9=?AZ^-~]+(/.[-!#-''*+/-9=?AZ^-~]+)*|"([]!#-[^-~ /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])?)+

No recomiendo restringir aún más la parte local, por ejemplo, al excluir cadenas entrecomilladas, ya que no sabemos qué tipo de nombres de buzón permiten algunos hosts (como "a..b"@example.neto incluso "ab"@example.net).

Tampoco recomiendo validar explícitamente contra una lista de dominios de nivel superior literal o incluso imponer restricciones de longitud (recuerde cómo se invalidó ".museum" [az]{2,4}), pero si debe:

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

Asegúrese de mantener su expresión regular actualizada si decide seguir el camino de la validación explícita de dominio de nivel superior.

Consideraciones adicionales

Cuando solo se aceptan nombres de host en la parte del dominio (después de @ -sign), las expresiones regulares anteriores solo aceptan etiquetas con un máximo de 63 caracteres, como deberían. Sin embargo, no imponen el hecho de que el nombre completo del host debe tener una longitud máxima de 253 caracteres (incluidos los puntos). Si bien esta restricción es estrictamente hablando todavía regular, no es factible hacer una expresión regular que incorpore esta regla.

Otra consideración, especialmente cuando se usan las expresiones regulares para la validación de entrada, es la retroalimentación al usuario. Si un usuario ingresa una dirección incorrecta, sería bueno dar un poco más de retroalimentación que una simple "dirección sintácticamente incorrecta". Con las expresiones regulares de "vainilla" esto no es posible.

Estas dos consideraciones podrían abordarse analizando la dirección. En algunos casos, la restricción de longitud adicional en los nombres de host también podría abordarse mediante el uso de una expresión regular adicional que la verifique y la coincidencia de la dirección con ambas expresiones.

Ninguna de las expresiones regulares en esta respuesta está optimizada para el rendimiento. Si el rendimiento es un problema, debe ver si (y cómo) se puede optimizar la expresión regular de su elección.

Con el paso de los años, poco a poco he desarrollado una expresión regular que valida la mayoría de las direcciones de correo electrónico correctamente, asumiendo que no usan una dirección IP como parte del servidor.

Lo uso en varios programas PHP, y funciona la mayor parte del tiempo. Sin embargo, de vez en cuando me contacta alguien que tiene problemas con un sitio que lo usa, y termino teniendo que hacer algunos ajustes (más recientemente me di cuenta de que no estaba permitiendo TLD de 4 caracteres).

¿Cuál es la mejor expresión regular que tiene o ha visto para validar correos electrónicos?

He visto varias soluciones que usan funciones que usan varias expresiones más cortas, pero prefiero tener una expresión larga y compleja en una función simple en lugar de varias expresiones cortas en una función más compleja.

Depende de lo que quiere decir con mejor: si está hablando de detectar cada dirección de correo electrónico válida, use lo siguiente:

(?:(?:/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 ) Si está buscando algo más simple pero que detecte la mayoría de las direcciones de correo electrónico válidas, intente algo como:

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

EDITAR: Desde el enlace:

Esta expresión regular solo validará las direcciones a las que se eliminaron los comentarios y se reemplazaron con espacios en blanco (esto lo hace el módulo).

Es fácil en Perl 5.10 o más reciente:

/(?(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

Esta pregunta se hace mucho, pero creo que debería retroceder y preguntarse por qué quiere validar las direcciones de correo electrónico de manera sintáctica. ¿Cuál es el beneficio realmente?

No detectará errores tipográficos comunes.
No evita que las personas ingresen direcciones de correo electrónico inválidas o inventadas, o que ingresen la dirección de otra persona.

Si desea validar que un correo electrónico es correcto, no tiene más remedio que enviar un correo electrónico de confirmación y que el usuario responda a eso. En muchos casos, tendrá que enviar un correo de confirmación de todos modos por razones de seguridad o por razones éticas (por lo que no puede, por ejemplo, contratar a alguien para un servicio contra su voluntad).

La expresión regular totalmente compatible con RFC 822 es ineficiente y oscura debido a su longitud. Afortunadamente, el RFC 822 fue reemplazado dos veces y la especificación actual para las direcciones de correo electrónico es RFC 5322 . RFC 5322 conduce a una expresión regular que puede entenderse si se estudia durante unos minutos y es lo suficientemente eficiente para su uso real.

Se puede encontrar una expresión regular compatible con RFC 5322 en la parte superior de la página en http://emailregex.com/ pero utiliza el patrón de dirección IP que está flotando en Internet con un error que permite 00 para cualquiera de los valores decimales de byte sin firmar en una dirección delimitada por puntos, que es ilegal. El resto parece ser consistente con la gramática RFC 5322 y pasa varias pruebas utilizando grep -Po , incluidos los casos de nombres de dominio, direcciones IP, nombres grep -Po y nombres de cuentas con y sin comillas.

Al corregir el error 00 en el patrón de IP, obtenemos una expresión regular que funciona y es bastante rápida. (Raspe la versión renderizada, no el markdown, para el código real).

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

Aquí está el diagram de la máquina de estados finitos para la expresión regular anterior que es más claro que la expresión regular en sí misma

Los patrones más sofisticados en Perl y PCRE (biblioteca de expresiones regulares utilizada, por ejemplo, en PHP) pueden analizar correctamente el RFC 5322 sin problemas . Python y C # también pueden hacer eso, pero usan una sintaxis diferente de las dos primeras. Sin embargo, si se ve obligado a usar uno de los muchos lenguajes de emparejamiento de patrones menos potentes, es mejor usar un analizador real.

También es importante comprender que la validación según la RFC no le dice absolutamente nada acerca de si esa dirección existe realmente en el dominio proporcionado, o si la persona que ingresa la dirección es su verdadero propietario. La gente inscribe a otros en listas de correo de esta manera todo el tiempo. Arreglo que requiere un tipo de validación más sofisticada que implica enviar a esa dirección un mensaje que incluye un token de confirmación destinado a ser ingresado en la misma página web que la dirección.

Los tokens de confirmación son la única forma de saber que tiene la dirección de la persona que ingresa. Esta es la razón por la cual la mayoría de las listas de correo ahora usan ese mecanismo para confirmar los registros. Después de todo, cualquiera puede escribir [email protected] , y eso incluso se considerará legal, pero no es probable que sea la persona en el otro extremo.

Para PHP, no debe usar el patrón dado en Validar una dirección de correo electrónico con PHP, de la manera correcta a la que cito:

Existe el peligro de que el uso común y la codificación descuidada generalizada establezcan un estándar de facto para las direcciones de correo electrónico que sea más restrictivo que el estándar formal registrado.

Eso no es mejor que todos los otros patrones que no son RFC. Ni siquiera es lo suficientemente inteligente como para manejar incluso el RFC 822 , y mucho menos el RFC 5322. Este , sin embargo, sí lo es.

Si desea ser elegante y pedante, implemente un motor de estado completo . Una expresión regular solo puede actuar como un filtro rudimentario. El problema con las expresiones regulares es que decirle a alguien que su dirección de correo electrónico perfectamente válida no es válida (un falso positivo) porque su expresión regular no puede controlarse, es grosero y descortés desde la perspectiva del usuario. Un motor de estado para este propósito puede validar e incluso corregir direcciones de correo electrónico que de otro modo se considerarían inválidas, ya que desmonta la dirección de correo electrónico de acuerdo con cada RFC. Esto permite una experiencia potencialmente más agradable, como

La dirección de correo electrónico especificada ''myemail @ address, com'' no es válida. ¿Quiso decir ''[email protected]''?

Consulte también Validación de direcciones de correo electrónico , incluidos los comentarios. O comparar una dirección de correo electrónico que valida expresiones regulares .

Demo Debuggex

No debe utilizar expresiones regulares para validar direcciones de correo electrónico.

En su lugar, use la clase MailAddress , como esta:

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

La clase MailAddress utiliza un analizador BNF para validar la dirección de acuerdo con RFC822.

Si realmente quieres usar una expresión regular, aquí está :

Por la especificación de 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])?)*$

Contexto:

Una dirección de correo electrónico válida es una cadena que coincide con la producción de ABNF [...].
Nota: Este requisito es una violación intencional de RFC 5322 , que define una sintaxis para las direcciones de correo electrónico que es a la vez demasiado estricta (antes del carácter "@"), demasiado vaga (después del carácter "@") y demasiado laxa ( Permitir que los comentarios, los caracteres de espacio en blanco y las cadenas citadas en formas no familiares para la mayoría de los usuarios sean de utilidad práctica aquí.
La siguiente expresión regular compatible con JavaScript y Perl es una implementación de la definición anterior.
/^[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])?)*$/

Todo depende de qué tan preciso quieres ser. Para mis propósitos, donde estoy tratando de mantener fuera cosas como bob @ aol.com (espacios en correos electrónicos) o steve (sin dominio) o mary@aolcom (sin período antes de .com), uso

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

Claro, coincidirá con cosas que no son direcciones de correo electrónico válidas, pero es una cuestión de jugar la regla 90/10.

[ACTUALIZADO] He recopilado todo lo que sé sobre la validación de direcciones de correo electrónico aquí: http://isemail.info/ , que ahora no solo valida, sino que también diagnostica problemas con las direcciones de correo electrónico. Estoy de acuerdo con muchos de los comentarios aquí de que la validación es solo una parte de la respuesta; ver mi ensayo en http://isemail.info/about .

is_email () sigue siendo, hasta donde sé, el único validador que le dirá definitivamente si una cadena dada es una dirección de correo electrónico válida o no. He subido una nueva versión en http://isemail.info/

Recopilé casos de prueba de Cal Henderson, Dave Child, Phil Haack, Doug Lovell, RFC5322 y RFC 3696. 275 direcciones de prueba en total. Corrí todas estas pruebas contra todos los validadores gratuitos que pude encontrar.

Trataré de mantener esta página actualizada a medida que las personas mejoren sus validadores. Gracias a Cal, Michael, Dave, Paul y Phil por su ayuda y cooperación en la compilación de estas pruebas y la crítica constructiva de mi propio validador .

Las personas deben ser conscientes de las erratas contra RFC 3696 en particular. Tres de los ejemplos canónicos son, de hecho, direcciones no válidas. Y la longitud máxima de una dirección es de 254 o 256 caracteres, no 320.

yo suelo

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

Cuál es el que usa RegularExpressionValidator en ASP.NET.

Cal Henderson (Flickr) escribió un artículo llamado Análisis de direcciones de correo electrónico en PHP y muestra cómo realizar un análisis de direcciones de correo electrónico compatible con RFC (2) 822. También puede obtener el código fuente en php , python y ruby que tiene licencia cc .

Estándar RFC 5322:

Permite el dominio literal del dominio del dominio de la parte, del nombre del dominio (IPv4, IPv6, IPv4 y IPv4-mapped IPv6), la parte local del dominio, el nombre del dominio dominio y (anidados) 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''

Estándar RFC 5321:

Permite el dominio literal de parte de punto-átomo, parte de cadena entrecomada, dominio de nombre de dominio y dirección IPv4, IPv6 y IPv4 asignada a 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''

BASIC:

Permite dominio de nombre de dominio y parte local de punto-átomo (requiere al menos dos etiquetas de nombre de dominio con el TLD limitado a 2-6 caracteres alfabéticos).

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

Mientras escribe en PHP, le aconsejo que utilice la validación de integración de PHP para correos electrónicos.

filter_var($value, FILTER_VALIDATE_EMAIL)

Si está ejecutando una versión de php inferior a 5.3.6, tenga en cuenta este problema: https://bugs.php.net/bug.php?id=53091

Si desea más información sobre cómo funciona esta validación de buid-in, vea aquí: ¿Funciona realmente el filtro_var FILTER_VALIDATE_EMAIL de PHP?

Para una demostración vívida, el siguiente monstruo es bastante bueno pero aún no reconoce correctamente todas las direcciones de correo electrónico válidas sintácticamente: reconoce comentarios anidados hasta cuatro niveles de profundidad.

Este es un trabajo para un analizador, pero incluso si una dirección es sintácticamente válida, es posible que no se pueda entregar. A veces tienes que recurrir al método de Hillbilly de "Oye, todos, cuídanos!"

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

Podría usar el empleado por el complemento de validación de jQuery:

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

Al decidir qué personajes están permitidos, recuerda a tus amigos apóstrofados y con guiones. No tengo control sobre el hecho de que mi empresa genera mi dirección de correo electrónico usando mi nombre del sistema de recursos humanos. Eso incluye el apóstrofe en mi apellido. No puedo decirle cuántas veces se me ha impedido interactuar con un sitio web por el hecho de que mi dirección de correo electrónico es "no válida".

Aquí está el PHP que uso. Elegí esta solución con el espíritu de que "los falsos positivos son mejores que los falsos negativos" como lo declaró otro comentarista aquí Y con respecto a mantener el tiempo de respuesta activo y la carga del servidor ... realmente no hay necesidad de desperdiciar los recursos del servidor con una expresión regular cuando esto eliminará el error más simple del usuario. Siempre puede seguir esto enviando un correo electrónico de prueba si lo desea.

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

De acuerdo con la norma oficial RFC 2822, el correo electrónico válido de expresión regular es

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

Si quieres usarlo en Java es realmente muy fácil.

import java.util.regex.*; class regexSample { public static void main(String args[]) { //Input the string for validation String email = "[email protected]"; //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."); } }

Es extraño que "no pueda" permitir 4 caracteres TLD. Está prohibiendo a las personas de .info y .name , y la limitación de longitud detiene a .travel y .museum , pero sí, son menos comunes que los TLD de 2 caracteres y los TLD de 3 caracteres.

También debe permitir alfabetos en mayúsculas. Los sistemas de correo electrónico normalizarán la parte local y la parte del dominio.

Para su expresión regular de parte del dominio, el nombre de dominio no puede comenzar con ''-'' y no puede terminar con ''-''. Dash solo puede permanecer en el medio.

Si usó la biblioteca PEAR, revise su función de correo (olvidó el nombre exacto / biblioteca). Puede validar la dirección de correo electrónico llamando a una función, y valida la dirección de correo electrónico de acuerdo con la definición en RFC822.

Esta expresión regular es de la biblioteca de Email::Valid de Perl Email::Valid . Creo que es lo más preciso, coincide con todos los 822. Y, se basa en la expresión regular del libro de O''Reilly:

Expresión regular creada utilizando el ejemplo de Jeffrey Friedl en Mastering Regular Expressions ( http://www.ora.com/catalog/regexp/ ).

$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

Hay muchos ejemplos de esto en la red (y creo que incluso uno que valida completamente el RFC, pero tiene una longitud de decenas / cientos de líneas si la memoria sirve). La gente tiende a dejarse llevar validando este tipo de cosas. ¿Por qué no solo comprobar que tiene una @ y al menos una? y cumple con alguna longitud mínima simple. Es trivial ingresar un correo electrónico falso y aun así igualar cualquier expresión regular válida de todos modos. Supongo que los falsos positivos son mejores que los falsos negativos.

La especificación HTML5 sugiere una expresión regular simple para validar direcciones de correo electrónico:

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

Esto intencionalmente no cumple con 5322 .

Nota: Este requisito es una violación intencional de 5322 , que define una sintaxis para las direcciones de correo electrónico que es a la vez demasiado estricta (antes del @carácter), demasiado vaga (después del @carácter) y demasiado laxa (permite comentarios, caracteres en blanco, y citó cadenas de maneras que no son familiares para la mayoría de los usuarios, para ser de utilidad práctica aquí.

La longitud total también podría limitarse a 254 caracteres, por RFC 3696 errata 1690 .

Las direcciones de correo electrónico que deseo validar serán utilizadas por una aplicación web ASP.NET que use el espacio de nombres System.Net.Mail para enviar correos electrónicos a una lista de personas. Entonces, en lugar de usar una expresión regular muy compleja, solo trato de crear una instancia de MailAddress desde la dirección. El constructor de MailAddress lanzará una excepción si la dirección no se forma correctamente. De esta manera, sé que al menos puedo recibir el correo electrónico de la puerta. Por supuesto, esta es la validación del lado del servidor, pero como mínimo lo necesita de todos modos.

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

No hay uno que sea realmente utilizable.
Discuto algunos problemas en mi respuesta a ¿Existe una biblioteca de php para la validación de direcciones de correo electrónico? , se discute también en el reconocimiento Regexp de la dirección de correo electrónico duro?

En resumen, no espere que una expresión regular única y utilizable haga un trabajo adecuado. Y la mejor expresión regular validará la sintaxis, no la validez de un correo electrónico ([email protected] es correcta, pero probablemente rebote ...).

No sé cuál es el mejor, pero este es al menos correcto, siempre que las direcciones tengan sus comentarios eliminados y reemplazados con espacios en blanco.

Seriamente. Debe usar una biblioteca ya escrita para validar correos electrónicos. Probablemente, la mejor manera es simplemente enviar un correo electrónico de verificación a esa dirección.

Nunca me molesto en crear con mi propia expresión regular, porque es probable que alguien más haya creado una versión mejor. Siempre uso regexlib para encontrar uno a mi gusto.

Para obtener la evaluación más completa de la mejor expresión regular para validar una dirección de correo electrónico, consulte este enlace; " Comparación de la dirección de correo electrónico que valida expresiones regulares "

Aquí está la expresión superior actual para propósitos de referencia:

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

Sin mencionar que los nombres de dominio no latinos (chinos, árabes, griegos, hebreos, cirílicos, etc.) se permitirán en un futuro próximo . Todos tienen que cambiar la expresión regular de correo electrónico utilizada, ya que esos caracteres seguramente no deben ser cubiertos por [az]/ini /w. Todos ellos fallarán.

Después de todo, la mejor manera de validar la dirección de correo electrónico es enviar un correo electrónico a la dirección en cuestión para validar la dirección. Si la dirección de correo electrónico forma parte de la autenticación del usuario (registro / inicio de sesión / etc), entonces puede combinarla perfectamente con el sistema de activación del usuario. Es decir, enviar un correo electrónico con un enlace con una clave de activación única a la dirección de correo electrónico especificada y solo permitir el inicio de sesión cuando el usuario ha activado la cuenta recién creada mediante el enlace del correo electrónico.

Si el propósito de la expresión regular es informar rápidamente al usuario en la interfaz de usuario de que la dirección de correo electrónico especificada no tiene el formato correcto, lo mejor es verificar si coincide básicamente con la expresión regular siguiente:

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

Simple como eso. ¿Por qué demonios te importan los caracteres utilizados en el nombre y el dominio? Es responsabilidad del cliente ingresar una dirección de correo electrónico válida, no la del servidor. Incluso cuando el cliente ingresa una dirección de correo electrónico válida sintácticamente[email protected] , esto no garantiza que sea una dirección de correo electrónico legítima. Nadie regex puede cubrir eso.

Una simple expresión regular que al menos no rechazaría ninguna dirección válida de correo electrónico sería verificar algo, seguido de un signo @ y luego algo seguido de un punto y al menos 2 años. No rechazará nada, pero después de revisar la especificación no puedo encontrar ningún correo electrónico que sea válido y rechazado.

email = ~ /.+@[^@]+/.[^@]{2,}$/

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