Как проверить адрес электронной почты в JavaScript
Как проверить адрес электронной почты на JavaScript?
Ответы
Ответ 1
Использование регулярных выражений, вероятно, лучший способ. Вы можете увидеть кучу тестов здесь (взяты из хрома)
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").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>
Ответ 2
Просто для полноты, здесь у вас есть еще одно регулярное выражение RFC 2822
Официальный стандарт известен как RFC 2822. В нем описывается синтаксис, которому должны соответствовать действительные адреса электронной почты. Вы можете (, но вы не должны — читать) реализовать его с помощью этого регулярного выражения:
(?:[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])+)\])
(...) Мы получим более практическую реализацию RFC 2822, если мы опустим синтаксис, используя двойные кавычки и квадратные скобки. Он по-прежнему будет соответствовать 99,99% всех адресов электронной почты, используемых в настоящее время.
[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?
Дальнейшее изменение, которое вы могли бы сделать, - это разрешить домен верхнего уровня с двумя буквами и только определенные общие домены верхнего уровня. Это регулярное выражение фильтрует фиктивные адреса электронной почты, например [email protected]. Вам нужно будет обновить его, когда будут добавлены новые домены верхнего уровня.
[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
Таким образом, даже при соблюдении официальных стандартов, все еще существуют компромиссы. Не слепо копировать регулярные выражения из онлайновых библиотек или дискуссионных форумов. Всегда проверяйте их на своих собственных данных и своими собственными приложениями.
Акцент на мине
Ответ 3
Я немного изменил ответ Jaymon для людей, которые хотят действительно простой проверки в форме:
[email protected]
Регулярное выражение:
/\[email protected]\S+\.\S+/
Пример функции JavaScript:
function validateEmail(email)
{
var re = /\[email protected]\S+\.\S+/;
return re.test(email);
}
Ответ 4
Вау, здесь много сложностей. Если все, что вы хотите сделать, это просто поймать наиболее очевидные синтаксические ошибки, я бы сделал что-то вроде этого:
^\[email protected]\S+$
Обычно он улавливает наиболее очевидные ошибки, которые совершает пользователь, и заверяет, что форма в основном правильная, что и является целью проверки JavaScript.
Ответ 5
Есть что-то, что вам нужно понять во втором, вы решили использовать регулярное выражение для проверки электронной почты: Это, вероятно, не очень хорошая идея. Как только вы смирились с этим, существует множество реализаций, которые могут получить вас на полпути, эта статья суммирует их хорошо.
Короче говоря, единственный способ быть абсолютно уверенным в том, что то, что вводил пользователь, на самом деле является электронной почтой, чтобы фактически отправить электронное письмо и посмотреть, что произойдет. Помимо этого все это просто догадывается.
Ответ 6
Сам HTML5 имеет проверку электронной почты. Если ваш браузер поддерживает HTML5, вы можете использовать следующий код.
<form><input type="email" placeholder="[email protected]" required>
<input type="submit">
</form>
ссылка jsFiddle
Из спецификации 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])?)*$/
Ответ 7
Я нашел это лучшим решением:
/^[^\[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, но они настолько редки, что я счастлив сделать это.
Ответ 8
В современных браузерах вы можете использовать ответ @Sushil, используя чистый JavaScript и 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);
}
Я собрал пример в скрипке http://jsfiddle.net/boldewyn/2b6d5/. В сочетании с обнаружением функций и простой проверкой из Squirtle Answer он освобождает вас от расправы с регулярными выражениями и не работает в старых браузерах.
Ответ 9
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)>)$
Ответ 10
Это правильная версия 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);
}
Ответ 11
Все адреса электронной почты содержат символ "at" (то есть @). Проверьте это необходимое условие:
email.indexOf("@") > 0
Не беспокойтесь о чем-нибудь более сложном. Даже если бы вы могли точно определить, является ли электронное письмо синтаксически действительным в RFC, это не скажет вам, принадлежит ли оно тому, кто его предоставил. Вот что действительно имеет значение.
Чтобы проверить это, отправьте сообщение проверки.
Ответ 12
Корректная проверка адреса электронной почты в соответствии с 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: После последней точки должно быть достаточно символов, чтобы сформировать двухсимвольный домен. Я не уверен, что скобки необходимы.
Ответ 13
Это было украдено из 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;}
Ответ 14
Я действительно с нетерпением жду решения этой проблемы.
Поэтому я изменил регулярное выражение проверки подлинности электронной почты выше
-
Оригинальный
/^(([^<>()\[\]\\.,;:\[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,}))$/
-
Модифицированный
/^(([^<>()\[\]\.,;:\[email protected]\"]+(\.[^<>()\[\]\.,;:\[email protected]\"]+)*)|(\".+\"))@(([^<>()\.,;\[email protected]\"]+\.{0,1})+[^<>()\.,;:\[email protected]\"]{2,})$/
чтобы передать примеры в Адрес электронной почты Википедии.
И вы можете увидеть результат здесь.
![введите описание изображения здесь]()
Ответ 15
Сделай это:
[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])?
Зачем? Это основано на RFC 2822, который является стандартным, ВСЕ адреса электронной почты ДОЛЖНЫ придерживаться. И я не уверен, почему вы возитесь с чем-то "более простым"... вы все равно скопируете и вставите его;)
Часто при хранении адресов электронной почты в базе данных я делаю их строчными, и на практике регулярные выражения обычно помечают без учета регистра. В этих случаях это немного короче:
[a-z0-9!#$%&'*+/=?^_'{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_'{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?
Вот пример его использования в JavaScript (с нечувствительным к регистру флагом i в конце).
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]') );
Примечание:
Технически, некоторые электронные письма могут содержать кавычки в разделе перед символом @ с escape-символами внутри кавычек (так что ваш пользователь электронной почты может быть противным и содержать такие вещи, как @ и "..." если он написан в кавычках). ЭТО НИКОГДА НЕ ДЕЛАЕТ! Это устарело. Но он включен в настоящий стандарт RFC 2822 и здесь опущен.
Дополнительная информация: http://www.regular-expressions.info/email.html
Ответ 16
Вы не должны использовать регулярные выражения для проверки входной строки, чтобы проверить, не является ли она электронной почтой. Это слишком сложно и не будет охватывать все случаи.
Теперь, поскольку вы можете покрывать только 90% случаев, напишите что-нибудь вроде:
function isPossiblyValidEmail(txt) {
return txt.length > 5 && txt.indexOf('@')>0;
}
Вы можете уточнить его. Например, "aaa @" действителен. Но в целом вы получаете суть. И не увлекайтесь... Простое 90% -ное решение лучше, чем 100% -ное решение, которое не работает.
Мир нуждается в более простом коде...
Ответ 17
Просто проверьте, является ли введенный адрес электронной почты действительным или не использует HTML.
<input type="email"/>
Нет необходимости писать функцию для проверки.
Ответ 18
Вот как это делает узел-валидатор:
/^(?:[\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])\]))$/
Ответ 19
Трудно получить валидатор электронной почты на 100% правильно. Единственный реальный способ исправить это - отправить тестовое электронное письмо на аккаунт. Тем не менее, есть несколько основных проверок, которые помогут убедиться, что вы получаете что-то разумное.
Некоторые вещи для улучшения:
Вместо нового RegExp просто попробуйте написать regexp следующим образом:
if (reg.test(/@/))
Во-вторых, убедитесь, что точка стоит после знака @, и убедитесь, что между @ и точками есть символы.
Ответ 20
Используйте этот код внутри вашей функции валидатора:
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
}
Ответ 21
В отличие от 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'); }
Ответ 22
Regex для проверки адреса электронной почты
[a-z0-9!#$%&'*+/=?^_'{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_'{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])+
Ответ 23
Решение, которое не проверяет существование TLD, является неполным.
Почти все ответы на эти вопросы предлагают использовать Regex для проверки адресов электронной почты. Я думаю, что Regex хорош только для элементарной проверки. Кажется, что проверка правильности адресов электронной почты на самом деле две отдельные проблемы:
1- Проверка формата электронной почты: Убедитесь, что электронная почта соответствует формату и шаблону электронных писем в RFC 5322 и действительно ли существует TLD. Список всех действующих TLD можно найти здесь.
Например, хотя адрес [email protected] будет проходить через регулярное выражение, он не является действительным адресом электронной почты, поскольку ccc не является доменом верхнего уровня IANA.
2- Убедиться, что электронная почта действительно существует: для этого единственной возможностью является отправка пользователям электронной почты.
Ответ 24
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');
}
полная версия
//
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
Ответ 25
По-видимому, это:
/^([\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.
Но, конечно, это игнорирование интернационализации.
Ответ 26
Вот очень хорошая дискуссия об использовании регулярных выражений для проверки адресов электронной почты; " Сравнение адреса электронной почты с проверкой регулярных выражений
Вот текущее верхнее выражение, совместимое с JavaScript, для справочных целей:
/^[-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
Ответ 27
Мои знания регулярных выражений не так хороши. Поэтому сначала я проверяю общий синтаксис с помощью простого регулярного выражения, а затем проверяю более конкретные параметры с другими функциями. Возможно, это не лучшее техническое решение, но в этом случае я стал более гибким и быстрым.
Наиболее распространенные ошибки, с которыми я сталкиваюсь, - это пробелы (особенно в начале и в конце) и иногда двойная точка.
function check_email(val){
if(!val.match(/\[email protected]\S+\.\S+/)){ // Jaymon / Squirtle 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
Ответ 28
<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>
Ответ 29
Регулярное выражение, предоставляемое 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})?$/
Который я выкладываю здесь на случай, если он ошибочен - хотя это всегда было идеально для моих нужд.
Ответ 30
Википедия стандартный почтовый синтаксис:
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
