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

StackOverflow https://stackoverflow.com/questions/46155

Pregunta

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

¿Fue útil?

Solución

Usando expresiones regulares es probablemente la mejor manera.Puedes ver un montón de pruebas. aquí (tomado 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 no se debe confiar únicamente 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) {
  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").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>

Otros consejos

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

El estándar oficial se conoce como RFC 2822.Describe la sintaxis que deben seguir las direcciones de correo electrónico válidas.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 del RFC 2822 si omitimos la sintaxis utilizando 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])?

Otro cambio que podría realizar es permitir cualquier dominio de nivel superior con 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.Tú Será necesario 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 los estándares oficiales, todavía hay que hacer concesiones. No copie ciegamente expresiones regulares de bibliotecas en línea o foros de discusión.Pruébelos siempre con sus propios datos y con sus propias aplicaciones.

El énfasis es mío.

Modifiqué ligeramente la respuesta de Jaymon para las personas que desean una validación realmente simple en forma de:

cualquiercadena@cualquiercadena.cualquiercadena

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

Vaya, hay mucha complejidad aquí.Si todo lo que quieres 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 garantiza que el formulario sea correcto en su mayor parte, que es de lo que se trata la validación de JavaScript.

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

En resumen, sin embargo, la única manera de estar absoluta y positivamente seguro de que lo que el usuario ingresó es en realidad un correo electrónico es enviar un correo electrónico y ver qué sucede.Aparte de eso, son sólo conjeturas.

El propio HTML5 tiene validación de correo electrónico.Si su navegador admite HTML5, puede utilizar el siguiente código.

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

jsFiddle enlace

Desde el Especificaciones 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 intencional de RFC 5322, que define una sintaxis para 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 (permite comentarios, espacios en blanco y comillas). cadenas de maneras desconocidas para la mayoría de los usuarios) para que sea 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 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 (space between the quotes)
8.  üñîçøðé@example.com (Unicode characters in local part)
9.  üñîçøðé@üñîçøðé.com (Unicode characters in domain part)
10. Pelé@example.com (Latin)
11. δοκιμή@παράδειγμα.δοκιμή (Greek)
12. 我買@屋企.香港 (Chinese)
13. 甲斐@黒川.日本 (Japanese)
14. чебурашка@ящик-с-апельсинами.рф (Cyrillic)

Es claramente versátil y permite los caracteres internacionales más importantes, al mismo tiempo que aplica el formato básico cualquier cosa@cualquier cosa.cualquier cosa.Bloqueará espacios que técnicamente están permitidos por RFC, pero son tan raros que estoy feliz de hacerlo.

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

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 preparado 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 La respuesta de Squirtle, te libera de la masacre de expresiones regulares y no molesta en los navegadores antiguos.

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

Esta es la versión RFC822 correcta.

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

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

email.indexOf("@") > 0

No te molestes en nada más complicado.Incluso si pudiera determinar perfectamente si un correo electrónico es sintácticamente válido según RFC, eso no le diría 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 los 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. Puerto JavaScript/node.js: https://www.npmjs.com/package/email-addresses.

Una buena práctica es validar tus datos en el cliente, pero volver a verificar la validación en el servidor.Con esto en mente, puede simplemente verificar si una cadena parece 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 comprobar 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 (hasta donde yo sé).

  • lastAtPos > 0:Debería 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 que " 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 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;}

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í.

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

A menudo, cuando almaceno 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 distinguir 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 indicador 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 entre comillas (por lo que su usuario de correo electrónico puede ser desagradable y contener cosas como @ y "..." siempre y cuando esté escrito entre comillas).¡NADIE HACE ESTO NUNCA!Está obsoleto.Pero ESTÁ incluido en la verdadera RFC 2822 estándar y se omite aquí.

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

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

Ahora que sólo 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 entiendes la esencia.Y no te dejes 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 usa HTML.

<input type="email"/>

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

Así es como validador de nodo 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])\]))$/

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

Algunas cosas para mejorar:

en lugar de nuevo RegExp, simplemente intenta escribir el regexp sale así:

if (reg.test(/@/))

En segundo lugar, verifique para asegurarse de que haya un punto después del @ firme y asegúrese de que haya caracteres entre los @s y períodos.

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

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 mecanografiada 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

La mejor expresión regular jamás creada que cumple con el 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])+

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 sólo sirve para una validación rudimentaria.Parece que la verificación de la validación de las direcciones de correo electrónico son en realidad dos problemas separados:

1- Validación del formato del correo electrónico: Asegurarse de si el correo electrónico cumple con el formato y patrón de 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 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 la IANA.

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

Al parecer, 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 es ignorar la internacionalización.

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

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

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 principal actual, que es compatible con JavaScript, como 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

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 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('check@this..com'); // Returns false
check_email(' check@this.com'); // Returns false
check_email('check@this.com'); // 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>

La expresión regular proporcionada por Microsoft dentro ASP.NETMVC es

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

Lo cual publico aquí en caso de que tenga algún defecto, aunque siempre ha sido perfecto para mis necesidades.

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

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

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top