¿Cómo validar una dirección de correo electrónico en JavaScript?

¿Cómo se puede validar una dirección de correo electrónico en JavaScript?

Usar expresiones regulares es probablemente la mejor manera. Puedes ver un montón de pruebas aquí (tomadas de cromo )

function validateEmail(email) { var re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; return re.test(String(email).toLowerCase()); } 

Aquí está el ejemplo de expresión regular que acepta Unicode:

 var re = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i; 

Pero tenga en cuenta que uno no debe confiar únicamente en la validación de JavaScript. JavaScript se puede deshabilitar fácilmente. Esto también debe validarse en el lado del servidor.

Aquí hay un ejemplo de lo anterior en acción:

 function validateEmail(email) { var re = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; return re.test(email); } function validate() { var $result = $("#result"); var email = $("#email").val(); $result.text(""); if (validateEmail(email)) { $result.text(email + " is valid :)"); $result.css("color", "green"); } else { $result.text(email + " is not valid :("); $result.css("color", "red"); } return false; } $("#validate").bind("click", validate); 
  

Enter an email address:

Solo para completar, aquí tienes otra expresión regular compatible con RFC 2822

El estándar oficial se conoce como RFC 2822 . Describe la syntax que deben cumplir las direcciones de correo electrónico válidas. Puedes ( pero no deberíasseguir leyendo ) implementarlo con esta expresión regular:

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

(…) Obtenemos una implementación más práctica de RFC 2822 si omitimos la syntax mediante comillas dobles y corchetes. Todavía igualará el 99.99% de todas las direcciones de correo electrónico en uso hoy en día.

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?

Otro cambio que podría hacer es permitir cualquier dominio de nivel superior de código de país de dos letras, y solo dominios generics de nivel superior específicos. Esta expresión regular filtra direcciones de correo asdf@adsf.adsf como asdf@adsf.adsf . Deberá actualizarlo a medida que se agreguen nuevos dominios de nivel superior .

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[AZ]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\b

Por lo tanto, incluso si se siguen los estándares oficiales, aún se deben realizar intercambios. No copie ciegamente expresiones regulares de bibliotecas en línea o foros de discusión. Siempre pruébelos en sus propios datos y con sus propias aplicaciones.

Énfasis mío

He modificado ligeramente la respuesta de Jaymon para las personas que quieren una validación realmente simple en la forma de:

anystring@anystring.anystring

La expresión regular:

 /\S+@\S+\.\S+/ 

Ejemplo de función de JavaScript:

 function validateEmail(email) { var re = /\S+@\S+\.\S+/; return re.test(email); } 

Hay algo que debes entender en el momento en que decides utilizar una expresión regular para validar los correos electrónicos: probablemente no sea una buena idea . Una vez que haya llegado a un acuerdo con eso, hay muchas implementaciones que pueden llevarlo hasta la mitad, este artículo las resume muy bien.

En resumen, sin embargo, la única forma de estar total y absolutamente seguro de que lo que el usuario ingresó es, de hecho, un correo electrónico es enviar un correo electrónico y ver qué sucede. Aparte de eso, todo es solo conjeturas.

Wow, hay mucha complejidad aquí. Si todo lo que quiere hacer es capturar los errores de syntax más obvios, haría algo como esto:

 \S+@\S+ 

Por lo general, capta los errores más obvios que comete el usuario y asegura que la forma es en su mayoría correcta, que es de lo que se trata la validación de JavaScript.

HTML5 en sí tiene validación de correo electrónico. Si su navegador es compatible con HTML5, puede usar el siguiente código.

 

jsEnlace de enlace

De la especificación de HTML5 :

Una dirección de correo electrónico válida es una cadena que coincide con la producción de email del siguiente ABNF, cuyo conjunto de caracteres es Unicode.

 email = 1*( atext / "." ) "@" label *( "." label ) label = let-dig [ [ ldh-str ] let-dig ] ; limited to a length of 63 characters by RFC 1034 section 3.5 atext = < as defined in RFC 5322 section 3.2.3 > let-dig = < as defined in RFC 1034 section 3.5 > ldh-str = < as defined in RFC 1034 section 3.5 > 

Este requisito es una violación voluntaria de RFC 5322, que define una syntax 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 (permitiendo comentarios , espacios en blanco y cadenas entre comillas de maneras poco familiares para la mayoría de los usuarios) para que sean de uso práctico 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])?)*$/ 

He encontrado que esta es la mejor solución:

 /^[^\s@]+@[^\s@]+\.[^\s@]+$/ 

Permite los siguientes formatos:

 1. prettyandsimple@example.com
 2. very.common@example.com
 3. disposable.style.email.with+symbol@example.com
 4. other.email-with-dash@example.com
 9. #!$%&'*+-/=?^_`{}|~@example.org
 6. "() []:,; @ \\\"! # $% & '* + - / =? ^ _ `{} |  ~ .a "@ example.org
 7. "" @ example.org (espacio entre las comillas)
 8. üñîçøðé@example.com (caracteres Unicode en la parte local)
 9. üñîçøðé@üñîçøðé.com (caracteres Unicode en la parte del dominio)
 10. Pelé@example.com (latín)
 11. δοκιμή@παράδειγμα.δοκιμή (Griego)
 12. 我 買 @ 屋企. 香港 (chino)
 13. 甲 斐 @ 黒 黒. 日本 (Japonés)
 14. чебурашка@ящик-с-апельсинами.рф (cirílico)

Es claramente versátil y permite los personajes internacionales más importantes, mientras sigue aplicando el formato básico anything@anything.anything. Bloqueará espacios que están técnicamente permitidos por RFC, pero son tan raros que estoy feliz de hacer esto.

En los navegadores modernos puedes construir sobre la respuesta de @ Sushil con JavaScript puro y el DOM :

 function validateEmail(value) { var input = document.createElement('input'); input.type = 'email'; input.required = true; input.value = value; return typeof input.checkValidity === 'function' ? input.checkValidity() : /\S+@\S+\.\S+/.test(value); } 

He creado un ejemplo en el violín http://jsfiddle.net/boldewyn/2b6d5/ . Combinado con la detección de características y la validación básica de Squirtle’s Answer , te libera de la masacre de expresiones regulares y no se encrespa en navegadores antiguos.

JavaScript puede coincidir con una expresión regular:

 emailAddress.match( / some_regex /); 

Aquí hay una expresión regular de RFC22 para correos electrónicos:

 ^((?>[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+\x20*|"((?=[\x01-\x7f])[^"\\]|\\[\x01-\x7f])* "\x20*)*(?< ))?((?!\.)(?>\.?[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+)+|"((?=[\x01-\x 7f])[^"\\]|\\[\x01-\x7f])*")@(((?!-)[a-zA-Z\d\-]+(?< !-)\.)+[a-zA-Z]{2,}|\[(((?(?< !\[)\.)(25[0-5]|2[0-4]\d|[01]?\d?\d)){4}|[a-zA-Z\d\-]*[a-zA-Z\d]:((?=[\x01-\x7f]) [^\\\[\]]|\\[\x01-\x7f])+)\])(?(angle)>)$ 

Esta es la versión correcta de RFC822.

 function checkEmail(emailAddress) { var sQtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'; var sDtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]'; var sAtom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+'; var sQuotedPair = '\\x5c[\\x00-\\x7f]'; var sDomainLiteral = '\\x5b(' + sDtext + '|' + sQuotedPair + ')*\\x5d'; var sQuotedString = '\\x22(' + sQtext + '|' + sQuotedPair + ')*\\x22'; var sDomain_ref = sAtom; var sSubDomain = '(' + sDomain_ref + '|' + sDomainLiteral + ')'; var sWord = '(' + sAtom + '|' + sQuotedString + ')'; var sDomain = sSubDomain + '(\\x2e' + sSubDomain + ')*'; var sLocalPart = sWord + '(\\x2e' + sWord + ')*'; var sAddrSpec = sLocalPart + '\\x40' + sDomain; // complete RFC822 email address spec var sValidEmail = '^' + sAddrSpec + '$'; // as whole string var reValidEmail = new RegExp(sValidEmail); return reValidEmail.test(emailAddress); } 

La correcta validación de la dirección de correo electrónico de acuerdo con las RFC no es algo que se pueda lograr con una expresión regular de una sola línea. Un artículo con la mejor solución que he encontrado en PHP es ¿Qué es una dirección de correo electrónico válida? . Obviamente, ha sido portado a Java. Creo que la función es demasiado compleja para ser portada y utilizada en JavaScript.

Una buena práctica es validar sus datos en el cliente, pero vuelva a verificar la validación en el servidor. Con esto en mente, puede simplemente verificar si una cadena se ve como una dirección de correo electrónico válida en el cliente y realizar una verificación estricta en el servidor.

Aquí está la función de JavaScript que uso para verificar si una cadena se parece a una dirección de correo válida:

 function looksLikeMail(str) { var lastAtPos = str.lastIndexOf('@'); var lastDotPos = str.lastIndexOf('.'); return (lastAtPos < lastDotPos && lastAtPos > 0 && str.indexOf('@@') == -1 && lastDotPos > 2 && (str.length - lastDotPos) > 2); } 

Explicación:

  • lastAtPos < lastDotPos : Last @ debe estar antes del último . ya que @ no puede ser parte del nombre del servidor (hasta donde yo sé).

  • lastAtPos > 0 : debe haber algo (el nombre de usuario del correo electrónico) antes del último @ .

  • str.indexOf('@@') == -1 : No debe haber @@ en la dirección. Incluso si @ aparece como el último carácter en el nombre de usuario del correo electrónico, debe ser citado para que " sea ​​entre ese @ y el último @ en la dirección.

  • lastDotPos > 2 : debe haber al menos tres caracteres antes del último punto, por ejemplo a@b.com .

  • (str.length - lastDotPos) > 2 : debe haber suficientes caracteres después del último punto para formar un dominio de dos caracteres. No estoy seguro si los corchetes son necesarios.

Todas las direcciones de correo electrónico contienen un símbolo ‘at’ (es decir, @). Pruebe esa condición necesaria:

 email.indexOf("@") > 0 

No te molestes con nada más complicado. Incluso si pudiera determinar perfectamente si un correo electrónico es RFC-sintácticamente válido, eso no le diría si pertenece a la persona que lo suministró. Eso es lo que realmente importa.

Para probar eso, envíe un mensaje de validación.

Esto fue robado de http://codesnippets.joyent.com/posts/show/1917

 email = $('email'); filter = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/; if (filter.test(email.value)) { // Yay! valid return true; } else {return false;} 

Tengo muchas ganas de resolver este problema. Así que modifiqué la expresión regular de validación de correo electrónico anterior

  • Original
    /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/

  • Modificado
    /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+[^<>()\.,;:\s@\"]{2,})$/

pasar los ejemplos en la dirección de correo electrónico de Wikipedia .

Y puedes ver el resultado aquí .

enter image description here

Hacer esto:

 [a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])? 

¿Por qué? Se basa en RFC 2822 , que es un estándar que TODAS las direcciones de correo electrónico DEBEN cumplir.

A menudo, al almacenar direcciones de correo electrónico en la base de datos, las escribo en minúsculas y, en la práctica, las expresiones regulares generalmente se pueden marcar sin distinción entre mayúsculas y minúsculas. En esos casos, esto es un poco más corto:

 [a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])? 

Aquí hay un ejemplo de que se usa en JavaScript (con el indicador de mayúsculas y minúsculas i al final).

 var emailCheck=/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i; console.log( emailCheck.test('some.body@domain.co.uk') ); 

Nota :
Técnicamente, algunos correos electrónicos pueden incluir comillas en la sección antes del símbolo @ con caracteres de escape dentro de las comillas (para que el usuario de su correo electrónico sea desagradable y contenga cosas como @ y "..." siempre que estén escritas entre comillas). ¡NADIE HACE ESTO NUNCA! Es obsoleto Pero, está incluido en el verdadero estándar RFC 2822 , y se omite aquí.

Más información: http://www.regular-expressions.info/email.html

No debe usar expresiones regulares para validar una cadena de entrada para verificar si se trata de un correo electrónico. Es muy complicado y no cubriría todos los casos.

Ahora que solo puedes cubrir el 90% de los casos, escribe algo como:

 function isPossiblyValidEmail(txt) { return txt.length > 5 && txt.indexOf('@')>0; } 

Puedes refinarlo. Por ejemplo, ‘aaa @’ es válido. Pero en general obtienes la esencia. Y no se deje llevar … Una solución simple al 90% es mejor que una solución al 100% que no funciona.

El mundo necesita un código más simple …

Simplemente revisa si la dirección de correo electrónico ingresada es válida o si no usas HTML.

  

No es necesario escribir una función para validación.

Así es como lo hace el nodo validador :

 /^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+@(?:(?:(?:[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]?)|(?:\[(?:(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\]))$/ 

Es difícil obtener un validador de correo electrónico 100% correcto. La única manera real de hacerlo correcto sería enviando un correo electrónico de prueba a la cuenta. Dicho esto, hay algunas comprobaciones básicas que pueden ayudarlo a asegurarse de obtener algo razonable.

Algunas cosas para mejorar:

En lugar de un nuevo RegExp , simplemente intente escribir la regexp esta manera:

 if (reg.test(/@/)) 

En segundo lugar, verifique que haya un período después del signo @ y asegúrese de que haya caracteres entre los @ sy los períodos.

Aparentemente, eso es todo:

 /^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[az])\.)+[az]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$/i 

Tomado de http://fightingforalostcause.net/misc/2006/compare-email-regex.php el 1 de octubre de 2010.

Pero, por supuesto, eso está ignorando la internacionalización.

En contraste con Squirtle , aquí hay una solución compleja, pero hace un trabajo muy bueno para validar los correos electrónicos correctamente:

 function isEmail(email) { return /^((([az]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([az]|\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)))@((([az]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([az]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([az]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([az]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([az]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([az]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([az]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([az]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i.test(email); } 

Úselo así:

 if (isEmail('youremail@yourdomain.com')){ console.log('This is email is valid'); } 

Use este código dentro de su función de validador:

 var emailID = document.forms["formName"]["form element id"].value; atpos = emailID.indexOf("@"); dotpos = emailID.lastIndexOf("."); if (atpos < 1 || ( dotpos - atpos < 2 )) { alert("Please enter correct email ID") return false; } 

Else you can use jQuery . Inside rules define:

 eMailId: { required: true, email: true } 

A solution that does not check the existence of the TLD is incomplete.

Almost all answers to this questions suggest using Regex to validate emails addresses. I think Regex is only good for a rudimentary validation. It seems that the checking validation of email addresses is actually two separate problems:

1- Validation of email format: Making sure if the email complies with the format and pattern of emails in RFC 5322 and if the TLD actually exists. A list of all valid TLDs can be found here .

For example, although the address example@example.ccc will pass the regex, it is not a valid email, because ccc is not a top-level domain by IANA.

2- Making sure the email actually exists: For doing this, the only option is to send the users an email .

Best regex ever which confirms with the RFC5322

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])+

Here is a very good discussion about using regular expressions to validate email addresses; ” Comparing E-mail Address Validating Regular Expressions ”

Here is the current top expression, that is JavaScript compatible, for reference purposes:

 /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+)*\.(aero|arpa|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org|pro|travel|mobi|[az][az])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i 

My knowledge of regular expressions is not that good. That’s why I check the general syntax with a simple regular expression first and check more specific options with other functions afterwards. This may not be not the best technical solution, but this way I’m way more flexible and faster.

The most common errors I’ve come across are spaces (especially at the beginning and end) and occasionally a double dot.

 function check_email(val){ if(!val.match(/\S+@\S+\.\S+/)){ // Jaymon's / Squirtle's solution // Do something return false; } if( val.indexOf(' ')!=-1 || val.indexOf('..')!=-1){ // Do something return false; } return true; } check_email('check@thiscom'); // Returns false check_email('check@this..com'); // Returns false check_email(' check@this.com'); // Returns false check_email('check@this.com'); // Returns true 
 
Please input a valid email address:

Regex update 2018! prueba esto

 let val = 'email@domain.com'; if(/^[a-z0-9][a-z0-9-_\.]+@([az]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[az]{2,10})?$/.test(val)) { console.log('passed'); } 

typscript version complete

 // export const emailValid = (val:string):boolean => /^[a-z0-9][a-z0-9-_\.]+@([az]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[az]{2,10})?$/.test(val); 

more info https://git.io/vhEfc

The regular expression provided by Microsoft within ASP.NET MVC is

 /^[\w-]+(\.[\w-]+)*@([a-z0-9-]+(\.[a-z0-9-]+)*?\.[az]{2,6}|(\d{1,3}\.){3}\d{1,3})(:\d{4})?$/ 

Which I post here in case it’s flawed – though it’s always been perfect for my needs.

Wikipedia standard mail syntax :

https://en.wikipedia.org/wiki/Email_address#Examples https://fr.wikipedia.org/wiki/Adresse_%C3%A9lectronique#Syntaxe_exacte

 function validMail(mail) { return /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+([^<>()\.,;:\s@\"]{2,}|[\d\.]+))$/.test(mail); } // VALID MAILS validMail('Abc@example.com') // Return true validMail('Abc@example.com.') // Return true validMail('Abc@10.42.0.1') // Return true validMail('user@localserver') // Return true validMail('Abc.123@example.com') // Return true validMail('user+mailbox/department=shipping@example.com') // Return true validMail('"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com') // Return true validMail('!#$%&\'*+-/=?^_`.{|}~@example.com') // Return true validMail('"()<>[]:,;@\\\"!#$%&\'-/=?^_`{}| ~.a"@example.org') // Return true validMail('"Abc@def"@example.com') // Return true validMail('"Fred Bloggs"@example.com') // Return true validMail('"Joe.\\Blow"@example.com') // Return true validMail('Loïc.Accentué@voilà.fr') // Return true validMail('" "@example.org') // Return true validMail('user@[IPv6:2001:DB8::1]') // Return true // INVALID MAILS validMail('Abc.example.com') // Return false validMail('A@b@c@example.com') // Return false validMail('a"b(c)d,e:f;gi[j\k]l@example.com') // Return false validMail('just"not"right@example.com') // Return false validMail('this is"not\allowed@example.com') // Return false validMail('this\ still\"not\\allowed@example.com') // Return false validMail('john..doe@example.com') // Return false validMail('john.doe@example..com') // Return false 

Show this test : https://regex101.com/r/LHJ9gU/1