Reconocimiento Regexp de la dirección de correo electrónico difícil?

Hace poco 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 de la norma es extremadamente difícil y es mucho más complicado de lo que uno inicialmente asumiría.

¿Alguien puede darnos una idea de por qué es eso?

¿Existen expresiones regulares conocidas y comprobadas que realmente lo hagan por completo?

¿Cuáles son algunas buenas alternativas al uso de expresiones regulares para hacer coincidir direcciones de correo electrónico?

Para la especificación formal de correo electrónico, sí, es técnicamente imposible a través de Regex debido a la recursión de cosas como comentarios (especialmente si no elimina los comentarios primero en el espacio en blanco), y los diferentes formatos (una dirección de correo electrónico no es ‘t siempre alguien@somewhere.tld). Puede acercarse (con algunos patrones Regex masivos e incomprensibles), pero una manera mucho mejor de revisar un correo electrónico es hacer un saludo de manos muy familiar:

  • ellos te dicen su correo electrónico
  • les envía un enlace de confimación por correo electrónico con un Guid
  • cuando hacen clic en el enlace, sabes que:

    1. el correo electrónico es correcto
    2. existe
    3. ellos lo poseen

Mucho mejor que aceptar ciegamente una dirección de correo electrónico.

Hay una serie de módulos Perl (por ejemplo) que hacen esto. No intente y escriba su propia expresión regular para hacerlo. Mirar

Mail::VRFY hará syntax y verificaciones de red (el servidor SMTP y alguna parte aceptan esta dirección)

https://metacpan.org/pod/Mail::VRFY

RFC::RFC822::Address – un analizador de direcciones 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 demente

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

De todos modos, validar las direcciones de correo electrónico no es muy útil. No detectará los errores tipográficos o las direcciones de correo electrónico inventadas, ya que tienden a parecer sintácticamente como direcciones válidas.

Si quiere asegurarse de que una dirección sea válida, no tiene más remedio que enviar un correo de confirmación.

Si solo quieres asegurarte de que el usuario ingrese algo que se parece a un correo electrónico en lugar de simplemente “asdf”, entonces busca un @. Una validación más compleja en realidad no proporciona ningún beneficio.

(Sé que esto no responde sus preguntas, pero creo que vale la pena mencionarlo de todos modos)

He cotejado 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

Trataré de 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 comstackción de estas pruebas y la crítica constructiva de mi propio validador .

La gente debería conocer la errata contra RFC 3696 en particular. Tres de los ejemplos canónicos son, de hecho, direcciones inválidas. Y la longitud máxima de una dirección es de 254 o 256 caracteres, no 320.

Sin embargo, no todo es una tontería, ya que permitir caracteres como ‘+’ puede ser muy útil para los usuarios que combaten el correo no deseado, por ejemplo, myemail+sketchysite@gmail.com ( direcciones de Gmail instantáneas desechables ).

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 sé de ninguna expresión regular que lo haga completamente; los ejemplos que se suelen dar requieren que primero se eliminen los comentarios. Escribí un analizador de descenso recursivo para hacerlo completamente una vez.

Aceptar o no formatos de direcciones de correo electrónico raros o poco comunes depende, en mi opinión, de lo que uno quiera hacer con ellos.

Si está escribiendo un servidor de correo, debe ser muy exacto e insoportablemente correcto en lo que acepta. El regex “loco” citado anteriormente es por lo tanto apropiado.

Para el rest de nosotros, sin embargo, estamos interesados ​​principalmente en garantizar que algo que un usuario escriba en un formulario web se vea razonable y no tenga algún tipo de inyección sql o desbordamiento de búfer en él.

Francamente, ¿alguien realmente se preocupa por permitir que alguien ingrese una dirección de correo electrónico de 200 caracteres con comentarios, líneas nuevas, comillas, espacios, paréntesis u otros galimatías al suscribirse a una lista de correo, un boletín o un sitio web? La respuesta adecuada a tales payasos es “Vuelve más tarde cuando tengas una dirección que se parece a nombredeusuario@dominio.tld“.

La validación que hago consiste en garantizar que haya exactamente una ‘@’; que no hay espacios, nulos o nuevas líneas; que la parte a la derecha de la ‘@’ tiene al menos un punto (pero no dos puntos en una fila); y que no hay comillas, paréntesis, comas, dos puntos, exclamaciones, punto y coma o barras diagonales inversas, todas las cuales tienen más probabilidades de ser bashs de hackeo 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 tratar de registrarse en mis sitios web, ¡quizás rechace “incorrectamente” hasta el 0.001% de las direcciones del mundo real! Puedo vivir con ello.

Citar y otras partes raramente utilizadas pero válidas de la RFC lo hacen difícil. No sé lo suficiente sobre este tema para comentar definitivamente, aparte de “es difícil”, pero, afortunadamente, otras personas han escrito al respecto extensamente.

En cuanto a una expresión regular válida para él, el módulo Perl Mail :: Rfc822 :: Address contiene una expresión regular que aparentemente funcionará , pero solo si los comentarios ya han sido reemplazados por espacios en blanco. (¿Comentarios en una dirección de correo electrónico? Ya ves por qué es más difícil de lo que cabrí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 realmente pueden coincidir con los paréntesis nesteds (por ejemplo, compatibles con Perl). Dicho esto, he visto una expresión regular que dice que coincide correctamente con el RFC 822 y con 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 enumerada 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 todas las especificaciones de correo electrónico, pero sí hace un trabajo decente para cubrir la mayoría de los requisitos básicos. Aún mejor, es algo comprensible y puede ser editado.

Extraído de una discusión en HouseOfFusion.com , un recurso de ColdFusion de primera clase.

Una manera fácil y buena de verificar las direcciones de correo electrónico en Java es usar el EmailValidator de la biblioteca de Apache Commons Validator .

Siempre verificaba una dirección de correo electrónico en un formulario de entrada en contra de 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 automatizado para correos de notificación de “entrega fallida”. 🙂

Es realmente difícil porque hay muchas cosas que pueden ser válidas en una dirección de correo electrónico de acuerdo con la especificación 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 la especificación.

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 busque uno que coincida. La mayoría de la gente realmente no necesita soporte completo para todas las posibilidades permitidas por la especificación.

Si se está ejecutando en .NET Framework, intente crear una instancia de un objeto MailAddress y FormatException la FormatException si esta explota, o FormatException la Address si tiene éxito. Sin entrar en ninguna tontería sobre el rendimiento de capturar excepciones (realmente, si esto es solo en un único formulario web, no va a hacer mucha diferencia), la clase MailAddress en .NET Framework pasa por un análisis bastante completo proceso (no usa un RegEx). Abra Reflector y busque MailAddress y MailBnfHelper.ReadMailAddress() para ver todas las cosas sofisticadas 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á recordar que muchos sitios web y servidores de correo electrónico han relajado la validación de las direcciones de correo electrónico, por lo que esencialmente no implementan el estándar por completo. Sin embargo, es suficiente para que el correo electrónico funcione todo el tiempo.

Prueba 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 los detalles.

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 dice la norma si los servidores de correo no reflejan el estándar. Entonces, yo diría que sería mejor imitar lo que hacen los servidores de correo más populares cuando validan 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:

  1. Los que están demasiado sueltos.
  2. 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 sin direcciones de correo electrónico que no son válidas 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 manera de comprobar 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. Teniendo esto en cuenta, las expresiones regulares que son demasiado estrictas en los correos electrónicos coincidentes en realidad no parecen tener un gran propósito.

Creo que la mayoría de las personas que solicitan una expresión regular de correo electrónico están buscando la primera opción, expresiones regulares que son demasiado flojas. Quieren probar una cadena y ver si se parece a un correo electrónico, si definitivamente no es un correo electrónico, entonces pueden decirle al usuario: “Oye, se supone que debes poner un correo electrónico aquí y esto definitivamente es 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 “.

Si un usuario pone 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é es eso?

Sí, es un estándar extremadamente complicado que permite muchas cosas que nadie usa realmente hoy. 🙂

¿Existen expresiones regulares conocidas y comprobadas que realmente lo hagan por completo?

Aquí hay un bash 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 direcciones de correo electrónico?

¿Usar un marco existente para él en cualquier idioma que esté utilizando, supongo? Aunque probablemente usarán la expresión regular internamente. Es una cadena compleja. Los Regexps están diseñados para analizar cadenas complejas, por lo que esa es realmente su mejor opción.

Editar : Debo añadir que la expresión regular a la que me he vinculado era solo por diversión. No apruebo el uso de expresiones regulares complejas como esa, algunas personas dicen que “si tu expresión regular es de más de una línea, se garantiza que tiene un error en alguna parte”. Me uní a él para ilustrar qué tan complejo es el estándar.

Añadiendo a la respuesta de Wayne , también hay una sección en http://www.regular-expressions.info dedicada al correo electrónico, con algunas muestras.

Siempre se puede preguntar si vale la pena o si, de hecho, cualquier expresión regular de menos de 100% de cobertura solo contribuye a una falsa sensación de seguridad.

Al final, enviar el correo electrónico es lo que proporcionará la validación final real. (-verás si tu servidor de correo electrónico tiene errores 😉

Para completar esta publicación, también para PHP hay una función integrada en el lenguaje para validar los correos electrónicos.

Para PHP Utilice el filtro nice_var con el tipo de validación EMAIL específico 🙂

No más expresiones de correo electrónico locas en php: D

 var_dump(filter_var('bob@example.com', FILTER_VALIDATE_EMAIL)); 

http://www.php.net/filter_var