Существует ли регулярное выражение для проверки адреса электронной почты в JavaScript?
@
, ;com
и т.д.) , и пусть пользователь исправить их , если они хотят (и принимать то , что они посылают меня)
Существует ли регулярное выражение для проверки адреса электронной почты в JavaScript?
@
, ;com
и т.д.) , и пусть пользователь исправить их , если они хотят (и принимать то , что они посылают меня)
Ответы:
Использование регулярных выражений , вероятно, лучший способ. Вы можете увидеть кучу тестов здесь (взяты из хрома )
function validateEmail(email) {
const 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());
}
Вот пример регулярного выражения, принимающего Unicode:
const re = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
Но имейте в виду, что не следует полагаться только на валидацию JavaScript. JavaScript можно легко отключить. Это должно быть проверено и на стороне сервера.
Вот пример вышесказанного в действии:
function validateEmail(email) {
const 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() {
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;
}
$("#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@gmail.com, "%2"@gmail.com, "a..b"@gmail.com, "a_b"@gmail.com, _@gmail.com, 1@gmail.com , 1_example@something.gmail.com
действительны, но Gmail никогда не разрешит использование этих адресов электронной почты. Вы должны сделать это, приняв адрес электронной почты и отправив сообщение на этот адрес электронной почты с кодом / ссылкой, которую пользователь должен посетить, чтобы подтвердить действительность.
Я немного изменил ответ Джеймона для людей, которым нужна действительно простая проверка в виде:
anystring@anystring.anystring
Регулярное выражение:
/\S+@\S+\.\S+/
Пример функции JavaScript:
function validateEmail(email)
{
var re = /\S+@\S+\.\S+/;
return re.test(email);
}
console.log(validateEmail('anystring@anystring.anystring'));
name@again@example.com
. Попробуйте вставить свою строку в консоль JavaScript. Я полагаю, что ваше намерение состояло в том, чтобы соответствовать только всему тексту, что потребовало бы начала текстовых операторов '^' и конца текста '$'. Тот, который я использую/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test('name@again@example.com')
@@@.@
? : D
Просто для полноты, здесь у вас есть еще одно регулярное выражение в соответствии с 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])?
Еще одно изменение, которое вы можете сделать, - разрешить использование любого двухбуквенного домена верхнего уровня с кодом страны и только определенных общих доменов верхнего уровня. Это регулярное выражение фильтрует фиктивные адреса электронной почты, такие как
asdf@adsf.adsf
. Вам нужно будет обновить его по мере добавления новых доменов верхнего уровня .
[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
Таким образом, даже при соблюдении официальных стандартов все же приходится идти на компромиссы. Не копируйте вслепую регулярные выражения из онлайн-библиотек или дискуссионных форумов. Всегда проверяйте их на ваших собственных данных и с вашими собственными приложениями.
Акцент мой
{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_
{|} ~ -] +) * @ (?: [a-z0-9] (?: [a-z0-9 -] * [a-z0-9])? \.) + [a-z0-9] [a-z0-9 -] * [a-z0-9] /
\w
или, что еще лучше, просто строчный адрес электронной почты, прежде чем что-либо делать с ним, потому что это соглашение в любом случае.
Вау, здесь много сложностей. Если все, что вы хотите сделать, это просто поймать наиболее очевидные синтаксические ошибки, я бы сделал что-то вроде этого:
^\S+@\S+$
Обычно он улавливает наиболее очевидные ошибки, которые совершает пользователь, и гарантирует, что форма в основном правильная, а это и есть смысл проверки JavaScript.
.+@.+
/\S+@\S+/.test("áéíóúý@ÁÉÍÓÚÝð")
true
Есть кое-что, что вы должны понять, как только вы решите использовать регулярное выражение для проверки писем: это, вероятно, не очень хорошая идея . Как только вы с этим смирились, есть много реализаций, которые могут помочь вам на полпути, эта статья подытоживает их.
Короче говоря, однако, единственный способ быть абсолютно уверенным в том, что введенное пользователем на самом деле является электронным письмом, - это фактически отправить электронное письмо и посмотреть, что произойдет. Кроме этого это всего лишь догадки.
name_part@domain_part
и практически все, включая адрес @
, действителен в name_part; Адрес foo@bar@machine.subdomain.example.museum
является законным, хотя он должен быть экранирован как foo\@bar@machine....
. Как только электронная почта достигает домена, например, «example.com», этот домен может направлять почту «локально», так что могут существовать «странные» имена пользователей и хостов.
.us
домен или потому, что я использовал +
слева от во @
многих местах исправлены эти вопиющие ошибки, но локальной частью (слева от @) может быть все, что хочет владелец домена. -> "foo@bar.com"@example.com <- это действующий адрес электронной почты.
Сам HTML5 имеет проверку электронной почты. Если ваш браузер поддерживает HTML5, вы можете использовать следующий код.
<form><input type="email" placeholder="me@example.com" required>
<input type="submit">
</form>
jsFiddleссылка
Из спецификации HTML5 :
Действительный адрес электронной почты является строкой , которая соответствует
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.!#$%&'*+/=?^_`{|}~-]+@[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])?)*$/
form
тега и представлен submit
входом, что не каждый может себе позволить. Кроме того, вы не можете оформить сообщение об ошибке.
user@email
тогда как, например, в PHP - filter_var
нет. Это может вызвать проблемы.
Я считаю, что это лучшее решение:
/^[^\s@]+@[^\s@]+\.[^\s@]+$/
Это позволяет следующие форматы:
1. prettyandsimple@example.com 2. very.common@example.com 3. одноразовый. Style.email.with+symbol@example.com 4. other.email-with-dash@example.com 9. #!$%&'*+-/=?^_`abilities угадывающимся ~~@example.org 6. "() []:,; @ \\\"! # $% & '* + - / =? ^ _ `{} | ~ .A "@ example.org 7. "" @ example.org (пробел между кавычками) 8. üñîçøðé@example.com (символы Юникода в локальной части) 9. üñîçøðé@üñîçøðé.com (символы Юникода в доменной части) 10. Pelé@example.com (латиница) 11. δοκιμή@παράδειγμα.δοκιμή (греческий) 12. 買 買 @ 屋企. 香港 (китайский) 13. 斐 斐 @ 黒 川. 日本 (японский) 14. чебурашка@ящик-с-апельсинами.рф (кириллица)
Он, безусловно, универсален и допускает все важные международные символы, но при этом поддерживает базовый формат any@anything.anything. Это заблокирует пространства, которые технически разрешены RFC, но они настолько редки, что я с удовольствием это сделаю.
@
как .
(или наоборот). Конечно, мы должны быть более строгими на стороне сервера.
username@domain.com
не работает с этим шаблоном
a@b@c@d.x.y.@.z
тогда, может быть, они заслуживают плохого времени? : D
В современных браузерах вы можете опираться на ответ @ 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() : /\S+@\S+\.\S+/.test(value);
}
Я собрал пример в скрипке http://jsfiddle.net/boldewyn/2b6d5/ . В сочетании с обнаружением функций и простой проверкой Squirtle 's Answer он освобождает вас от расправы с регулярными выражениями и не работает в старых браузерах.
.@a
проверяется как true
в текущих версиях Chrome, Firefox и Safari.
Это правильная версия 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);
}
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)>)$
(?>
чтобы прекратить возвращаться назад и (?<angle><)…(?(angle)>)
избегать длинных |
.
Все адреса электронной почты содержат символ «at» (то есть @). Проверьте это необходимое условие:
email.indexOf("@") > 0
Не беспокойтесь о чем-нибудь более сложном. Даже если бы вы могли точно определить, является ли электронная почта RFC-синтаксически действительной, это не скажет вам, принадлежит ли оно тому, кто его предоставил. Вот что действительно имеет значение.
Чтобы проверить это, отправьте сообщение проверки.
Корректная проверка адреса электронной почты в соответствии с 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
: Last @
должен быть перед последним, .
поскольку @
не может быть частью имени сервера (насколько я знаю).
lastAtPos > 0
: Должно быть что-то (имя пользователя электронной почты) перед последним @
.
str.indexOf('@@') == -1
: Не должно быть @@
в адресе. Даже если @
в имени пользователя электронной почты он указан как последний символ, он должен быть заключен в кавычки, поэтому он "
должен находиться между @
последним и последним @
в адресе.
lastDotPos > 2
Например, перед последней точкой должно быть не менее трех символов a@b.com
.
(str.length - lastDotPos) > 2
: После последней точки должно быть достаточно символов для формирования двухсимвольного домена. Я не уверен, что скобки необходимы.
@
в имени пользователя электронной почты он указан как последний символ, он должен быть заключен в кавычки, поэтому он "
должен быть между этим @
и последним @
в адресе». Как насчет "@@"@example.com
?
Это было украдено с 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;}
.museum
и .travel
домены (из-за лимита в 4 символа после .
)
{2,4}
- просто полезный индикатор этого (например, «когда вы видите эту ошибку, другие, вероятно, будут рядом»). Самые основные из них является отсутствие +
в локальной части; это поле для комментариев слишком мало, чтобы указывать на все ошибки, допущенные выше.
return filter.test(email.value);
?
xn--clchc0ea0b2g2a9gcd
). Все еще не проблема?
Сделай это:
[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('some.body@domain.co.uk') );
Примечание .
Технически некоторые электронные письма могут содержать кавычки в разделе перед @
символом с escape-символами внутри кавычек (поэтому ваш почтовый пользователь может быть неприятным и содержать такие вещи, как @
и "..."
до тех пор, пока он написан в кавычках). ЭТО НИКОГДА НЕ ДЕЛАЕТ! Это устарело. Но он включен в настоящий стандарт RFC 2822 и здесь опущен.
Дополнительная информация: http://www.regular-expressions.info/email.html
/i
флага в конце регулярного выражения. Я упоминаю тот факт, что это должно быть сравнение без учета регистра, но я сделаю это более ясным.
Я действительно с нетерпением жду, чтобы решить эту проблему. Поэтому я изменил регулярное выражение проверки электронной почты выше
оригинал
/^(([^<>()\[\]\\.,;:\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,}))$/
модифицированный
/^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+[^<>()\.,;:\s@\"]{2,})$/
передать примеры в адрес электронной почты Википедии .
И вы можете увидеть результат здесь .
john..doe@example.com
должно быть не правильно? Это действительный угловой случай.
Вы не должны использовать регулярные выражения для проверки входной строки, чтобы проверить, является ли это электронное письмо. Это слишком сложно и не охватит все случаи.
Теперь, поскольку вы можете охватить только 90% случаев, напишите что-то вроде:
function isPossiblyValidEmail(txt) {
return txt.length > 5 && txt.indexOf('@')>0;
}
Вы можете уточнить это. Например, 'aaa @' допустимо. Но в целом вы понимаете суть. И не увлекайтесь ... Простое решение на 90% лучше, чем решение на 100%, которое не работает.
Мир нуждается в более простом коде ...
(.+)@(.*)
делает то же самое и короче.
Просто проверьте, является ли введенный адрес электронной почты действительным или не использует HTML.
<input type="email"/>
Нет необходимости писать функцию для проверки.
Трудно получить валидатор электронной почты на 100% правильно. Единственный реальный способ исправить это - отправить тестовое электронное письмо на аккаунт. Тем не менее, есть несколько основных проверок, которые помогут убедиться, что вы получаете что-то разумное.
Некоторые вещи для улучшения:
Вместо нового RegExp
просто попробуйте написать regexp
так:
if (reg.test(/@/))
Во-вторых, убедитесь, что точка стоит после @
знака, и убедитесь, что между символами @
s и точками есть символы .
Вот как это делает узел-валидатор :
/^(?:[\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])\]))$/
Используйте этот код внутри вашей функции валидатора:
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
}
abc@xyz
является совершенно действительным адресом электронной почты, который не распознается вашим регулярным выражением.
abc@tld
же действительный адрес электронной почты.
Regex обновление 2018 года! попробуй это
let val = 'email@domain.com';
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');
}
полная версия
//
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);
больше информации https://git.io/vhEfc
Почти все ответы на эти вопросы предлагают использовать Regex для проверки адресов электронной почты. Я думаю, что Regex хорош только для элементарной проверки. Кажется, что проверка правильности адресов электронной почты на самом деле две отдельные проблемы:
1- Проверка формата электронной почты. Убедитесь, что электронная почта соответствует формату и шаблону электронных писем в RFC 5322 и действительно ли существует TLD. Список всех действительных TLD можно найти здесь .
Например, хотя адрес example@example.ccc
будет проходить регулярное выражение, он не является действительным электронным письмом, поскольку ccc
IANA не является доменом верхнего уровня.
2. Убедитесь, что электронная почта действительно существует. Для этого единственной возможностью является отправка пользователям электронной почты .
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])+
Вот очень хорошая дискуссия об использовании регулярных выражений для проверки адресов электронной почты; " Сравнение адреса электронной почты, проверяющего регулярные выражения »
Вот текущее верхнее выражение, совместимое с 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
.jobs
. Кроме того, существуют живые ИДИ (большинство из которых, я признаю, были официально одобрены только после вашего поста - например, .中國
в июне 2010 года; но большинство работали годами).
Видимо, вот и все:
/^([\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
Взято с http://fightingforalostcause.net/misc/2006/compare-email-regex.php 1 октября 2010 года.
Но, конечно, это игнорирование интернационализации.
В отличие от 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('youremail@yourdomain.com')){ console.log('This is email is valid'); }
== true
на вашем примере.
Мои знания регулярных выражений не так хороши. Вот почему я сначала проверяю общий синтаксис с помощью простого регулярного выражения, а затем проверяю более конкретные параметры с другими функциями. Возможно, это не лучшее техническое решение, но в этом случае я стал более гибким и быстрым.
Наиболее распространенные ошибки, с которыми я сталкиваюсь, - это пробелы (особенно в начале и в конце) и иногда двойная точка.
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('check@this..com'); // Returns false
check_email(' check@this.com'); // Returns false
check_email('check@this.com'); // Returns 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>
<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>
Я искал Regex в JS, который проходит все тестовые случаи адреса электронной почты:
email@example.com
Действительный адрес электронной почты
firstname.lastname@example.com
Письмо содержит точку в поле адреса
email@subdomain.example.com
Письмо содержит точку с поддоменом
firstname+lastname@example.com
Знак плюс считается действительным символом
email@192.0.2.123
Домен является действительным IP-адресом
email@[192.0.2.123]
Квадратная скобка вокруг IP-адреса считается действительной
“email”@example.com
Цитаты по электронной почте считаются действительными
1234567890@example.com
Цифры в адресе действительны
email@domain-one.example
Тире в доменном имени действительна
_______@example.com
Подчеркивание в поле адреса является действительным
email@example.name
.name
действительное имя домена верхнего уровня
email@example.co.jp
Точка в доменном имени верхнего уровня также считается действительной (в co.jp
качестве примера здесь)
firstname-lastname@example.com
Тире в поле адреса действительна
Вот так :
ИЛИ регулярное выражение:
Regex = /(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@[*[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+]*/
Регулярное выражение, предоставляемое 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})?$/
Который я выкладываю здесь на случай, если он ошибочен - хотя он всегда идеально подходил для моих нужд.