Как проверить адрес электронной почты на JavaScript?
Использование регулярных выражений, вероятно, лучший способ. Вы можете увидеть кучу тестов здесь (взяты из хрома)
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());
}
Вот пример регулярного выражения, принимающего Unicode:
var re = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
Но имейте в виду, что не следует полагаться только на валидацию JavaScript. JavaScript можно легко отключить. Это должно быть проверено и на стороне сервера.
Вот пример вышесказанного в действии:
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>
Я немного изменил ответ Jaymon для людей, которые хотят действительно простой проверки в форме:
Регулярное выражение:
/\S+@\S+\.\S+/
Пример функции JavaScript:
function validateEmail(email)
{
var re = /\S+@\S+\.\S+/;
return re.test(email);
}
/[^\s@]+@[^\s@]+\.[^\s@]+/.test('name@[email protected]') // false
Просто для полноты, здесь у вас есть еще одно регулярное выражение 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
Таким образом, даже при соблюдении официальных стандартов, все еще существуют компромиссы. Не слепо копировать регулярные выражения из онлайновых библиотек или дискуссионных форумов. Всегда проверяйте их на своих собственных данных и своими собственными приложениями.
Акцент на мине
{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_
{|} ~ -] +) * @ (?: [a-z0-9] (?: [a-z0-9 -] * [a-z0-9])? \.) + [a -z0-9] [а-z0-9 -] * [а-z0-9] /
Вау, здесь много сложностей. Если все, что вы хотите сделать, это просто поймать наиболее очевидные синтаксические ошибки, я бы сделал что-то вроде этого:
^\S+@\S+$
Обычно он улавливает наиболее очевидные ошибки, которые совершает пользователь, и заверяет, что форма в основном правильная, что и является целью проверки JavaScript.
Есть что-то, что вам нужно понять во втором, вы решили использовать регулярное выражение для проверки электронной почты: Это, вероятно, не очень хорошая идея. Как только вы смирились с этим, существует множество реализаций, которые могут получить вас на полпути, эта статья суммирует их хорошо.
Короче говоря, единственный способ быть абсолютно уверенным в том, что то, что вводил пользователь, на самом деле является электронной почтой, чтобы фактически отправить электронное письмо и посмотреть, что произойдет. Помимо этого все это просто догадывается.
Сам HTML5 имеет подтверждение по электронной почте. Если ваш браузер поддерживает HTML5, вы можете использовать следующий код.
<form><input type="email" placeholder="[email protected]">
<input type="submit">
</form>
jsFiddle ссылка
A действительный адрес электронной почты - это строка, соответствующая типу
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
, что не каждый может себе позволить. Кроме того, вы не можете оформить сообщение об ошибке.
Я нашел это лучшим решением:
/^[^\s@]+@[^\s@]+\.[^\s@]+$/
Он позволяет использовать следующие форматы:
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, но они настолько редки, что я счастлив сделать это.
@
as .
(или наоборот). Конечно, мы должны быть более строгими на стороне сервера.
[email protected]
не работает с этим шаблоном
В современных браузерах вы можете использовать ответ @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 Answer он освобождает вас от расправы с регулярными выражениями и не работает в старых браузерах.
.@a
проверяется как true
в текущих версиях Chrome, Firefox и Safari.
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)>)
чтобы избежать предоставления длинных |
.
Это правильная версия 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);
}
Корректная проверка адреса электронной почты в соответствии с 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
: перед последней точкой должно быть не менее трех символов, например [email protected]
.
(str.length - lastDotPos) > 2
: После последней точки должно быть достаточно символов, чтобы сформировать двухсимвольный домен. Я не уверен, что скобки необходимы.
Все адреса электронной почты содержат символ "at" (то есть @). Проверьте это необходимое условие:
email.indexOf("@") > 0
Не беспокойтесь о чем-нибудь более сложном. Даже если бы вы могли точно определить, является ли электронное письмо синтаксически действительным в RFC, это не скажет вам, принадлежит ли оно тому, кто его предоставил. Вот что действительно имеет значение.
Чтобы проверить это, отправьте сообщение проверки.
Это было украдено из 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 символа после .
)
Я действительно с нетерпением жду решения этой проблемы. Поэтому я изменил регулярное выражение проверки подлинности электронной почты выше
Оригинальный /^(([^<>()\[\]\\.,;:\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,})$/
чтобы передать примеры в Адрес электронной почты Википедии.
И вы можете увидеть результат здесь.
[email protected]
не работает ...
Сделай это:
[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.
/i
в конце регулярного выражения. Я упоминаю тот факт, что это должно быть сравнение без учета регистра, но я сделаю это более ясным.
Вы не должны использовать регулярные выражения для проверки входной строки, чтобы проверить, не является ли она электронной почтой. Это слишком сложно и не будет охватывать все случаи.
Теперь, поскольку вы можете покрывать только 90% случаев, напишите что-нибудь вроде:
function isPossiblyValidEmail(txt) {
return txt.length > 5 && txt.indexOf('@')>0;
}
Вы можете уточнить его. Например, "aaa @" действителен. Но в целом вы получаете суть. И не увлекайтесь... Простое 90% -ное решение лучше, чем 100% -ное решение, которое не работает.
Мир нуждается в более простом коде...
Просто проверьте, является ли введенный адрес электронной почты действительным или не использует HTML.
<input type="email"/>
Нет необходимости писать функцию для проверки.
Вот как это делает узел-валидатор:
/^(?:[\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])\]))$/
Трудно получить валидатор электронной почты на 100% правильно. Единственный реальный способ исправить это - отправить тестовое электронное письмо на аккаунт. Тем не менее, есть несколько основных проверок, которые помогут убедиться, что вы получаете что-то разумное.
Некоторые вещи для улучшения:
Вместо нового RegExp
просто попробуйте написать regexp
следующим образом:
if (reg.test(/@/))
Во-вторых, убедитесь, что точка стоит после знака @
, и убедитесь, что между @
и точками есть символы.
Regex обновление 2018 года! попробуй это
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');
}
полная версия
//
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 можно найти здесь.
Например, хотя адрес [email protected]
будет проходить через регулярное выражение, он не является действительным адресом электронной почты, поскольку ccc
не является доменом верхнего уровня IANA.
2- Убедиться, что электронная почта действительно существует: для этого единственной возможностью является отправка пользователям электронной почты.
Лучшее регулярное выражение, которое соответствует 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])+
Используйте этот код внутри вашей функции валидатора:
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
- это абсолютно корректное письмо, которое не распознается вашим регулярным выражением.
В отличие от 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'); }
== true
на вашем примере.
По-видимому, это:
/^([\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 октября '10.
Но, конечно, это игнорирование интернационализации.
@
.
Мои знания регулярных выражений не так хороши. Поэтому сначала я проверяю общий синтаксис с помощью простого регулярного выражения, а затем проверяю более конкретные параметры с другими функциями. Возможно, это не лучшее техническое решение, но в этом случае я стал более гибким и быстрым.
Наиболее распространенные ошибки, с которыми я сталкиваюсь, - это пробелы (особенно в начале и в конце) и иногда двойная точка.
function check_email(val){
if(!val.match(/\S+@\S+\.\S+/)){ // Jaymon / Squirtle 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
Вот очень хорошая дискуссия об использовании регулярных выражений для проверки адресов электронной почты; " Сравнение адреса электронной почты с проверкой регулярных выражений
Вот текущее верхнее выражение, совместимое с 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
. Кроме того, существуют живые IDN (большинство из которых, я признаю, были официально одобрены только после вашего поста - например, .中國
в июне 2010 года; но большинство работали годами).
<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>
Википедия стандартный почтовый синтаксис:
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
Показать этот тест: https://regex101.com/r/LHJ9gU/1
Регулярное выражение, предоставляемое 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})?$/
Который я выкладываю здесь на случай, если он ошибочен - хотя это всегда было идеально для моих нужд.
Как написать частное регулярное выражение в Android или Java.
1) USER_NAME = "^[A-Za-z0-9_-]{min number of character,max number of character}$";
2) TELEPHONE = "(^\\+)?[0-9()-]*";
3) TELEPHONE_OPTIONAL = "^($|(^\\+)?[0-9()-]*)$";
4) EMAIL = "[a-zA-Z0-9_\\.\\+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-\\.]+";
5) EMAIL_OPTIONAL = "^($|[a-zA-Z0-9_\\.\\+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-\\.]+)$";
6) WEB_URL = "^($|(http:\\/\\/|https:\\/\\/)?(www.)?([a-zA-Z0-9]+).[a-zA-Z0-9]*.[az]{3}.?([az]+)?)$";
7) WEB_URL_YOUTUBE_BE = "https?\\:\\/\\/(www\\.)?youtu(\\.)?be(\\.com)?\\/.*(\\?v=|\\/v\\/)?[a-zA-Z0-9_\\-]+";
8) POSTAL_ADDRESS = "[a-zA-Z\\d\\s\\-\\,\\#\\.\\+]+";
9) FIELD_NOT_EMPTY = "[^\\s]*";
10) PINCODE = "^([0-9]{6})?$";
11) IFSC_CODE = "^[^\\s]{4}\\d{7}$";
12) SWIFT_CODE = "^([0-9]{10})?$";
13) PINCODE = "^([0-9]{6})?$";
Я смешал @mevius и @Boldewyn Code, чтобы создать этот окончательный код для проверки электронной почты с использованием JavaScript.
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,}))$/;
var input = document.createElement('input');
input.type = 'email';
input.value = email;
return typeof input.checkValidity == 'function' ? input.checkValidity() : re.test(email);
}
Я поделился этим кодом в своем блоге здесь.
Решение Sectrean отлично работает, но это не удалось мне linter. Поэтому я добавил несколько побегов:
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);
}
false
значение
Я искал Regex в JS, который проходит все тестовые случаи адреса электронной почты:
[email protected]
Действительный адрес электронной почты
[email protected]
содержит точку в поле адреса
[email protected]
Электронная почта содержит точку с поддоменом
[email protected]
Знак плюс считается действительным символом
[email protected]
Домен является действительным IP-адресом
email@[192.0.2.123]
Квадратная скобка вокруг IP-адреса считается действительной
"email"@example.com
Цитаты по электронной почте считаются действительными
[email protected]
Цифры в адресе действительны
[email protected]
Даш в доменном имени действителен
[email protected]
Подчеркивание в поле адреса действительно
[email protected]
.name
действительное Имя домена верхнего уровня
[email protected]
Точка в имени домена верхнего уровня также считается действительной (в качестве примера здесь используется co.jp
)
[email protected]
Тире в поле адреса действительна
Вот так:
ИЛИ регулярное выражение:
Regex = /(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@[*[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+]*/
Лучшей практикой является использование встроенного тега электронной почты HTML5.
<input type="email" name="email">
или общий синтаксис электронной почты, как распознавание @и. из строки приведена ниже.
^[a-zA-Z0-9_\-.]+@[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-.]+$
Обратите внимание, что это все равно приведет к недействительной электронной почте, которая по-прежнему будет соответствовать регулярное выражение, его почти невозможно поймать, но это будет немного улучшить ситуацию.
Вот функция, которую я использую для проверки подлинности на лицевой стороне. (Регулярное выражение получено из parsley.js)
<!DOCTYPE html>
<html>
<head>
<title>Our Company</title>
<style>
.form-style {
color: #ccc;
}
</style>
</head>
<body>
<h1>Email Validation Form Example</h1>
<input type="text" name="email" id="emailInput" class="form-style">
<script>
function validateEmail(emailAddress) {
var regularExpression = /^((([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]))){2,6}$/i;
return regularExpression.test(emailAddress);
}
function showEmailValidationState(event) {
if (validateEmail(event.target.value)) {
document.getElementById("emailInput").style.color = 'black';
}
}
document.getElementById("emailInput").addEventListener("keyup", showEmailValidationState);
</script>
</body>
</html>
Вы также можете попробовать
var string = "[email protected]"
var exp = /(\w(=?@)\w+\.{1}[a-zA-Z]{2,})/i
alert(exp.test(string))
Используйте регулярное выражение:
/^[a-z][a-zA-Z0-9_.]*(\.[a-zA-Z][a-zA-Z0-9_.]*)?@[a-z][a-zA-Z-0-9]*\.[a-z]+(\.[a-z]+)?$/
Пример:
function validateEmail(email) {
var re = /^[a-z][a-zA-Z0-9_.]*(\.[a-zA-Z][a-zA-Z0-9_.]*)?@[a-z][a-zA-Z-0-9]*\.[a-z]+(\.[a-z]+)?$/;
return re.test(email);
}
Он должен допускать только @,., _
После проверки Regex:
function validateEmail(email) {
var chrbeforAt = email.substr(0, email.indexOf('@'));
if (!($.trim(email).length > 127)) {
if (chrbeforAt.length >= 2) {
var re = /^(([^<>()[\]{}'^?\\.,!|//#%*-+=&;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
//var re = /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
return re.test(email);
} else {
return false;
}
} else {
return false;
}
}
Это перевод на JavaScript валидации, предложенной официальным руководством Rails, используемым тысячами веб-сайтов:
/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
Относительно просто, но проверяет на наиболее распространенные ошибки.
Протестировано на наборе данных тысяч электронных писем, и в нем не было ни одного ложного негатива/позитива.
Пример использования:
const emailRegex = /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i;
emailRegex.test('[email protected]'); // true
// Multi-word domains
emailRegex.test('[email protected]'); // true
emailRegex.test('[email protected]'); // true
// Valid special characters
emailRegex.test('unusual+but+valid+email1900=/!#$%&\'*+-/=?^_'.{|}[email protected]') // true
// Trailing dots
emailRegex.test('[email protected].'); // false
// No domain
emailRegex.test('email@example'); // false
// Leading space
emailRegex.test(' [email protected]'); // false
// Trailing space
emailRegex.test('[email protected] '); // false
// Incorrect domains
emailRegex.test('email@example,com '); // false
// Other invalid emails
emailRegex.test('invalid.email.com') // false
emailRegex.test('invalid@[email protected]') // false
emailRegex.test('[email protected]') // false
Если вы используете ng-шаблон и материал, это делает работу.
vm.validateEmail = '([a-zA-Z0-9_.]{1,})((@[a-zA-Z]{2,})[\\\.]([a-zA-Z]{2}|[a-zA-Z]{3}))';
лучший: D (RFC-friendly и без ошибок "слишком сложно" ):
function isMail(mail)
{
pattuser = /^([A-Z0-9_%+\-!#$&'*\/=?^`{|}~]+\.?)*[A-Z0-9_%+\-!#$&'*\/=?^`{|}~]+$/i;
pattdomain = /^([A-Z0-9-]+\.?)*[A-Z0-9-]+(\.[A-Z]{2,9})+$/i;
tab = mail.split("@");
if (tab.length != 2)
return false;
return (pattuser.test(tab[0]) && pattdomain.test(tab[1]));
}
<pre>
**The personal_info part contains the following ASCII characters.
1.Uppercase (A-Z) and lowercase (a-z) English letters.
2.Digits (0-9).
3.Characters ! # $ % & ' * + - / = ? ^ _ ` { | } ~
4.Character . ( period, dot or fullstop) provided that it is not the first or last character and it will not come one after the other.**
</pre>
*Example of valid email id*
<pre>
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
</pre>
<pre>
xxxx.ourearth.com [@ is not present]
[email protected] [ tld (Top Level domain) can not start with dot "." ]
@you.me.net [ No character before @ ]
[email protected] [ ".b" is not a valid tld ]
[email protected] [ tld can not start with dot "." ]
[email protected] [ an email should not be start with "." ]
xxxxx()*@gmail.com [ here the regular expression only allows character, digit, underscore and dash ]
[email protected] [double dots are not allowed
</pre>
**javascript mail code**
function ValidateEmail(inputText)
{
var mailformat = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
if(inputText.value.match(mailformat))
{
document.form1.text1.focus();
return true;
}
else
{
alert("You have entered an invalid email address!");
document.form1.text1.focus();
return false;
}
}
Если вы используете Closure, вы можете использовать встроенный тип goog.format.EmailAddress
:
http://docs.closure-library.googlecode.com/git/class_goog_format_EmailAddress.html
Например:
goog.format.EmailAddress.isValidAddrSpec("[email protected]")
Обратите внимание, что, читая исходный код (связанный выше), вы можете видеть, что комментарии указывают, что IDN не поддерживаются и что он предназначен только для большинства адресов:
// This is a fairly naive implementation, but it covers 99% of use cases.
// For more details, see http://en.wikipedia.org/wiki/Email_address#Syntax
// TODO(mariakhomenko): we should also be handling i18n domain names as per
// http://en.wikipedia.org/wiki/Internationalized_domain_name
Вы также можете использовать этот повторно используемый компонент электронной почты, который запускает это регулярное выражение и возвращает логическое значение, не дублируя его в нескольких местах.
Как это работает:
function isEmail(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);
};
На этот вопрос ответить сложнее, чем кажется на первый взгляд.
В мире было множество людей, которые искали "правило, чтобы управлять ими всеми", но правда в том, что есть тоны поставщиков электронной почты.
В чем проблема? Ну, "a_z%@gmail.com не может существовать, но может существовать такой же адрес через другого провайдера" [email protected].
Зачем? Согласно RFC: https://en.wikipedia.org/wiki/Email_address#RFC_specification.
Я возьму выдержку для облегчения лекции:
The local-part of the email address may use any of these ASCII characters:
- uppercase and lowercase Latin letters A to Z and a to z;
- digits 0 to 9;
- special characters !#$%&'*+-/=?^_'{|}~;
- dot ., provided that it is not the first or last character unless quoted, and provided also that it does not appear consecutively unless quoted (e.g. [email protected] is not allowed but "John..Doe"@example.com is allowed);[6]
Note that some mail servers wildcard local parts, typically the characters following a plus and less often the characters following a minus, so fred+bah@domain and fred+foo@domain might end up in the same inbox as fred+@domain or even as fred@domain. This can be useful for tagging emails for sorting, see below, and for spam control. Braces { and } are also used in that fashion, although less often.
- space and "(),:;<>@[\] characters are allowed with restrictions (they are only allowed inside a quoted string, as described in the paragraph below, and in addition, a backslash or double-quote must be preceded by a backslash);
- comments are allowed with parentheses at either end of the local-part; e.g. john.smith(comment)@example.com and (comment)[email protected] are both equivalent to [email protected].
Итак, я могу иметь адрес электронной почты, например:
A__z/J0hn.sm{it!}[email protected]
Если вы попробуете этот адрес, держу пари, что он потерпит неудачу во всех или в большей части регулярного выражения, размещенного по всей сети. Но помните, что этот адрес следует правилам RFC, поэтому он действительно действителен.
Представьте, что я разочарован тем, что не могу нигде зарегистрироваться, проверенный этими регулярными выражениями !!
Единственный, кто действительно может подтвердить адрес электронной почты, является поставщиком адреса электронной почты.
Как бороться, так?
Не имеет значения, добавляет ли пользователь недействительный адрес электронной почты почти во всех случаях. Вы можете положиться на HTML 5 input type = "email", который работает рядом с RFC, мало шансов на провал. HTML5 input type = "email" info: https://www.w3.org/TR/2012/WD-html-markup-20121011/input.email.html
Например, это действительный адрес электронной почты RFC:
"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com
Но проверка html5 скажет вам, что текст перед @не должен содержать, например, символы "или", что на самом деле неверно.
В любом случае, вы должны сделать это, приняв адрес электронной почты и отправив сообщение на этот адрес электронной почты с кодом/ссылкой, которую пользователь должен посетить, чтобы подтвердить действительность.
Хорошей практикой при этом является ввод "введите свой адрес электронной почты снова", чтобы избежать ошибок при вводе пользователем. Если вам этого недостаточно, добавьте модальное окно предварительной отправки с заголовком "Это ваш текущий адрес электронной почты?", А затем сообщение, введенное пользователем внутри тега h2, вы знаете, чтобы четко показать, какой адрес -почта они ввели, затем кнопку "да, отправить".
Вот простое регулярное выражение, которое просто проверяет основной формат электронной почты, например, X@YC
:
\S+@\S+\.\S+
<input type="email" class="form-control" required="required" placeholder="Email Address" name="Email" id="Email" autocomplete="Email">
<button class="btn-1 shadow-0 full-width" type="button" id="register">Register account</button>
$("#register").click(function(){
var rea = /^[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])?)*$/;
var Email = $("#Email").val();
var x = rea.test(Email);
if (!x) {
alert('Type Your valid Email');
return false;
}
</script>
Now ReactNative Version 0.46 Используйте ниже код для проверки электронной почты.
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,}))$/;
if (re.test(email)) {
} else {
alert('email: ' + "Please enter valid emailID.")
}
}
Как насчет создания функции, которая будет тестировать любую строку против шаблона электронной почты с использованием регулярного выражения в JavaScript, поскольку мы знаем, что адреса электронной почты могут быть совершенно разными в разных регионах, например, в Великобритании и Австралии, обычно это заканчивается .co.uk
или .com.au
, поэтому я попытался их охватить, а также проверить, передана ли строка функции, примерно так:
var isEmail = function(str) {
return typeof str==='string' && /^[\w+\d+._]+\@[\w+\d+_+]+\.[\w+\d+._]{2,8}$/.test(str);
}
и проверьте, отправляется ли он по электронной почте, как показано ниже:
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]#sswzazaaaa'); //false
isEmail('[email protected]'); //false
[email protected]
или phil.h\@\@[email protected]
?
Здесь написано несколько сложных RegEx, которые также работают.
Я тестировал этот, и он тоже работает:
[a-zA-Z0-9._]+[@]+[a-zA-Z0-9]+[.]+[a-zA-Z]{2,6}
Пожалуйста, проверьте это здесь: http://www.regextester.com/?fam=97334
Надеюсь, что это поможет.
me@localhost
не удается.
В nodeJS вы также можете использовать модуль валидатора node и просто использовать это
Установите библиотеку с помощью проверки подлинности npm
var validator = require('validator');
validator.isEmail('[email protected]'); //=> true
Тот, кто использует решение @pvl и хочет, чтобы он передал ESLint Prefer-template, затем здесь версия, в которой я использовал шаблонные литералы вместо строки конкатенация.
validateEmail(email) {
let sQtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]';
let sDtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]';
let sAtom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+';
let sQuotedPair = '\\x5c[\\x00-\\x7f]';
let sDomainLiteral = `\\x5b(${sDtext}|${sQuotedPair})*\\x5d`;
let sQuotedString = `\\x22(${sQtext}|${sQuotedPair})*\\x22`;
let sDomainRef = sAtom;
let sSubDomain = `(${sDomainRef}|${sDomainLiteral})`;
let sWord = `(${sAtom}|${sQuotedString})`;
let sDomain = `${sSubDomain}(\\x2e${sSubDomain})*`;
let sLocalPart = `${sWord}(\\x2e${sWord})*`;
let sAddrSpec = `${sLocalPart}\\x40${sDomain}`; // complete RFC822 email address spec
let sValidEmail = `^${sAddrSpec}$`; // as whole string
let reValidEmail = new RegExp(sValidEmail);
return reValidEmail.test(email);
}
Что вы думаете о моем решении здесь: Как использовать Angular ввод полей проверки подлинности электронной почты внутри контроллера?
В принципе, вы можете создать скрытое поле ввода электронной почты типа и с помощью javascript установить значение для этого ввода и проверить, действительно ли оно.
Это регулярное выражение предотвращает дублирование доменных имен, таких как [email protected], это позволит использовать только домен два раза, например [email protected]. Он также не позволяет statring от числа, такого как [email protected]
regexp: /^([a-zA-Z])+([a-zA-Z0-9_.+-])+\@(([a-zA-Z])+\.+?(com|co|in|org|net|edu|info|gov|vekomy))\.?(com|co|in|org|net|edu|info|gov)?$/,
Все лучшее!!!!!
Если вы хотите использовать JQuery и хотите иметь современный подход, используйте маска ввода JQuery с проверкой.
http://bseth99.github.io/projects/jquery-ui/5-jquery-masks.html
Демонстрация того, как простая маска ввода jquery находится здесь: http://codepen.io/anon/pen/gpRyBp
Пример простой маски ввода для даты forexample НЕ полная проверка
<input id="date" type="text" placeholder="YYYY-MM-DD"/>
и script:
$("#date").mask("9999-99-99",{placeholder:"YYYY-MM-DD"});
После проверки Regex:
Длина электронной почты должна быть меньше 128 символов
function validateEmail(email) {
var chrbeforAt = email.substr(0, email.indexOf('@'));
if (!($.trim(email).length > 127)) {
if (chrbeforAt.length >= 2) {
var re = /^(([^<>()[\]{}'^?\\.,!|//#%*-+=&;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
return re.test(email);
} else {
return false;
}
} else {
return false;
}
}
Я знаю его не регулярное выражение, а каким-то образом...
Это пример с node и пакетом npm email-existence, это полная проверка, существует ли электронная почта и если она в правильной форме: )
Это приведет к отправке сообщения электронной почты, если он ответит, если он не получит ответа, он вернет false или true.
function doesEmailExist(email) {
var emailExistence = require('email-existence');
return emailExistence.check(email,function (err,status) {
if (status) {
return status;
}
else {
throw new Error('Email does not exist');
}
});
}
Если вы используете AngularJS, просто добавьте type="email"
к элементу ввода:
Если нет элемента ввода, его можно создать динамически:
var isEmail = $compile('<input ng-model="m" type="email">')($rootScope.$new()).
controller('ngModel').$validators["email"];
if (isEmail('[email protected]')) {
console.log('valid');
}
Вы используете https://github.com/chriso/validator.js и просто делаете:
var validator = require('validator');
validator.isEmail('[email protected]'); //=> true
Обратите внимание, что это может работать на клиенте.
Вот рекомендуемый шаблон Regex для HTML5 на MDN:
Браузеры, поддерживающие тип ввода электронной почты, автоматически проверяют, чтобы в поле ввода был введен только текст, соответствующий стандартному формату адресов электронной почты в Интернете. Браузеры, которые реализуют спецификацию, должны использовать алгоритм, эквивалентный следующему регулярному выражению:
/^[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])?)*$/
https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email#Validation
Вы также можете использовать класс New Regex и сделать так:
const validaEmail = function validateEmail(str) { let regex = new RegExp(/([\w\.\-_]+)?\w+@[\w-_]+(\.\w+){1,}/,'igm') return regex.test(str); }
ссылка: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
Часть personal_info содержит следующие символы ASCII.
Доменное имя [например, com, org, net, in, us, info] содержит буквы, цифры, дефисы и точки.
function ValidateEmail(mail)
{
if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
{
return (true)
}
alert("You have entered an invalid email address!")
return (false)
}
Это работает для меня:
function Email(mail)
{
if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
{
return (true)
}
alert("Invalid email address!")
return (false)
}
function ValidateEmail(mail)
{
if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
{
return (true)
}
alert("You have entered an invalid email address!")
return (false)
}
Ссылочный URL: https://www.w3resource.com/javascript/form/email-validation.php
Я написал валидатор электронной почты JavaScript, который полностью совместим с реализацией PHP filter_var($value, FILTER_VALIDATE_EMAIL)
.
https://github.com/mpyw/FILTER_VALIDATE_EMAIL.js
import validateEmail from 'filter-validate-email'
const value = '...'
const result = validateEmail(value)
эквивалентно:
<?php
$value = '...';
$result = (bool)filter_var($value, FILTER_VALIDATE_EMAIL, FILTER_FLAG_EMAIL_UNICODE);
Вот решение, которое работает и включает функциональность проверки/уведомления в форме:
Вы можете запустить его по этой ссылке
JAVASCRIPT
(function() {
'use strict';
window.addEventListener('load', function() {
var form = document.getElementById('needs-validation');
form.addEventListener('submit', function(event) {
if (form.checkValidity() === false) {
event.preventDefault();
}
form.classList.add('was-validated');
event.preventDefault();
}, false);
}, false);
})();
HTML
<p class='title'>
<b>Email validation</b>
<hr size="30px;">
</p>
<br>
<form id="needs-validation" novalidate>
<p class='form_text'>Try it out!</p>
<div class="form-row">
<div class="col-12">
<input type="email" class="form-control" placeholder="Email Address" required>
<div class="invalid-feedback">
Please enter a valid email address.
</div>
</div>
<div class="row">
<div class="col-12">
<button type="submit"
class="btn btn-default btn-block">Sign up now
</button>
</div>
</div>
</form>
Пример ES6
const validateEmail=(email)=> /^(([^<>()\[\]\\.,;:\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,}))$/.test(email);
Я хотел бы добавить короткую заметку о символах, отличных от ASCII. Решение Rnevius (и co.) Является блестящим, но оно позволяет добавлять кириллицу, японский, смайликов и другие символы Unicode, которые могут быть ограничены некоторыми серверами.
В приведенном ниже коде будет напечатан true
, хотя он содержит символ UTF-8 Ё
.
console.log (/^(([^<>()\[\]\\.,;:\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,}))$/.test ('Ё@example.org'))
В моем случае все символы, отличные от ASCII, запрещены, поэтому я изменил исходное выражение, чтобы исключить все символы выше U + 007F:
/^(([^\u0080-\uffff<>()\[\]\\.,;:\s@"]+(\.[^\u0080-\uffff<>()\[\]\\.,;:\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,}))$/
Возможно, это поможет кому-то предотвратить нежелательное поведение.
Если вы определяете свое регулярное выражение как строку, все обратные косые черты должны быть экранированы, поэтому вместо '\ w' вы должны иметь "\ w".
В качестве альтернативы, определите его как регулярное выражение:
var pattern = /^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$/;
\b[a-z][\w\d_\.]+@\w+\.[a-z]{2}[a-z]?\.?[a-z]{,2}\s
Это позволяет:
[email protected]
[email protected]
[email protected]
[email protected]
{min,max}
. Пустой min
- ошибка, но может иметь пустой max
. Я имею в виду [az]{,2}
не так, напишите как {0,2}
. Более того: ваше регулярное выражение показывает kamal@_gmail.com
как действительный, который не является!
Один из моих коллег поделился этим регулярным выражением со мной. Мне это очень нравится.
function isValidEmailAddress (email) {
var validEmail = false;
if (email) {
email = email.trim().toLowerCase();
var pattern = /^[\w-']+(\.[\w-']+)*@([a-zA-Z0-9]+[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*?\.[a-zA-Z]{2,6}|(\d{1,3}\.){3}\d{1,3})(:\d{4})?$/;
validEmail = pattern.exec(email);
}
return validEmail;
}
if (typeof String.prototype.trim !== 'function') {
String.prototype.trim = function() {
return this.replace(/^\s+|\s+$/g, '');
};
}
Простое регулярное выражение для email-Id
String EMAIL_PATTERN ="^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$";
function validatecontactEmail(email) {
if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(email))
{
return (true)
}
return (false)
}
return /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(email)
?
Очень просто в JavaScript
. следуйте этому коду.
function validate(){
var email = document.getElementById('Email');
var filter = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
if (!filter.test(email.value))
{
alert('Please Enter the valid email address');
email.focus;
return false;
}
else
{
return true;
}
HTML
код для этого:
form name="form"
enctype="multipart/form-data"
name="form"
action="register.php"
method="POST" onsubmit="return validate();" >
<input type="text" placeholder="Enter ur Email Id" id="Email" name="Email" />
<input type="submit" id="submit" value="save" name="Like" class="button" />
</form>
Регулярное выражение для электронной почты:
var rex_email = /^(([^<>()[\]\\.,;:\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,}))$/;
if(email=="") {
window.plugins.toast.showShortBottom( "Please enter the details. ", function(a) {
console.log('toast success: ' + a);
}, function(b) { });
} else if(!rex_email.test(email)) {
window.plugins.toast.showShortBottom( "Please enter the valid email id. ", function(a) {
console.log('toast success: ' + a);
}, function(b) { });
}
Следующее регулярное выражение:
/^([\w]+)(.[\w]+)*@([\w]+)(.[\w]{2,3}){1,2}$/;
function validateEmail(elementValue){
var emailPattern = /^[a-zA-Z0-9._]+[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z]{2,4}$/;
return emailPattern.test(elementValue);
}
Возвращает true, если адрес электронной почты действителен. В противном случае он вернет false.
W3Schools дает хороший простой и эффективный script для проверки электронной почты:
function validateEmail(email) {
var atpos=email.indexOf("@");
var dotpos=email.lastIndexOf(".");
if (atpos < 1 || dotpos < atpos+2 || dotpos+2 >= email.length) {
alert("Not a valid e-mail address");
return false;
}
return true;
}
Обратите внимание, что вам нужно будет удалить пробелы, если они есть, что-то вроде этого:
.replace(/ /g,'')
Источник: Проверка формы JavaScript
abc@xyz
- это абсолютно корректное письмо, которое не распознается вашим регулярным выражением.