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

4976

¿Existe una expresión regular para verificar una dirección de correo electrónico en JavaScript?

5
  • 12
    ¡¡Advertencia!! La respuesta aceptada es objetivamente incorrecta, ya que no se ajusta a las especificaciones. Lea todas las respuestas para obtener más detalles. David Mårtensson 16 de febrero a las 18:25
  • @ DavidMårtensson Es casi inútil validar los correos electrónicos de acuerdo con la especificación, la especificación es mucho más liberal en comparación con lo que de facto se considera un correo electrónico bien formado. Si su objetivo es, por ejemplo, validar un correo electrónico en un formulario para detectar errores que no puede cumplir con la especificación, es demasiado indulgente para detectar errores reales del usuario. Alex 19 mar a las 11:02
  • 1
    @Alex La razón por la que agregué este comentario es que la expresión regular sugerida en la respuesta aceptada no permitirá las direcciones de correo electrónico en vivo existentes, lo cual es un mal comienzo para un cliente, y el gran problema es que incluso SI la dirección fue aceptada, todavía no lo hace. decir si funciona. La única forma de verificar de manera confiable que un correo electrónico proporcionado es un correo electrónico válido y funcional es enviar un correo con un enlace de verificación. Por lo tanto, si su caso de uso no exige que verifique el correo electrónico, simplemente haga una prueba mínima para @; de lo contrario, use un correo electrónico de verificación. Regex solo proporcionará una mala experiencia de usuario. David Mårtensson 3 de mayo a las 14:56
  • @David Mårtensson Agregué un + a sus pensamientos. Sin embargo, creo que un enlace de correo electrónico de verificación también puede ser una mala experiencia para el usuario. Uno que puede hacerte perder un cliente. mikael1000 3 de junio a las 10:22
  • @ mikael1000 Seguro, pero ¿cuál es el propósito de una validación de expresiones regulares cuando no sabrás si es un correo electrónico válido de todos modos? Si no desea entrometerse en el cliente con un enlace de validación, simplemente haga la validación más simple <algo> en <algo> y déjelo así. Se asegurará de que el cliente al menos agregue algo que podría ser un correo electrónico, algo más, es principalmente una pérdida de código hasta que llegue a validarlo. Posiblemente podría verificar si el dominio existe con una búsqueda de dns. David Mårtensson 4 de junio a las 14:23
5799

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

function validateEmail(email) {
    const re = /^(([^<>()[\]\\.,;:\[email protected]"]+(\.[^<>()[\]\\.,;:\[email protected]"]+)*)|(".+"))@((\[[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 = /^(([^<>()[\]\.,;:\[email protected]\"]+(\.[^<>()[\]\.,;:\[email protected]\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\[email protected]\"]+\.)+[^<>()[\]\.,;:\[email protected]\"]{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 = /^(([^<>()[\]\\.,;:\[email protected]\"]+(\.[^<>()[\]\\.,;:\[email protected]\"]+)*)|(\".+\"))@((\[[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;
}

$("#email").on("input", validate);
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<label for=email>Enter an email address:</label>
<input id="email">
<h2 id="result"></h2>
7
  • 647
    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 8 de septiembre de 2010 a las 2:34
  • 58
    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 26/10/12 a las 6:32
  • 178
    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 que estas direcciones de correo electrónico: %[email protected], "%2"@gmail.com, "a..b"@gmail.com, "a_b"@gmail.com, [email protected], [email protected] , [email protected]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 1 de febrero de 2014 a las 8:49
  • @KevinFegan seamos realistas: no usarías JavaScript para confirmar si un correo electrónico es auténtico. Veo esta validación como perfectamente razonable cuando un usuario se registra. Probablemente no quiera molestarse en enviar correos electrónicos de verificación a direcciones que no pueden existir. Algunos también pueden tener límites saliente de correo electrónico, por lo que es digno de norte a enviar correos electrónicos a [email protected], i don't have an emailo cualquier otro insumo divertidos de usuario. undefined 16 de julio a las 23:02
  • [email protected] - la muestra es válida, lo que no deberíaGautam Parmar 6 de agosto a las 6:33
1056

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

[email protected]

La expresión regular:

/\[email protected]\S+\.\S+/

Para evitar que coincidan varios signos @:

/^[^\[email protected]][email protected][^\[email protected]]+\.[^\[email protected]]+$/

Ejemplo de función de JavaScript:

function validateEmail(email) 
    {
        var re = /\[email protected]\S+\.\S+/;
        return re.test(email);
    }
    
console.log(validateEmail('[email protected]'));
3
  • 84
    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 RFC2822 100% válida pero utilizando un nombre de usuario o dominio no registrado). ¡Voto a favor! user83358 30/07/12 a las 18:20
  • 113
    @ImmortalFirefly, la expresión regular que proporcionaste coincidirá [email protected]@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/^[^\[email protected]][email protected][^\[email protected]]+\.[^\[email protected]]+$/.test('[email protected]@example.com') ... OregonTrail 9 de agosto de 2012 a las 14:58
  • La segunda expresión regular no requiere un dominio de nivel superior, es decir, acepta [email protected]. Pero AFAIK, esta es en realidad una dirección de correo electrónico válida, aunque poco común. La primera expresión regular requiere un TLD, por lo que no cubre este tipo de direcciones. waldgeist 15 jul a las 13:00
843

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

The official standard is known as RFC 2822. It describes the syntax that valid email addresses must adhere to. You can (but you shouldn'tread on) implement it with this regular expression:

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

(...) We get a more practical implementation of RFC 2822 if we omit the syntax using double quotes and square brackets. It will still match 99.99% of all email addresses in actual use today.

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

A further change you could make is to allow any two-letter country code top level domain, and only specific generic top level domains. This regex filters dummy email addresses like [email protected]. You will need to update it as new top-level domains are added.

[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

So even when following official standards, there are still trade-offs to be made. Don't blindly copy regular expressions from online libraries or discussion forums. Always test them on your own data and with your own applications.

Énfasis mío

1
  • 93
    NB: "En uso real hoy " puede haber sido válido cuando se escribió el código, en 200x. Es probable que el código permanezca en uso más allá de ese año específico. (Si tuviera un centavo por cada "meh, nadie usaría 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 left the building 13/06/12 a las 15:51
434

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

^\[email protected]\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.

2
  • 83
    +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 19/07/12 a las 7:14
  • 1
    Pero no aceptará "Mohit Atray" @ gmail.com porque contiene un carácter de espacio. Tal vez deberíamos usar /^\S.*@\S+$/ regex. Mohit Atray 8 de julio a las 19:57
349

Hay algo que debes entender en el momento en que decides usar una expresión regular para validar correos electrónicos: probablemente no sea una buena idea . Una vez que haya aceptado eso, hay muchas implementaciones que pueden llevarlo a la mitad del camino, este artículo las 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.

1
  • 70
    @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 [email protected]_party prácticamente cualquier cosa, incluida una @, es válida en name_part; La dirección [email protected]@machine.subdomain.example.museumes legal, aunque debe escaparse como foo\@[email protected]. 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". Stephen P 7 de marzo de 2013 a las 1:40
245

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="[email protected]" required>
    <input type="submit">
</form>

jsFiddle enlace

De la especificación HTML5 :

A valid e-mail address is a string that matches the email production of the following ABNF, the character set for which is 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 >

This requirement is a willful violation of RFC 5322, which defines a syntax for e-mail addresses that is simultaneously too strict (before the "@" character), too vague (after the "@" character), and too lax (allowing comments, whitespace characters, and quoted strings in manners unfamiliar to most users) to be of practical use here.

The following JavaScript- and Perl-compatible regular expression is an implementation of the above definition.

/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-][email protected][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])?)*$/
1
  • 35
    esto es bueno, pero el problema con esto es que debe estar dentro de una formetiqueta y enviado por una submitentrada, lo que no todo el mundo puede darse el lujo de hacer. Además, realmente no se puede diseñar el mensaje de error. Jason 12/11/11 a las 0:08
172

He descubierto que esta es la mejor solución:

/^[^\[email protected]][email protected][^\[email protected]]+\.[^\[email protected]]+$/

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 (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 personajes internacionales más importantes, sin dejar de aplicar 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.

0
107

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() : /\[email protected]\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 funciona en navegadores antiguos.

1
  • Esta debería ser la respuesta aceptada por mucho. Permita que los proveedores de navegadores con gurús de las expresiones regulares en el personal mantengan expresiones regulares enormemente complicadas para las direcciones de correo electrónico. El desarrollador de frontend promedio que crea un formulario para recopilar correo electrónico no suele tener tiempo para dominar las expresiones regulares detalladas. Sí, debe confiar en la expresión regular que proporciona el proveedor, pero si necesita algo más complejo, hágalo en el servidor o envíe un correo electrónico real y verifique la respuestaMatt 16 de julio a las 11:04
75

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

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)>)$
2
  • 1
    @Kato: Utiliza algunas extensiones incompatibles, incluso (?>para detener el retroceso y (?<angle><)…(?(angle)>)evitar proporcionar un archivo |. Ry- 9 de marzo de 2014 a las 20:05
  • El matchmétodo devuelve una matriz, el testmétodo, que devuelve un booleano, sería mejor para esta situación. iPzard 7 nov.20 a las 20:43
71

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: El último @debe estar antes del último, .ya @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 un no @@en la dirección. Incluso si @aparece como el último carácter en el nombre de usuario del correo electrónico, se debe citar, 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 de si los corchetes son necesarios.

0
67

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.

3
  • 14
    ¿Y si hubiera más de un símbolo '@'? otros símbolos restringidos? No se puede confiar en esta validación ...iwazovsky 26/04/2015 a las 10:14
  • ¿Es un correo electrónico válido a @ b? Aravin 20/12/20 a las 10:17
  • 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álidosDavid Mårtensson 16 de febrero a las 18:37
62

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

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

Está basado en RFC 2822

Pruébelo en https://regex101.com/r/857lzc/1

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 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 antes del @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 estándar RFC 2822 y se omite aquí.

Nota 2 : El comienzo de un correo electrónico (antes del signo @) puede distinguir entre mayúsculas y minúsculas (a través de la especificación). Sin embargo, cualquiera que tenga un correo electrónico que distinga entre mayúsculas y minúsculas probablemente esté acostumbrado a tener problemas y, en la práctica, no distingue entre mayúsculas y minúsculas es una suposición segura. Más información: ¿Las direcciones de correo electrónico distinguen entre mayúsculas y minúsculas?

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

1
45

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

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

Y puedes ver el resultado aquí .

ingrese la descripción de la imagen aquí

0
26

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.

0
26

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

1
  • 23
    Esto permite la entrada de tantas direcciones de correo electrónico inválidas que es un consejo inútil. cazlab 6 ene 12 a las 23:07
19

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 ser nuevo RegExp, intente escribirlo regexpasí:

if (reg.test(/@/))

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

18

Así es como lo hace el validador de nodos :

/^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~][email protected](?:(?:(?:[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])\]))$/
15

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 del formato de correo electrónico: Asegurarse de que el correo electrónico cumpla 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 [email protected]pasará la expresión regular, no es un correo electrónico válido porque cccno es un dominio de nivel superior de IANA.

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 .

14

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
}
0
14

¡Actualización de expresiones regulares 2018! prueba esto

let val = '[email protected]';
if(/^[a-z0-9][a-z0-9-_\.][email protected]([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-_\.][email protected]([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[a-z]{2,10})?$/.test(val);

más info https://git.io/vhEfc

0
13

A diferencia de Squirtle , aquí hay una solución compleja, pero hace un gran trabajo validando 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('[email protected]')){ console.log('This is email is valid'); }
0
13

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

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 validando 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
0
12

Aparentemente, eso es todo:

/^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~][email protected]((((([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.

0
12

Mi conocimiento de las 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(/\[email protected]\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('[email protected]'); // Returns false
check_email('[email protected]'); // Returns false
check_email(' [email protected]'); // Returns false
check_email('[email protected]'); // Returns true
10

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 /^(([^<>()\[\]\.,;:\[email protected]\"]+(\.[^<>()\[\]\.,;:\[email protected]\"]+)*)|(\".+\"))@(([^<>()\.,;\[email protected]\"]+\.{0,1})+([^<>()\.,;:\[email protected]\"]{2,}|[\d\.]+))$/.test(mail);
}

// VALID MAILS

validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('[email protected]') // Return true
validMail('user+mailbox/[email protected]') // Return true
validMail('"very.(),:;<>[]\".VERY.\"[email protected]\\ \"very\".unusual"@strange.example.com') // Return true
validMail('!#$%&\'*+-/=?^_`.{|}[email protected]') // Return true
validMail('"()<>[]:,;@\\\"!#$%&\'-/=?^_`{}| ~.a"@example.org') // Return true
validMail('"[email protected]"@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('[email protected][IPv6:2001:DB8::1]') // Return true

// INVALID MAILS

validMail('Abc.example.com') // Return false
validMail('[email protected]@[email protected]') // Return false
validMail('a"b(c)d,e:f;g<h>i[j\k][email protected]') // Return false
validMail('just"not"[email protected]') // Return false
validMail('this is"not\[email protected]') // Return false
validMail('this\ still\"not\\[email protected]') // Return false
validMail('[email protected]') // Return false
validMail('[email protected]') // Return false

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

0
10

Estaba buscando una expresión regular en JS que pase todos los casos de prueba de direcciones de correo electrónico:

Aquí vamos :

http://regexr.com/3f07j

O expresión regular:

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

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

function checkbae() {
  if (document.layers || document.getElementById || document.all)
    return checkemail()
  else
    return 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>
0