regex - test - ¿Cuál sería una expresión regular aceptada globalmente para que coincida con las direcciones de correo electrónico?

probar expresiones regulares

Question

He visto muchos ejemplos, con muchos comentarios de "no, te perdiste algo". ¿Cuál es la forma correcta de hacer coincidir una dirección de correo electrónico?

Para Sanity sake, solo nombres de dominio totalmente calificados, no se permite @localhost. (o, en ambos sentidos)

Los subdominios deben estar permitidos ([email protected])

Answer 1

Recientemente tuve que crear algunos canales RSS, y parte de eso incluía examinar el esquema Xml, incluidos los elementos para Webmaster y ManagingEditor, que se definen como una dirección de correo electrónico que coincida con este patrón:

([a-zA-Z0-9_/-])([a-zA-Z0-9_/-/.]*)@(/[((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])/.){3}|((([a-zA-Z0-9/-]+)/.)+))([a-zA-Z]{2,}|(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])/])

Answer 2

Si está usando Perl, creo que el módulo Regex :: Common sería el que desea usar, y en particular, Regex :: Common :: Email :: Address.

Answer 3

Lamentablemente, no es una expresión regular, pero ... La forma correcta de validar una dirección de correo electrónico es enviar un mensaje y ver si el usuario responde.

Si realmente desea verificar que una dirección es sintácticamente válida / compatible con RFC, entonces es probable que una expresión regular no sea la herramienta adecuada para el trabajo. Lo más probable es que cree un analizador en menos caracteres que la longitud de una expresión regular con un nivel similar de cumplimiento RFC y el analizador probablemente se ejecute más rápido para arrancar.

Incluso con una prueba perfecta de cumplimiento de RFC, [email protected] está perfectamente formado y se refiere a un dominio existente, por lo que no sabrá si la dirección que se le proporciona es realmente válida o no, a menos que le envíe un mensaje.

Answer 4

Esta expresión regular cumple con la gramática descrita en RFC 2822 , es muy larga, pero la gramática descrita en el RFC es compleja ...

Answer 5

Es imposible hacerlo en una expresión pura. Regexen no puede hacer coincidir paréntesis anidados, que requiere la especificación completa de RFC. (El último RFC sobre este tema es RFC5322, publicado hace unos meses).

La validación completa de las direcciones de correo electrónico requiere algo similar a un CFG, y hay algunas cosas más que desconfiar; por ejemplo, las direcciones de correo electrónico pueden contener ''/0'' , el carácter nulo ... por lo que no puede usar ninguna de las funciones de cadena normales de C en ellas.

De hecho, me siento un poco raro al responder una pregunta con un enlace a algo que he escrito, pero como sucede, tengo uno que preparé antes: un validador corto y (por lo que puedo decir) totalmente compatible, en Haskell ; puedes ver el código fuente aquí . Imagino que el código podría ser fácilmente portado a cualquier biblioteca de análisis similar (quizás Boost.Spirit de C ++), o tan fácilmente enganchado desde otro idioma (Haskell tiene una manera muy simple para que C use el código Haskell , y todo puede usar enlaces C ...)

También hay casos de prueba extensos en el código fuente (no los exporté del módulo), que se deben a Dominic Sayers , quien tiene su propia versión de un analizador compatible con RFC en PHP. (Varias de las pruebas fallan, pero son más estrictas que las especificadas por RFC5322, así que estoy de acuerdo con eso en este momento).

Answer 6

El consejo general es no

Probablemente valga la pena verificar que ingresaron "[email protected]" solo para comprobar que pusieron el correo electrónico en el cuadro de la derecha.
Más allá de eso, la mayoría de los regex oficiales permiten tantos casos oscuros que tienen una enorme tasa de falsos positivos (permitirán entradas técnicamente legales pero extremadamente improbables)

Answer 7

Desde http://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html :

La gramática descrita en RFC 822 es sorprendentemente compleja. La implementación de la validación con expresiones regulares de alguna manera empuja los límites de lo que es sensato hacer con las expresiones regulares, aunque Perl lo hace bien:

(?:(?:/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*)

Answer 8

Sin mencionar que los nombres de dominio chino / árabe se permitirán en el futuro cercano. Todo el mundo tiene que cambiar la expresión regular de correo electrónico utilizada, porque seguramente esos caracteres no estarán cubiertos por [az]/i ni /w . Todos fallarán.

Después de todo, la mejor forma de validar la dirección de correo electrónico es enviando un correo electrónico a la dirección en cuestión para validar la dirección. Si la dirección de correo electrónico es 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 haya activado la cuenta recién creada utilizando el enlace en el correo electrónico.

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

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

Simple como eso. ¿Por qué diablos te importarían los personajes utilizados en el nombre y el dominio?

Answer 9

Aquí hay otra discusión sobre esto: Usar una expresión regular para validar una dirección de correo electrónico

Answer 10

Eso fue preguntado aquí hace un par de semanas. Lo que se reduce a esto es que hay muchas direcciones legales que una expresión regular fácil no coincidirá. Se necesita una expresión auténtica para que coincida con la mayoría de las direcciones legales. Y aun así, una dirección sintácticamente legal no garantiza la existencia de una cuenta detrás de ella. Por ejemplo, tome [email protected].