Cómo 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í (tomado 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 desactivar 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 desean una validación realmente simple en forma de:

anystring@anystring.anystring

La expresión regular:

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

Para evitar que coincidan varios signos @:

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

Ejemplo de función de JavaScript:

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

Solo para completar, aquí tienes 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. Usted puede (pero no deberías - leer en) 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. Seguirá coincidiendo con el 99.99% de todas las direcciones de correo electrónico que se utilizan actualmente.

[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 hacer es permitir cualquier dominio de nivel superior de código de país de dos letras y solo dominios de nivel superior genéricos específicos. Esta expresión regular filtra direcciones de correo electrónico ficticias como asdf@adsf.adsf. Usted 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

Entonces, incluso cuando se siguen los estándares oficiales, todavía hay concesiones por hacer. No copie a ciegas expresiones regulares de bibliotecas en línea o foros de discusión. Pruébelos siempre con sus propios datos y con sus propias aplicaciones.

_{Énfasis mío}

Vaya, 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, que es de lo que se trata la validación de JavaScript.

Hay algo que debe comprender en el momento en que decide usar una expresión regular para validar los correos electrónicos: Probablemente no sea una buena idea. Una vez que haya aceptado eso, existen muchas implementaciones que pueden llevarlo a la mitad del camino, este artículo los resume muy bien.

En resumen, sin embargo, la única forma de estar 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.

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

<form><input type="email" placeholder="me@example.com" required>
    <input type="submit">
</form>

jsviolín aquí

Desde el Especificación HTML5:

A Dirección de email válida es una cadena que coincide con el email producció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 un violación intencionada 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, espacios en blanco y comillas cadenas de formas desconocidas para la mayoría de los usuarios) para ser 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 descubierto 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, sin dejar de aplicar el formato básico anything@anything.anything. 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 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 puesto 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 Respuesta de Squirtle, te libera de la masacre de las expresiones regulares y no funciona con los navegadores antiguos.

Ésta 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 un RFC22 expresión regular 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 "arroba" (es decir, @). Pruebe esa condición necesaria:

email.indexOf("@") > 0

No se moleste con nada más complicado. Incluso si pudiera determinar perfectamente si un correo electrónico es sintácticamente válido RFC, eso no le dirá si pertenece a la persona que lo proporcionó. 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 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, 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 vuelva a verificar la validación en el servidor. Con esto en mente, simplemente puede verificar si una cadena parece una dirección de correo electrónico válida en el cliente y realizar la verificación estricta en el servidor.

Aquí está la función de JavaScript que uso para verificar si una cadena parece 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: Último @ debería ser antes del último . desde @ 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 debería haber @@ en la dirección. Incluso si @ aparece como el último carácter en el nombre de usuario del correo electrónico, debe citarse para " estaría entre eso @ 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 de 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" ... lo copiarás y pegarás 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 cómo se usa en JavaScript (con la marca que no distingue entre 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 citas 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 Dirección de correo electrónico de Wikipedia.

Y puedes ver el resultado en 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, entiendes la esencia. Y no se deje llevar ... Una simple solución 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 usa HTML.

<input type="email"/>

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

Es difícil conseguir que un validador de correo electrónico sea 100% correcto. La única forma real de corregirlo sería enviar un correo electrónico de prueba a la cuenta. Dicho esto, existen algunas comprobaciones básicas que pueden ayudar a asegurarse de que está obteniendo algo razonable.

Algunas cosas para mejorar:

En lugar de nuevo RegExp, solo intenta escribir el regexp salir así:

if (reg.test(/@/))

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

Esta es la forma validador de nodos lo hace:

/^(?:[\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, puedes usar jQuery. Las reglas internas definen:

eMailId: {
    required: true,
    email: true
}

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

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

1- Validación de 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. Se puede encontrar una lista de todos los TLD válidos aquí.

Por ejemplo, aunque la dirección example@example.ccc pasará la expresión regular, no es un correo electrónico válido, porque ccc no es un dominio de nivel superior de IANA.

2- Asegurarse de que el correo electrónico realmente exista: Por hacer esto, la unica opcion is enviar a los usuarios un correo electrónico.

¡Actualización de expresiones regulares 2018! prueba esto

let val = 'email@domain.com';
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

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 direcciones de correo electrónico Validación de expresiones regulares"

Aquí está la expresión superior actual, que es compatible con JavaScript, con 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 10.

Pero, por supuesto, eso es ignorar la internacionalización.

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 con los que me he encontrado son los espacios (especialmente al principio y al final) y ocasionalmente un punto doble.

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

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

Úselo así:

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

<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 una expresión regular en JS que pase todos los casos de prueba de direcciones de correo electrónico:

• email@example.com Email valido

• firstname.lastname@example.com El correo electrónico contiene un punto en el campo de dirección

• email@subdomain.example.com El correo electrónico contiene un punto con subdominio

• firstname+lastname@example.com El signo más se considera un carácter válido

• email@192.0.2.123 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

• 1234567890@example.com Los dígitos de la dirección son válidos

• email@domain-one.example El guión en el nombre de dominio es válido

• _______@example.com El subrayado en el campo de dirección es válido

• email@example.name .name es un nombre de dominio de nivel superior válido

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

• firstname-lastname@example.com El guión en el campo de dirección es válido

Aquí vamos :

http://regexr.com/3f07j

O expresión regular:

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

Sintaxis de correo estándar de Wikipedia:

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;g<h>i[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

Muestre esta prueba: https://regex101.com/r/LHJ9gU/1