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

validar formulario javascript

Question

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

Answer 1

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

Casi todas las respuestas a estas preguntas sugieren usar Regex para validar las direcciones de correo electrónico. Creo que Regex solo es bueno para una validación rudimentaria. Parece que la 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 el patrón de los correos electrónicos en RFC 5322 y si el TLD existe realmente. Una lista de todos los TLD válidos se puede encontrar here .

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

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

Answer 2

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.

Answer 3

Así es como lo hace el node-validator :

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

Answer 4

En los navegadores modernos, puedes 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 reunido un ejemplo en el violín http://jsfiddle.net/boldewyn/2b6d5/ . Combinado con la detección de funciones y la validación básica de Squirtle''s Answer , te libera de la masacre de expresiones regulares y no funciona con los navegadores antiguos.

Answer 5

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

Algunas cosas para mejorar:

En lugar de la nueva RegExp , simplemente intente escribir la regexp esta manera:

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 @ sy puntos.

Answer 6

Esta es la versión correcta del 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);
}

Answer 7

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

Answer 8

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

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

jsFiddle link

De la especificación HTML5 :

Una dirección de correo electrónico válida es una cadena que coincide con la producción de email del siguiente ABNF, cuyo conjunto de caracteres es Unicode.

email = 1*( atext / "." ) "@" label *( "." label )
label = let-dig [ [ ldh-str ] let-dig ] ; limited to a length of 63 characters by RFC 1034 section 3.5
atext = < as defined in RFC 5322 section 3.2.3 >
let-dig = < as defined in RFC 1034 section 3.5 >
ldh-str = < as defined in RFC 1034 section 3.5 >

Este requisito es una violación deliberada de RFC 5322, que define una sintaxis para las 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) , los caracteres de espacios en blanco y las cadenas citadas de maneras que no son familiares para la mayoría de los usuarios, para ser 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])?)*$/

Answer 9

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 una dirección de correo electrónico TODAS las direcciones que DEBEN cumplir.

A menudo, al almacenar las direcciones de correo electrónico en la base de datos, las hago en minúsculas y, en la práctica, las expresiones regulares pueden marcarse como 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 bandera que distingue entre mayúsculas y minúsculas 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(''[email protected]'') );

Nota :
Técnicamente, algunos correos electrónicos pueden incluir citas 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 y cuando esté escrito entre comillas). ¡NADIE LO HACE NUNCA! Es obsoleto Pero, ESTÁ incluido en el verdadero estándar RFC 2822 , y se omite aquí.

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

Answer 10

Hay algo que debes entender en el momento en que decides utilizar una expresión regular para validar los correos electrónicos: probablemente no sea una buena idea . Una vez que haya llegado a un acuerdo con eso, hay muchas implementaciones que pueden llevarlo hasta la mitad, este artículo las resume muy bien.

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

Answer 11

He encontrado que esta es la mejor solución:

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

Permite los siguientes formatos:

1. [email protected] 2. [email protected] 3. [email protected] 4. [email protected] 9. #!$%&''*+-/=?^_`{}|[email protected] 6. "()[]:,;@///"!#$%&''*+-/=?^_`{}| ~.a"@example.org 7. " "@example.org (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 a los personajes internacionales de suma importancia, al tiempo que sigue aplicando el formato básico de cualquier cosa a cualquier cosa. Bloqueará los espacios técnicamente permitidos por RFC, pero son tan raros que estoy feliz de hacer esto.

Answer 12

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

[email protected]

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

Answer 13

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

Answer 14

La validación correcta de la dirección de correo electrónico de acuerdo con las RFC no es algo que pueda lograrse 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 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 se ve como una dirección de correo electrónico válida en el cliente y realizar una comprobació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 : Last @ debe ser anterior al ú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 de la última @ .

• str.indexOf(''@@'') == -1 : No debe haber @@ en la dirección. Incluso si @ aparece como el último carácter en el nombre de usuario del correo electrónico, debe citarse para que esté entre ese @ y el último @ en la dirección.

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

• (str.length - lastDotPos) > 2 : Debe haber suficientes caracteres después del último punto para formar un dominio de dos caracteres. No estoy seguro si los soportes son necesarios.

Answer 15

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 que solo 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 se obtiene la esencia. Y no se deje llevar ... Una solución simple al 90% es mejor que la solución al 100% que no funciona.

El mundo necesita un código más simple ...

Answer 16

Simplemente revisa si la dirección de correo electrónico ingresada es válida o no usa HTML.

<input type="email"/>

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

Answer 17

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

La norma oficial se conoce como RFC 2822 . Describe la sintaxis que deben cumplir las direcciones de correo electrónico válidas. Puedes ( pero no debes , sigue leyendo ) implementarlo con esta expresión regular:

(?:[a-z0-9!#$%&''*+/=?^_`{|}~-]+(?:/.[a-z0-9!#$%&''*+/=?^_`{|}~-]+)*|"(?:[/x01-/x08/x0b/x0c/x0e-/x1f/x21/x23-/x5b/x5d-/x7f]|//[/x01-/x09/x0b/x0c/x0e-/x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|/[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)/.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[/x01-/x08/x0b/x0c/x0e-/x1f/x21-/x5a/x53-/x7f]|//[/x01-/x09/x0b/x0c/x0e-/x7f])+)/])

(...) Obtenemos una implementación más práctica de RFC 2822 si omitimos la sintaxis utilizando comillas dobles y corchetes. Todavía coincidirá con el 99,99% de todas las direcciones de correo electrónico en uso real en la actualidad.

[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 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 las direcciones de correo electrónico ficticias como [email protected] . Deberá actualizarlo a medida que se agreguen nuevos dominios de nivel superior .

[a-z0-9!#$%&''*+/=?^_`{|}~-]+(?:/.[a-z0-9!#$%&''*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/.)+(?:[AZ]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)/b

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

_{Énfasis mio}

Answer 18

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

• Original
  /^(([^<>()/[/]//.,;:/s@"]+(/.[^<>()/[/]//.,;:/s@"]+)*)|(".+"))@((/[[0-9]{1,3}/.[0-9]{1,3}/.[0-9]{1,3}/.[0-9]{1,3}])|(([a-zA-Z/-0-9]+/.)+[a-zA-Z]{2,}))$/

• Modificado
  /^(([^<>()/[/]/.,;:/s@/"]+(/.[^<>()/[/]/.,;:/s@/"]+)*)|(/".+/"))@(([^<>()/.,;/s@/"]+/.{0,1})+[^<>()/.,;:/s@/"]{2,})$/

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

Y puedes ver el resultado here .

Answer 19

Todas las direcciones de correo electrónico contienen un símbolo ''en'' (es decir, @). Probar 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 RFC-sintácticamente válido, eso no le diría si pertenece a la persona que lo suministró. Eso es lo que realmente importa.

Para probar eso, envíe un mensaje de validación.

Answer 20

Usar expresiones regulares es probablemente la mejor manera. Puedes ver un montón de pruebas here (tomadas de chromium )

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 solo en la validación de JavaScript. JavaScript puede ser fácilmente deshabilitado. Esto debería ser validado en el lado del servidor también.

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").bind("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>

Answer 21

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

/S+@/S+

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

Answer 22

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

Answer 23

Actualización de Regex 2018! prueba esto

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

versión 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

Answer 24

La mejor expresión regular que se confirma 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])+

Answer 25

Utilice este código dentro de su función de validador:

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
}

Answer 26

Aquí hay una muy buena discusión sobre el uso de expresiones regulares para validar direcciones de correo electrónico; " http://fightingforalostcause.net/misc/2006/compare-email-regex.php "

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

/^[-a-z0-9~!$%^&*_=+}{/'?]+(/.[-a-z0-9~!$%^&*_=+}{/'?]+)*@([a-z0-9_][-a-z0-9_]*(/.[-a-z0-9_]+)*/.(aero|arpa|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org|pro|travel|mobi|[a-z][a-z])|([0-9]{1,3}/.[0-9]{1,3}/.[0-9]{1,3}/.[0-9]{1,3}))(:[0-9]{1,5})?$/i

Answer 27

En contraste con Squirtle , aquí hay una solución compleja, pero hace un excelente trabajo para validar 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);
}

Utilizar como tal:

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

Answer 28

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

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

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

Answer 29

Mi conocimiento de las expresiones regulares no es tan bueno. Por eso verifico primero la sintaxis general con una simple expresión regular 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 más rápido.

Los errores más comunes que 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(''[email protected]''); // Returns false
check_email('' [email protected]''); // Returns false
check_email(''[email protected]''); // Returns true

Answer 30

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