¿Es difícil el reconocimiento de expresiones regulares de la dirección de correo electrónico?
https://stackoverflow.com/questions/156430
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Recientemente leí en alguna parte que escribir una expresión regular para que coincida con una dirección de correo electrónico, teniendo en cuenta todas las variaciones y posibilidades del estándar, es extremadamente difícil y significativamente más complicado de lo que uno podría suponer inicialmente.
¿Alguien puede darnos una idea de por qué es así?
¿Existen expresiones regulares conocidas y probadas que realmente hagan esto completamente?
¿Cuáles son algunas buenas alternativas al uso de expresiones regulares para hacer coincidir direcciones de correo electrónico?
Solución
Para la especificación de correo electrónico formal , sí, es técnicamente imposible a través de Regex debido a la recurrencia de cosas como los comentarios (especialmente si no elimina los comentarios al espacio en blanco primero), y el varios formatos diferentes (una dirección de correo electrónico no siempre es alguien@somewhere.tld). Puede acercarse (con algunos patrones Regex masivos e incomprensibles), pero una forma mucho mejor de consultar un correo electrónico es hacer un apretón de manos muy familiar:
- te dicen su correo electrónico
- les envía por correo electrónico un enlace de confirmación con un Guid
-
cuando hacen clic en el enlace sabes que:
- el correo electrónico es correcto
- existe
- lo poseen
Mucho mejor que aceptar ciegamente una dirección de correo electrónico.
Otros consejos
Hay varios módulos de Perl (por ejemplo) que hacen esto. No intentes escribir tu propia expresión regular para hacerlo. Mira
Mail::VRFY realizará comprobaciones de sintaxis y de red (un servidor SMTP acepta esta dirección en alguna parte)
https://metacpan.org/pod/Mail::VRFY
RFC::RFC822::Address - un analizador de dirección de correo electrónico de descenso recursivo.
https://metacpan.org/pod/RFC::RFC822::Address
Mail::RFC822::Address - validación de dirección basada en expresiones regulares, vale la pena mirar solo para la expresión regular loca
http://ex-parrot.com/~pdw/Mail -RFC822-Address.html
Existen herramientas similares para otros idiomas. Regexp loco a continuación ...
(?:(?:\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*)
Validar las direcciones de correo electrónico no es realmente muy útil de todos modos. No detectará errores tipográficos comunes o direcciones de correo electrónico inventadas, ya que tienden a parecerse sintácticamente a direcciones válidas.
Si desea asegurarse de que una dirección sea válida, no tiene más remedio que enviar un correo de confirmación.
Si solo quiere asegurarse de que el usuario ingrese algo que se parece a un correo electrónico en lugar de solo " asdf " ;, entonces busque una @. La validación más compleja realmente no proporciona ningún beneficio.
(Sé que esto no responde a sus preguntas, pero creo que vale la pena mencionarlo de todos modos)
Ahora he recopilado casos de prueba de Cal Henderson, Dave Child, Phil Haack, Doug Lovell y RFC 3696. 158 direcciones de prueba en total.
Ejecuté todas estas pruebas contra todos los validadores que pude encontrar. La comparación está aquí: http://www.dominicsayers.com/isemail
Intentaré mantener esta página actualizada a medida que las personas mejoren sus validadores. Gracias a Cal, Dave y Phil por su ayuda y cooperación en la compilación de estas pruebas y críticas constructivas de mi propio validador .
Las personas deben conocer 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.
Sin embargo, no todo son tonterías, ya que permitir caracteres como '+' puede ser muy útil para los usuarios que combaten el spam, p. myemail+sketchysite@gmail.com ( direcciones de Gmail desechables instantáneas ).
Sin embargo, solo cuando un sitio lo acepta.
Hay una gramática libre de contexto en BNF que describe direcciones de correo electrónico válidas en RFC-2822 . Es complejo. Por ejemplo:
" @ "@example.com
es una dirección de correo electrónico válida. No conozco ninguna expresión regular que lo haga completamente; los ejemplos que se dan generalmente requieren que los comentarios se eliminen primero. Escribí un analizador de descenso recursivo para hacerlo completamente una vez.
En mi opinión, aceptar o no formatos de direcciones de correo electrónico extraños y poco comunes depende de lo que uno quiera hacer con ellos.
Si estás escribiendo un servidor de correo, tienes que ser muy exacto y tremendamente correcto en lo que aceptas.Por lo tanto, la expresión regular "loca" citada anteriormente es apropiada.
Para el resto de nosotros, sin embargo, lo que más nos interesa es garantizar que algo que un usuario escribe en un formulario web parezca razonable y no tenga algún tipo de inyección SQL o desbordamiento de búfer.
Francamente, ¿a alguien realmente le importa permitir que alguien ingrese una dirección de correo electrónico de 200 caracteres con comentarios, nuevas líneas, citas, espacios, paréntesis u otras tonterías al registrarse para recibir una lista de correo, un boletín informativo o un sitio web?La respuesta adecuada a estos payasos es "Vuelve más tarde cuando tengas una dirección parecida a nombre de usuario@dominio.tld".
La validación que hago consiste en asegurar que existe exactamente un '@';que no haya espacios, nulos o nuevas líneas;que la parte a la derecha de la '@' tenga al menos un punto (pero no dos puntos seguidos);y que no hay comillas, paréntesis, comas, dos puntos, exclamaciones, punto y coma o barras invertidas, todo lo cual es más probable que sean intentos de piratería informática que partes de una dirección de correo electrónico real.
Sí, esto significa que estoy rechazando direcciones válidas con las que alguien podría intentar registrarse en mis sitios web. ¡Quizás rechazo "incorrectamente" hasta un 0,001% de las direcciones del mundo real!Puedo vivir con ello.
Las citas y otras partes raramente utilizadas pero válidas del RFC lo dificultan. No sé lo suficiente sobre este tema para comentar definitivamente, aparte de & Quot; es difícil & Quot; - pero afortunadamente otras personas tienen escrito al respecto en detalle.
En cuanto a una expresión regular válida, el módulo Perl Mail :: Rfc822 :: Address contiene una expresión regular que aparentemente funcionará , pero solo si algún comentario ya ha sido reemplazado por espacios en blanco. (¿Comentarios en una dirección de correo electrónico? Ve por qué es más difícil de lo que uno podría esperar ...)
Por supuesto, las expresiones regulares simplificadas que abundan en otros lugares validarán casi todas las direcciones de correo electrónico que realmente se utilizan ...
Algunos sabores de expresiones regulares pueden coincidir entre paréntesis anidados (por ejemplo, los compatibles con Perl). Dicho esto, he visto una expresión regular que dice coincidir correctamente con RFC 822 y eran dos páginas de texto sin espacios en blanco. Por lo tanto, la mejor manera de detectar una dirección de correo electrónico válida es enviarle un correo electrónico y ver si funciona.
Solo para agregar una expresión regular que sea menos loca que la listada por @mmaibaum:
^[a-zA-Z]([.]?([a-zA-Z0-9_-]+)*)?@([a-zA-Z0-9\-_]+\.)+[a-zA-Z]{2,4}$
No es a prueba de balas, y ciertamente no cubre toda la especificación de correo electrónico, pero hace un trabajo decente al cubrir la mayoría de los requisitos básicos. Aún mejor, es algo comprensible y puede editarse.
Cibbed de una discusión en HouseOfFusion.com , un recurso de clase mundial de ColdFusion.
Una manera fácil y buena de verificar las direcciones de correo electrónico en Java es utilizar el Validador de correo electrónico del Apache Validador de Commons biblioteca.
Siempre verificaría una dirección de correo electrónico en un formulario de entrada contra algo como esto antes de enviar un correo electrónico, incluso si solo detecta algunos errores tipográficos. Probablemente no desee escribir un escáner automático para & Quot; error en la entrega & Quot; correos de notificación. :-)
Es realmente difícil porque hay muchas cosas que pueden ser válidas en una dirección de correo electrónico de acuerdo con las especificaciones de correo electrónico, RFC 2822 . Las cosas que normalmente no ves como + son caracteres perfectamente válidos para una dirección de correo electrónico ... de acuerdo con las especificaciones.
Hay una sección completa dedicada a las direcciones de correo electrónico en http://regexlib.com , que es un gran recurso. Le sugiero que determine qué criterios le importan y que encuentre uno que coincida. La mayoría de las personas realmente no necesitan soporte completo para todas las posibilidades permitidas por la especificación.
Si está ejecutando .NET Framework, intente crear una instancia de un MailAddress objeto y atraparlo FormatException si explota, o sacando el Address si tiene éxito.Sin entrar en tonterías sobre el rendimiento de la captura de excepciones (en realidad, si esto es sólo en un único formulario web no hará mucha diferencia), el MailAddress La clase en el marco .NET pasa por un proceso de análisis bastante completo (no utiliza una expresión regular).Abra Reflector y busque MailAddress y MailBnfHelper.ReadMailAddress() para ver todas las cosas elegantes que hace.Alguien más inteligente que yo pasó mucho tiempo construyendo ese analizador en Microsoft. Lo usaré cuando envíe un correo electrónico a esa dirección, así que también podría usarlo para validar la dirección entrante.
Muchos lo han intentado, y muchos se acercan. Es posible que desee leer el artículo de Wikipedia , y algunos otros .
Específicamente, querrás recordar que muchos sitios web y servidores de correo electrónico tienen una validación relajada de las direcciones de correo electrónico, por lo que esencialmente no implementan el estándar por completo. Sin embargo, es lo suficientemente bueno para que el correo electrónico funcione todo el tiempo.
Pruebe este:
"(?:[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])+)\])"
Eche un vistazo aquí para obtener más información.
Sin embargo, en lugar de implementar el estándar RFC822, tal vez sería mejor mirarlo desde otro punto de vista. Realmente no importa lo que diga el estándar si los servidores de correo no reflejan el estándar. Por lo tanto, diría que sería mejor imitar lo que hacen los servidores de correo más populares al validar las direcciones de correo electrónico.
Esta clase para Java tiene un validador: http://www.leshazlewood.com/?p=23
Esto está escrito por el creador de Shiro (formalmente Ki, formalmente JSecurity)
Los pros y los contras de probar la validez de la dirección de correo electrónico:
Hay dos tipos de expresiones regulares que validan los correos electrónicos:
- Los que están demasiado sueltos.
-
Unos que son demasiado estrictos.
No es posible que una expresión regular coincida con todas las direcciones de correo electrónico válidas y con ninguna dirección de correo electrónico que no sea válida porque algunas cadenas pueden parecer direcciones de correo electrónico válidas pero en realidad no van a la bandeja de entrada de nadie. La única forma de probar para ver si un correo electrónico es realmente válido es enviar un correo electrónico a esa dirección y ver si obtiene algún tipo de respuesta. Con eso en mente, las expresiones regulares que son demasiado estrictas para los correos electrónicos coincidentes realmente no parecen tener mucho propósito.
Creo que la mayoría de las personas que solicitan una expresión regular de correo electrónico buscan la primera opción, expresiones regulares demasiado sueltas. Quieren probar una cadena y ver si parece un correo electrónico, si definitivamente no es un correo electrónico, entonces pueden decirle al usuario: & "; Hey, se supone que debes poner un correo electrónico aquí y esto definitivamente no es un correo electrónico válido. Tal vez no se dio cuenta de que este campo es para un correo electrónico o tal vez hay un error tipográfico & Quot ;.
Si un usuario coloca una cadena que se parece mucho a un correo electrónico válido, pero en realidad no es uno, entonces ese es un problema que debería ser manejado por una parte diferente de la aplicación.
¿Alguien puede darnos una idea de por qué?
Sí, es un estándar extremadamente complicado que permite muchas cosas que nadie realmente usa hoy en día. :)
¿Hay expresiones regulares conocidas y probadas que realmente lo hacen completamente?
Aquí hay un intento de analizar completamente el estándar ...
http://ex-parrot.com/~pdw/Mail -RFC822-Address.html
¿Cuáles son algunas buenas alternativas al uso de expresiones regulares para hacer coincidir las direcciones de correo electrónico?
¿Supongo que usa un marco existente para él en cualquier idioma que esté usando? Aunque probablemente usarán regexp internamente. Es una cadena compleja. Las expresiones regulares están diseñadas para analizar cadenas complejas, por lo que realmente es su mejor opción.
Editar : debo agregar que la expresión regular a la que me vinculé fue solo por diversión. No apruebo usar una expresión regular compleja como esa; algunas personas dicen que & "; Si su expresión regular es más de una línea, se garantiza que tiene un error en alguna parte &"; Lo vinculé para ilustrar cuán complejo es el estándar.
Además de la respuesta de Wayne , también hay una sección sobre www.regular-expressions.info dedicado al correo electrónico, con algunas muestras.
Siempre puede preguntarse si vale la pena o si, de hecho, cualquier expresión regular de cobertura inferior al 100% solo contribuye a una falsa sensación de seguridad.
Al final, en realidad enviar el correo electrónico es lo que proporcionará la validación final real. (-verás si tu servidor de correo tiene errores ;-)
Para completar esta publicación, también para PHP hay una función integrada de lenguaje para validar correos electrónicos.
Para PHP Utilice el agradable filter_var con el tipo de validación EMAIL específico :)
No más expresiones regulares de correo electrónico en php: D
var_dump(filter_var('bob@example.com', FILTER_VALIDATE_EMAIL));
