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?

preguntado el 05 de septiembre de 08 a las 14:09

¡¡Advertencia!! La respuesta aceptada es objetivamente incorrecta, ya que no se ajusta a las especificaciones. Lea todas las respuestas para obtener más detalles. -

30 Respuestas

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>

Respondido el 13 de diciembre de 20 a las 17:12

Esta expresión regular elimina los correos electrónicos válidos en uso. No utilice. Busque en Google "RFC822" o "RFC2822" para obtener una expresión regular adecuada. - Randal Schwartz

Esto ni siquiera acepta los ejemplos en RFC 822. En algunos casos simples, no coincide con a \ @ b @ c.com, a(b)@c.com. Consulte el RFC para obtener más información. Aquí hay una expresión regular que no rechazará ninguna dirección válida [^ @] + @ [^ @] + \. [^ @] + Y protege contra errores comunes. - Vroo

No puede validar direcciones de correo electrónico, punto. El único que puede validar una dirección de correo electrónico es el proveedor de la dirección de correo electrónico. Por ejemplo, esta respuesta dice estas direcciones de correo electrónico: %2@gmail.com, "%2"@gmail.com, "a..b"@gmail.com, "a_b"@gmail.com, _@gmail.com, 1@gmail.com , 1_example@something.gmail.com son todas válidas, pero Gmail nunca permitirá ninguna de estas direcciones de correo electrónico. Debe hacer esto aceptando la dirección de correo electrónico y enviando un mensaje de correo electrónico a esa dirección de correo electrónico, con un código / enlace que el usuario debe visitar para confirmar la validez. - kevin fegan

En estos días, Javascript se puede ejecutar en un servidor, por lo que para aquellos que piensan que esto solo es relevante para la validación del lado del cliente, están equivocados. Y para aquellos que dicen que no es posible validar un correo electrónico, creo que están perdiendo el punto de validación en general. NUNCA escribirás la validación de un formulario para asegurarte de que todo sea 100% perfecto por dos razones principales: 1. Tomaría más tiempo del que valdría la pena escribir la lógica y 2. Siempre habrá un caso límite en el que los datos sean incorrectos. podría ser enviado. La razón por la que validamos es para fomentar el envío adecuado de datos y evitar errores. - Disparador de limpieza

Cuidado, esto no es válido: re.test("username+something@gmail.com") - Adriaan

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

Respondido 22 Feb 21, 21:02

Puede implementar algo 20 veces más largo que podría causar problemas a algunos usuarios y podría no ser válido en el futuro, o puede tomar la versión de ImmortalFirefly para asegurarse de que al menos se esfuercen para que parezca real. Dependiendo de su aplicación, es más probable que se encuentre con alguien que se enoje porque no acepta su correo electrónico poco convencional, en lugar de alguien que causa problemas al ingresar direcciones de correo electrónico que realmente no existen (lo que pueden hacer de todos modos ingresando una dirección de correo electrónico RFC100 2822% válida pero utilizando un nombre de usuario o dominio no registrado). ¡Voto a favor! - user83358

@ImmortalFirefly, la expresión regular que proporcionó coincidirá name@again@example.com. Intente pegar su línea en una consola JavaScript. Creo que su intención era hacer coincidir solo el texto completo, lo que requeriría los operadores de comienzo de texto '^' y final de texto '$'. El que estoy usando es /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test('name@again@example.com') - Camino de Oregón

@OregonTrail Las direcciones de correo electrónico válidas pueden contener @ caracteres entre comillas, y su expresión regular las rechazaría. Podría decirse que eso lo coloca en un punto medio indeseable donde tiene errores de tipo I y tipo II (es decir, estaría mejor con solo errores de tipo I de la expresión regular grande, o solo errores de tipo II de la pequeña). Es cierto que es una compensación, ya que un doble @ error tipográfico es bastante fácil de hacer y los correos electrónicos que contienen @ adicionales son prácticamente inexistentes en la práctica. - pablo hendry

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

Respondido el 20 de junio de 20 a las 10:06

NB: "En uso real ahora"puede haber sido válido cuando se escribió el código, en 200x. El código probablemente permanezcan en uso más allá de ese año específico. (Si tuviera un centavo por cada "meh, nadie usará un TLD de más de 4 letras excepto los específicos" que tuviera que arreglar, podría acaparar el mercado mundial del cobre y el níquel;)) - Piskvor salió del edificio

Ahora hay tantos dominios de nivel superior que filtrarlos es contraproducente. o al menos propenso a cambios constantes. - pstantón

Esto no parece cubrir los comentarios en las direcciones de correo electrónico, que están en el RFC, por absurda que sea la noción. matt@example (this is comment don't you know) .com debería coincidir, pero no lo es. - matt ellen

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.

respondido 28 nov., 18:10

+1, ya que enviar un correo electrónico y ver lo que sucede es la única forma realmente segura de validar una dirección de correo electrónico, no hay necesidad de hacer más que una simple coincidencia de expresiones regulares. - kommradHomer

Aún puede mantenerlo simple, pero haga un poco más para asegurarse de que tenga un "." en algún lugar después de @ seguido solo de números o dígitos, por lo que cosas como yo @ aquí, yo @ aquí @ y yo @ aquícom no son válidas ... ^ \ S + @ \ S + [\.] [0-9a-z ] + $ - tim franklin

Creo que las direcciones de correo electrónico pueden contener espacios. Probablemente sea mejor usar .+@.+ - Diana

/\S+@\S+/.test("áéíóúý@ÁÉÍÓÚÝð") true - gtournie

@gtournie A nadie le importa. Nadie va a ingresar eso en un campo de correo electrónico. por accidente, y eso es todo, la validación de front-end es para: Para evitar que las personas ingresen accidentalmente información incorrecta, como su nombre, en un campo de correo electrónico. - meagar ♦

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.

contestado el 02 de mayo de 09 a las 18:05

-1 ¿Por qué querría dedicar mi tiempo a validar una dirección de correo electrónico que ni siquiera pasa el control de expresiones regulares? - kommradHomer

@PaoloBergantino lo digo en serio, ¿por qué intentaría enviar un correo electrónico para verificar una dirección de correo obviamente incorrecta? Incluso si necesito "estar absolutamente seguro de que lo que el usuario ingresó es de hecho un correo electrónico", solo verificaría las direcciones de correo electrónico que coincidan con la expresión regular. kommradHomer

@kommradHomer: una dirección de "expresión regular no válida" es casi siempre válida, porque cualquier expresión regular que use para validar una dirección de correo electrónico es casi seguro que es incorrecta y excluirá las direcciones de correo electrónico válidas. Una dirección de correo electrónico es name_part@domain_part y prácticamente cualquier cosa, incluso an @, es válido en name_part; La dirección foo@bar@machine.subdomain.example.museum es legal, aunque debe evitarse como foo\@bar@machine..... Una vez que el correo electrónico llega al dominio, por ejemplo, 'ejemplo.com', ese dominio puede enrutar el correo "localmente" para que existan nombres de usuario y nombres de host "extraños". - Esteban P.

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])?)*$/

Respondido el 03 de diciembre de 20 a las 21:12

esto es bueno, pero el problema con esto es que debe estar dentro de un form etiqueta y enviado por un submit entrada, que no todo el mundo puede darse el lujo de hacer. Además, realmente no se puede diseñar el mensaje de error. - Jason

Diciembre de 2020 @Jason - ¿El uso de la validación de HTML5 aún requiere 'dentro de una etiqueta de formulario y enviado por una entrada de envío'? o puede ser 'llamado' en Javascript. Esta validación parece suceder DESPUÉS de mis validaciones codificadas de Javascript. - aNuevob

La semántica HTML requiere tener un elemento si está mostrando el componente de formulario. Dicho esto, siempre debe usar un formulario cuando use input. - Dimitri Kopriwa

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.

Respondido el 21 de Septiembre de 15 a las 02:09

Se ajusta a lo que usted mismo definió, pero la parte de host de una dirección de correo electrónico no es necesariamente un dominio. Por lo tanto, un punto no es algo en lo que pueda confiar, ejemplos: john@[::1] y john@server. - AmigoJack

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.

Respondido 25 Jul 18, 08:07

Esta es una idea inteligente para resolver el problema, pero no funciona porque los navegadores también tienen una validación deficiente. P.ej .@a valida como true en las versiones actuales de Chrome, Firefox y Safari. - Hank

@HenryJackson Desafortunadamente, en este caso sí. Esto se debe a que, según el RFC, esa es una dirección de correo electrónico válida (piense en las intranets). Los navegadores serían cuestionados si validan demasiado estrechos y producen falsos negativos. - Boldewyn

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

Respondido 25 Feb 15, 15:02

Las direcciones IDN no están validadas (info@üpöü.com) - DAH

'a @ a' devuelve válido: jsfiddle.net/pmiranda/guoyh4dv - pmiranda

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

Respondido 24 ago 13, 21:08

@Kato: usa algunas extensiones incompatibles, incluidas (?> para dejar de dar marcha atrás y (?<angle><)…(?(angle)>) para evitar proporcionar una larga |. - Ry- ♦

La match El método devuelve una matriz, el test El método, que devuelve un booleano, sería mejor para esta situación. - iPzard

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.

Respondido el 20 de Septiembre de 20 a las 23:09

¿Y si hubiera más de un símbolo '@'? otros símbolos restringidos? No se puede confiar en esta validación ... - Iwazovsky

¿Es un correo electrónico válido a @ b? - Aravin

@Aravin Podría ser, en una LAN. - Nayuki

pero la pregunta es genérica, no para el sistema local de LAN - Aravin

Es mejor que la mayoría, sí, podría tener más de una @ con esto, pero también podría ser un correo electrónico válido como "@"@mydomain.jskd o elldffs (este es @ comment) @ mydomain.kjfdij. Ambos son correos electrónicos sintácticamente válidos: David Martensson

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.

Respondido 31 Oct 18, 09:10

Creo que esta es una mejor forma de validar el correo electrónico en comparación con la expresión regular, la expresión regular es excelente, pero puede que no sea una herramienta adecuada para este problema. La única sugerencia sería tener esta cadena de reglas de validación dividida en variables descriptivas, solo por el bien de la legibilidad de este ejemplo: GnrlBzik

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

contestado el 02 de mayo de 09 a las 18:05

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

respondido 04 mar '19, 19:03

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

respondido 13 nov., 16:10

La parte local tiene una longitud máxima, que no está validada. - AmigoJack

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

respondido 09 mar '15, 17:03

Esto permite la entrada de tantas direcciones de correo electrónico inválidas que es un consejo inútil. - cazlab

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.

respondido 14 mar '14, 16:03

Ver comentario anterior 32 esto es bueno, pero el problema con esto es que debe estar dentro de una etiqueta de formulario y enviado por una entrada de envío, lo que no todos pueden darse el lujo de hacer. Además, realmente no se puede diseñar el mensaje de error. - @Jason 12 de noviembre de 11 a las 0:08 - aNuevob

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.

Respondido 15 Abr '18, 11:04

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])\]))$/

Respondido 15 Abr '18, 11:04

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
}

Respondido 15 Abr '18, 11:04

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.

Respondido 02 Jul 18, 02:07

¡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

Respondido 07 ago 18, 15:08

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])+

Respondido 05 Jul 19, 12:07

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

contestado el 28 de mayo de 10 a las 23:05

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.

Respondido 01 Oct 10, 10:10

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

respondido 14 mar '14, 16:03

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

Respondido el 01 de junio de 16 a las 06:06

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

Respondido el 05 de junio de 14 a las 10:06

Ver comentario anterior 32 esto es bueno, pero el problema con esto es que debe estar dentro de una etiqueta de formulario y enviado por una entrada de envío, lo que no todos pueden darse el lujo de hacer. Además, realmente no se puede diseñar el mensaje de error. - @Jason 12 de noviembre de 11 a las 0:08 - aNuevob

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-.]+]*/

Respondido 03 ago 18, 00:08

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

Respondido el 21 de junio de 17 a las 10:06

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.