javascript - строку - функция проверки email js




Как проверить адрес электронной почты в JavaScript? (20)

Решение, которое не проверяет существование ДВУ, является неполным.

Почти все ответы на эти вопросы предлагают использовать Regex для проверки адресов электронной почты. Я думаю, что Regex хорош только для элементарной проверки. Кажется, проверка проверки адресов электронной почты на самом деле является двумя отдельными проблемами:

1- Проверка формата электронной почты: убедитесь, что письмо соответствует формату и шаблону писем в RFC 5322 и если существует ДВУ. Список всех действительных TLD можно найти here .

Например, хотя адрес [email protected] будет передавать регулярное выражение, он не является допустимым адресом электронной почты, потому что ccc не является доменом верхнего уровня IANA.

2. Убедитесь, что письмо действительно существует: для этого единственным вариантом является отправка пользователям электронной почты .

Как проверить адрес электронной почты на JavaScript?


JavaScript может соответствовать регулярному выражению:

emailAddress.match( / some_regex /);

Вот регулярное выражение RFC22 для электронных писем:

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

Вау, здесь много сложностей. Если все, что вы хотите сделать, это просто поймать наиболее очевидные синтаксические ошибки, я бы сделал что-то вроде этого:

\[email protected]\S+

Он обычно улавливает наиболее очевидные ошибки, которые делает пользователь, и гарантирует, что форма в основном правильная, и это то, что касается проверки JavaScript.


Видимо, вот и все:

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

Взято с http://fightingforalostcause.net/misc/2006/compare-email-regex.php 1 октября '10.

Но, конечно, это игнорирует интернационализацию.


Все адреса электронной почты содержат символ «at» (т.е. @). Проверьте необходимое условие:

email.indexOf("@") > 0

Не беспокойтесь ни о чем более сложном. Даже если вы могли бы точно определить, является ли письмо RFC синтаксически действительным, это не скажет вам, принадлежит ли оно тому, кто его предоставил. Вот что действительно важно.

Чтобы проверить это, отправьте сообщение проверки.


Вы не должны использовать регулярные выражения для проверки входной строки, чтобы проверить, является ли это электронным письмом. Это слишком сложно и не будет охватывать все случаи.

Теперь, поскольку вы можете покрыть только 90% случаев, напишите что-нибудь вроде:

function isPossiblyValidEmail(txt) {
   return txt.length > 5 && txt.indexOf('@')>0;
}

Вы можете уточнить его. Например, «aaa @» действителен. Но в целом вы получаете суть. И не увлекайтесь ... Простое 90% -ное решение лучше, чем 100% -ное решение, которое не работает.

Мир нуждается в более простом коде ...


Лучше всего использовать регулярные выражения . Здесь вы можете увидеть кучу тестов (взятых из 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());
}

Вот пример регулярного выражения, которое принимает unicode:

var re = /^(([^<>()\[\]\.,;:\[email protected]\"]+(\.[^<>()\[\]\.,;:\[email protected]\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\[email protected]\"]+\.)+[^<>()[\]\.,;:\[email protected]\"]{2,})$/i;

Но имейте в виду, что нельзя полагаться только на проверку JavaScript. JavaScript можно легко отключить. Это также должно быть проверено на стороне сервера.

Вот пример приведенного выше:

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>


Правильная проверка адреса электронной почты в соответствии с RFC не является чем-то, что может быть достигнуто с помощью однострочного регулярного выражения. Статья с лучшим решением, которое я нашел в PHP, - это действительный адрес электронной почты? , Очевидно, что он был перенесен на Java. Я думаю, что эта функция слишком сложна, чтобы ее можно было портировать и использовать в JavaScript. Порт JavaScript / node.js: https://www.npmjs.com/package/email-addresses .

Хорошей практикой является проверка ваших данных на клиенте, но дважды проверьте правильность проверки на сервере. Имея это в виду, вы можете просто проверить, будет ли строка выглядеть как действительный адрес электронной почты на клиенте и выполнить строгую проверку на сервере.

Вот функция JavaScript, которую я использую, чтобы проверить, выглядит ли строка как действительный почтовый адрес:

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

Объяснение:

  • lastAtPos < lastDotPos : Последний @ должен быть до последнего . поскольку @ не может быть частью имени сервера (насколько я знаю).

  • lastAtPos > 0 : Должно быть что-то (имя пользователя электронной почты) до последнего @ .

  • str.indexOf('@@') == -1 : В адресе не должно быть @@ . Даже если @ отображается как последний символ в имени пользователя электронной почты, он должен быть указан таким образом " будет между этим @ и последним @ в адресе.

  • lastDotPos > 2 : перед последней точкой должно быть не менее трех символов, например [email protected] .

  • (str.length - lastDotPos) > 2 : После последней точки должно быть достаточно символов, чтобы сформировать двухсимвольный домен. Я не уверен, нужны ли скобки.


Просто проверьте, является ли введенный адрес электронной почты действительным или не использует HTML.

<input type="email"/>

Нет необходимости писать функцию для проверки.


Сам HTML5 имеет подтверждение по электронной почте. Если ваш браузер поддерживает HTML5, вы можете использовать следующий код.

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

jsFiddle link

Из спецификации HTML5 :

Действительным адресом электронной почты является строка, которая соответствует выпуску email следующего ABNF, набор символов, для которого является 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 >

Это требование является преднамеренным нарушением RFC 5322, который определяет синтаксис для адресов электронной почты, которые одновременно слишком строгие (до символа «@»), слишком расплывчатые (после символа «@») и слишком слабые (допускающие комментарии , пробельные символы и процитированные строки в манерах, незнакомых большинству пользователей) для практического использования здесь.

Следующее стандартное выражение, совместимое с JavaScript и Perl, является реализацией указанного выше определения.

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

Трудно получить правильную проверку электронной почты на 100% правильно. Единственный реальный способ получить правильное решение - отправить тестовое письмо на учетную запись. Тем не менее, есть несколько базовых проверок, которые могут помочь убедиться, что вы получаете что-то разумное.

Некоторые улучшения:

Вместо нового RegExp просто попробуйте написать regexp следующим образом:

if (reg.test(/@/))

Во-вторых, убедитесь, что после знака @ появляется период, и убедитесь, что между символами @ s и периодами есть символы.


Это было украдено с 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;}

Я действительно с нетерпением жду решения этой проблемы. Поэтому я изменил регулярное выражение проверки подлинности электронной почты выше

для передачи примеров в Википедии адрес электронной почты .

И вы можете увидеть результат here .


Я нашел это лучшим решением:

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

Он позволяет использовать следующие форматы:

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)

Он явно универсален и позволяет использовать все важные международные символы, сохраняя при этом базовый формат [email protected] Он будет блокировать пробелы, которые технически разрешены RFC, но они настолько редки, что я счастлив сделать это.


Синтаксис стандартной почты Википедии:

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

Показать этот тест: https://regex101.com/r/LHJ9gU/1


Используйте этот код внутри своей функции валидатора:

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

Кроме того, вы можете использовать jQuery . Внутренние правила определяют:

eMailId: {
    required: true,
    email: true
}

Обновление Regex 2018! попробуй это

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

версия typscript полная

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

подробнее https://git.io/vhEfc


В отличие от squirtle , вот комплексное решение, но он отлично справляется с правильной проверкой писем:

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

Используйте так:

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

Мои знания о регулярных выражениях не так уж хороши. Вот почему я сначала проверяю общий синтаксис простым регулярным выражением и потом проверяю более конкретные параметры с другими функциями. Это может быть не лучшее техническое решение, но таким образом я более гибкий и быстрый.

Наиболее распространенными ошибками, с которыми я столкнулся, являются пробелы (особенно в начале и в конце), а иногда и двойные точки.

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

Регулярное выражение, предоставляемое Microsoft в ASP.NET MVC, является

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

Который я отправляю здесь, если он испорчен, хотя он всегда был идеален для моих нужд.





email-validation