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

¿Existe una expresión regular para 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) {
    const 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:

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

Pero tenga en cuenta que no se debe confiar solo 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) {
  const 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() {
  const $result = $("#result");
  const 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").on("click", validate);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<form>
  <p>Enter an email address:</p>
  <input id='email'>
  <button type='submit' id='validate'>Validate!</button>
</form>

<h2 id='result'></h2>

He modificado ligeramente la respuesta de Jaymon para las personas que quieren una validación realmente simple en 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);
    }
    
console.log(validateEmail('[email protected]'));

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

El estándar oficial se conoce como RFC 2822 . Describe la sintaxis a la que deben adherirse las direcciones de correo electrónico válidas. Se puede ( pero no deberías - sigue 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 sintaxis usando comillas dobles y corchetes. Todavía coincidirá con el 99.99% de todas las direcciones de correo electrónico en uso real hoy.

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

Un cambio adicional que podría realizar es permitir cualquier dominio de nivel superior de código de país de dos letras y solo dominios genéricos específicos de nivel superior. Esta expresión regular filtra direcciones de correo electrónico falsas como[email protected] . 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])?\.)+(?:[A-Z]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)\b

Por lo tanto, incluso cuando se siguen las normas oficiales, todavía hay que hacer concesiones. No copie ciegamente expresiones regulares de bibliotecas en línea o foros de discusión. Siempre pruébelos con sus propios datos y con sus propias aplicaciones.

_{El énfasis es mío}

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

^\S+@\S+$

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

Hay algo que debes entender en el momento en que decidas usar 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 absolutamente seguro de que lo que ingresó el usuario es en realidad un correo electrónico es enviar un correo electrónico y ver qué sucede. Aparte de eso, todo son solo conjeturas.

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

<form><input type="email" placeholder="[email protected]" required>
    <input type="submit">
</form>

Enlace jsFiddle

De la especificación HTML5 :

Una dirección de correo electrónico válida es una cadena que coincide con la emailproducción del siguiente ABNF, cuyo juego 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 intencional de RFC 5322, que define una sintaxis para direcciones de correo electrónico que es simultáneamente demasiado estricta (antes del carácter "@"), demasiado vaga (después del carácter "@") y demasiado laxa (permitiendo comentarios , caracteres de espacios en blanco y cadenas citadas de maneras desconocidas para la mayoría de los usuarios) para que 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])?)*$/

He encontrado que esta es la mejor solución:

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

Permite los siguientes formatos:

1. [email protected]
2. [email protected]
3. [email protected]
4. [email protected]
9. #!$%&'*+-/=?^_`{}|[email protected]
6. "() []:,; @ \\\"! # $% & '* + - / =? ^ _ `{} | ~ .a "@ example.org
7. "" @ example.org (espacio entre comillas)
8. üñîçøðé@example.com (caracteres Unicode en la parte local)
9. üñîçøðé@üñîçøðé.com (caracteres Unicode en la parte del dominio)
10. Pelé@ejemplo.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, a la vez que impone el formato básico [email protected]. Bloqueará espacios que técnicamente están permitidos por RFC, pero son tan raros que estoy feliz de hacer esto.

En los navegadores modernos, puede construir sobre la respuesta de @ Sushil con JavaScript puro y 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 reunido 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 , lo libera de la masacre de expresiones regulares y no interfiere en los navegadores antiguos.

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

JavaScript puede coincidir con una expresión regular:

emailAddress.match( / some_regex /);

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

^((?>[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+\x20*|"((?=[\x01-\x7f])[^"\\]|\\[\x01-\x7f])*
"\x20*)*(?<angle><))?((?!\.)(?>\.?[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)>)$

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 válido sintácticamente RFC, 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.

La validación correcta de la dirección de correo electrónico de conformidad con los RFC no es algo que se pueda lograr con una expresión regular de una 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, se ha portado a Java. Creo que la función es demasiado compleja para ser portada y utilizada en JavaScript. Puerto JavaScript / node.js: https://www.npmjs.com/package/email-addresses .

Una buena práctica es validar sus datos en el cliente, pero verifique la validación en el servidor. Con esto en mente, simplemente puede verificar si una cadena se parece a 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: El último @debe ser anterior al último .desde@ que no puede ser parte del nombre del servidor (que yo sepa).

• 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 citarse, por "lo que estaría entre ese @y el último @en la dirección.

• lastDotPos > 2: Debe haber al menos tres caracteres antes del último punto, por ejemplo [email protected].

• (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.

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

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. Y no estoy seguro de por qué te molestarías con algo "más simple" ... vas a copiarlo y pegarlo de todos modos;)

A menudo, al almacenar direcciones de correo electrónico en la base de datos, las pongo 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 su uso en JavaScript (con el distintivo de mayúsculas y minúsculas ial 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('[email protected]') );

Nota :
Técnicamente, algunos correos electrónicos pueden incluir comillas en la sección anterior al @símbolo con caracteres de escape dentro de las comillas (por lo que su usuario de correo electrónico puede ser desagradable y contener cosas como @y "..."siempre que esté escrito entre comillas). NADIE HACE ESTO NUNCA! Es obsoleto Pero, ESTÁ incluido en el verdadero RFC 2822 estándar , y se omite aquí.

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

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,})$/

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

Y puedes ver el resultado aquí .

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

Ahora, dado que solo puede cubrir el 90% de los casos, escriba algo como:

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

Puedes refinarlo. Por ejemplo, 'aaa @' es válido. Pero en general se entiende 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 verifique si la dirección de correo electrónico ingresada es válida o no utiliza HTML.

<input type="email"/>

No hay necesidad de escribir una función para la validación.

Es difícil obtener un validador de correo electrónico 100% correcto. La única forma real de hacerlo correctamente sería enviar un correo electrónico de prueba a la cuenta. Dicho esto, hay algunas comprobaciones básicas que pueden ayudar a garantizar que esté obteniendo algo razonable.

Algunas cosas para mejorar:

En lugar de nuevo RegExp, solo trata de escribirlo regexpasí:

if (reg.test(/@/))

En segundo lugar, verifique que haya un punto después del @signo y asegúrese de que haya caracteres entre los @puntos y los puntos.

Así es como lo hace el validador de nodos :

/^(?:[\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])\]))$/

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

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

De lo contrario, puede usar jQuery . Las reglas internas definen:

eMailId: {
    required: true,
    email: true
}

Regex actualización 2018! prueba esto

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

versión de typscript completa

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

más información https://git.io/vhEfc

Una solución que no verifica la existencia del TLD es incompleta.

Casi todas las respuestas a estas preguntas sugieren usar Regex para validar las direcciones de correo electrónico. Creo que Regex solo es bueno para una validación rudimentaria. Parece que la validación de verificación de direcciones de correo electrónico es en realidad dos problemas separados:

1- Validación del formato de correo electrónico: asegurarse de que el correo electrónico cumpla con el formato y el patrón de los correos electrónicos en RFC 5322 y si el TLD realmente existe. Puede encontrar una lista de todos los TLD válidos aquí .

Por ejemplo, aunque la dirección [email protected]pasará la expresión regular, no es un correo electrónico válido, porqueccc IANA no es un dominio de nivel superior.

2- Asegurarse de que el correo electrónico realmente existe: para hacer esto, la única opción es enviar un correo electrónico a los usuarios .

Regex para validar la dirección de correo electrónico

[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 una muy buena discusión sobre el uso de expresiones regulares para validar direcciones de correo electrónico; " Comparación de la dirección de correo electrónico que valida expresiones regulares "

Aquí está la expresión superior actual, que es compatible con JavaScript, para fines de referencia:

/^[-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|[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i

Aparentemente, eso es todo:

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

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

Pero, por supuesto, eso ignora la internacionalización.

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

function isEmail(email) { 
    return /^((([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.test(email);
} 

Use así:

if (isEmail('[email protected]')){ console.log('This is email is valid'); }

Mi conocimiento de expresiones regulares. no es tan bueno. Es por eso que primero verifico la sintaxis general con una expresión regular simple y luego verifico opciones más específicas con otras funciones. Puede que esta no sea la mejor solución técnica, pero de esta manera soy mucho más flexible y rápido.

Los errores más comunes que he encontrado son espacios (especialmente al principio y al final) y ocasionalmente un doble punto.

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('[email protected]'); // Returns false
check_email(' [email protected]'); // Returns false
check_email('[email protected]'); // Returns true

<form name="validation" onSubmit="return checkbae()">
    Please input a valid email address:<br />

    <input type="text" size=18 name="emailcheck">
    <input type="submit" value="Submit">
</form>

<script language="JavaScript1.2">
    var testresults
    function checkemail(){
        var str = document.validation.emailcheck.value
        var filter = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i
        if (filter.test(str))
            testresults = true
        else {
            alert("Please input a valid email address!")
            testresults = false
        }
        return (testresults)
    }
</script>

<script>
    function checkbae(){
        if (document.layers || document.getElementById || document.all)
            return checkemail()
        else
            return true
    }
</script>

Estaba buscando un Regex en JS que pasa todos los casos de prueba de dirección de correo electrónico:

• [email protected] Email valido

• [email protected] El correo electrónico contiene un punto en el campo de dirección

• [email protected] El correo electrónico contiene puntos con subdominio

• [email protected] El signo más se considera un carácter válido.

• [email protected] El dominio es una dirección IP válida

• email@[192.0.2.123] El corchete alrededor de la dirección IP se considera válido

• “email”@example.com Las cotizaciones alrededor del correo electrónico se consideran válidas

• [email protected] Los dígitos en la dirección son válidos

• [email protected] El guión en el nombre de dominio es válido

• [email protected] El guión bajo en el campo de dirección es válido

• [email protected] .name es un nombre de dominio de nivel superior válido

• [email protected] El punto en el nombre de dominio de nivel superior también se considera válido (usando co.jp como ejemplo aquí)

• [email protected] El guión en el campo de dirección es válido

Aquí vamos :

http://regexr.com/3f07j

O regex:

Regex = /(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@[*[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+]*/

La expresión regular proporcionada por Microsoft dentro de ASP.NET MVC es

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

Que publico aquí en caso de que sea defectuoso, aunque siempre ha sido perfecto para mis necesidades.