regular - validar telefono javascript




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

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 .

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



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() : /\[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 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.


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.


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

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

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.


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


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

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.


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.


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


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.


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

function validateEmail(email) {
    var 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:

var 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 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 = /^(([^<>()[\]\\.,;:\[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() {
  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>


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


Actualización de Regex 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 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 información https://git.io/vhEfc


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
}

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

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.


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(/\[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






email-validation