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

Существует ли регулярное выражение для проверки адреса электронной почты в JavaScript?

5.09.2008 16:10:11
пожалуйста, поймите это правильно, слишком многим веб-сайтам не нравится мой адрес электронной почты "firstName@secondName.name", не все домены верхнего уровня заканчиваются на 2 или 3 буквы.
Ian Ringrose 19.08.2011 14:51:03
Любая поддержка использования проверок регулярных выражений для электронных писем я против 100%. Я устал от того, что мне сказали, что мой адрес электронной почты "foo+bar@gmail.com" недействителен. Лучший вариант - попросить пользователя ввести свою электронную почту дважды, и если вы ДОЛЖНЫ использовать проверку на регулярные выражения, то скажите пользователю, что его адрес электронной почты не является действительным, и спросите, уверены ли они, что он его напечатал. верно. Даже зайдите так далеко, чтобы указать, ЧТО не проверялось в проверке регулярных выражений, но НЕ мешайте им отправлять форму.
Soundfx4 15.03.2016 16:21:38
@ Soundfx4: это должен быть ответ, принятый как таковой. Проверка правильности адреса - это глупая вещь - лучший способ разочаровать клиентов. Я прошу адрес наберется дважды и намек , что есть некоторые возможные проблемы (отсутствует @, ;comи т.д.) , и пусть пользователь исправить их , если они хотят (и принимать то , что они посылают меня)
WoJ 4.04.2017 17:24:54
Я полностью согласен с ответом WoJ. Формат действующего адреса электронной почты слишком сложен, чтобы его можно было проверить с помощью простого регулярного выражения. Единственный способ убедиться, что адрес действителен, это попробовать.
Nicole 1.08.2018 09:51:13
30 ОТВЕТОВ
РЕШЕНИЕ

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

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").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>

4866
21.03.2019 11:46:20
Это регулярное выражение исключает действительные, используемые электронные письма. Не используйте. Google для "RFC822" или "RFC2822", чтобы получить правильное регулярное выражение.
Randal Schwartz 8.09.2010 02:34:23
@Randall: Можете ли вы привести пример адреса электронной почты, который не будет пропущен?
rossipedia 14.09.2010 18:08:40
@GoodPerson Я просто попытался написать по электронной почте n @ ai, чтобы сказать ему / ей, что у них есть классный адрес электронной почты. Но, увы, Gmail не позволил бы мне. Я подозреваю, что у кого бы то ни было, есть большие проблемы в общении с другими по электронной почте, чем просто проверка JavaScript моего сайта! Но спасибо, что приняли вызов.
Ben Roberts 13.01.2013 07:38:43
Для всех людей, комментирующих, что это «достаточно хорошо»: смотрите, вы просто думаете об этой проблеме неправильно. Ничего страшного. Это выбор, который вы можете сделать для своих пользователей. Я не злюсь на это. Но, вы знаете, технически говоря, вы демонстративно, доказуемо неправы.
Wayne Burkett 22.11.2013 16:32:59
Вы не можете проверить адреса электронной почты, точка. Единственный, кто может подтвердить адрес электронной почты, является поставщиком адреса электронной почты. Например, в этом ответе говорится, что все эти адреса электронной почты %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 никогда не разрешит использование этих адресов электронной почты. Вы должны сделать это, приняв адрес электронной почты и отправив сообщение на этот адрес электронной почты с кодом / ссылкой, которую пользователь должен посетить, чтобы подтвердить действительность.
Kevin Fegan 1.02.2014 08:49:15

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)>)$
68
24.08.2013 20:45:54
Узел не может скомпилировать это регулярное выражение
Kato 6.10.2012 00:08:01
@Kato: он использует некоторые несовместимые расширения, в том числе, (?>чтобы прекратить возвращаться назад и (?<angle><)…(?(angle)>)избегать длинных |.
Ry-♦ 9.03.2014 20:05:57

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

^\S+@\S+$

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

369
28.11.2018 10:31:58
+1, так как отправка электронной почты и просмотр того, что происходит, - это единственный реальный надежный способ подтвердить адрес электронной почты, нет необходимости делать больше, чем простое совпадение с регулярным выражением.
kommradHomer 19.07.2012 07:14:33
Вы все еще можете сделать это простым, но сделайте немного больше, чтобы убедиться, что у него есть "." где-то после @, за которым следуют только цифры или цифры, поэтому такие вещи, как я @ здесь, меня @ здесь @ и меня @ herecom, недопустимы ... ^ \ S + @ \ S + [\.] [0-9a-z ] + $
Tim Franklin 21.03.2013 04:06:18
Я думаю, что адреса электронной почты могут содержать пробелы. Это, вероятно, лучше использовать.+@.+
Sam 10.04.2013 23:51:58
/\S+@\S+/.test("áéíóúý@ÁÉÍÓÚÝð") true
gtournie 27.01.2014 04:57:17
@gtournie Никому нет дела. Никто не собирается вводить это в поле электронной почты случайно , и это все, что нужно для проверки внешнего интерфейса: чтобы люди не могли случайно ввести неправильный бит информации, такой как их имя, в поле электронной почты.
meagar♦ 31.01.2015 14:59:52

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

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

328
2.05.2009 17:18:29
-1 Зачем мне тратить время на проверку адреса электронной почты, который даже не проходит через регулярное выражение?
kommradHomer 19.07.2012 07:16:01
@kommradHomer - неверный адрес регулярного выражения почти всегда действителен, потому что любое регулярное выражение, которое вы используете для проверки адреса электронной почты, почти наверняка неверно и исключит действительные адреса электронной почты. Адрес электронной почты name_part@domain_partи практически все, включая адрес @, действителен в name_part; Адрес foo@bar@machine.subdomain.example.museumявляется законным, хотя он должен быть экранирован как foo\@bar@machine..... Как только электронная почта достигает домена, например, «example.com», этот домен может направлять почту «локально», так что могут существовать «странные» имена пользователей и хостов.
Stephen P 7.03.2013 01:40:17
Второе регулярное выражение в ответе voyager на stackoverflow.com/a/1373724/69697 практично для использования и не должно иметь почти никаких ложных отрицаний. Я согласен с @kommradHomer здесь - зачем отправлять электронную почту, если вам не нужно? Я могу понять рефлексивную неприязнь к непонятным регулярным выражениям и желание сохранить код простым, но это пара строк кода, которые могут спасти ваш сервер от многих проблем, немедленно отсеяв элементы, которые определенно недействительны. Регулярное выражение само по себе бесполезно, но служит хорошим дополнением к проверке на стороне сервера.
Ben Regenspan 10.04.2013 21:30:28
@dmur Я признаю, что «почти всегда действительный», вероятно, преувеличивает его, но мои адреса электронной почты (совершенно действительные и работающие) слишком часто отклоняются веб-сайтами, просто потому, что у меня есть .usдомен или я использовал +слева от во @многих местах исправлены эти вопиющие ошибки, но локальной частью (слева от @) может быть все, что хочет владелец домена. -> "foo@bar.com"@example.com <- это действующий адрес электронной почты.
Stephen P 10.02.2014 18:15:47
@kommradHomer "Недопустимый адрес регулярного выражения -% 100 неверный адрес." Простите ... извините? Знаете ли вы, сколько раз мне говорили, что foo+bar@gmail.com НЕ является действительным электронным письмом, хотя на самом деле оно совершенно недействительно ?! Ваша логика крайне ошибочна. Я отправил формы с электронными письмами в следующем виде: thisisafakeemailbutitwillpassyourstupidregexcheck@regexchecksareretarded.com И угадайте, что? Это проходит проверку REGEX ... но это НЕ действительный адрес электронной почты (хотя технически это ЕСТЬ, но я обещаю вам, что его не существует ... пока царапает его подбородок ). Как уже говорили многие, это
Soundfx4 27.08.2017 21:43:56

Это было украдено с 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;}
46
2.05.2009 17:19:46
Это отфильтровывает все популярные .museumи .travelдомены (из-за ограничения в 4 символа после .)
bobobobo 16.09.2011 12:50:48
Изменение {2,4} на {2,6} не будет проблемой
Anton N 19.01.2012 12:37:25
@Anton N: у него есть еще около миллиарда других проблем; последний {2,4}- просто полезный индикатор этого (например, «когда вы видите эту ошибку, другие могут быть рядом»). Самые основные из них является отсутствие +в локальной части; это поле для комментариев слишком мало, чтобы указывать на все ошибки, допущенные выше.
Piskvor left the building 13.06.2012 15:43:11
Почему ты не можешь просто сделать return filter.test(email.value);?
MT. 15.06.2012 18:03:31
@AntonN: теперь у нас есть 10+ TLD ( xn--clchc0ea0b2g2a9gcd). Все еще не проблема?
Piskvor left the building 14.06.2014 15:27:27

Следующее регулярное выражение:

/^([\w]+)(.[\w]+)*@([\w]+)(.[\w]{2,3}){1,2}$/;
-6
11.09.2011 11:32:38
Это не соответствует RFC.
tchrist 14.07.2013 18:35:34

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

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

Вместо нового RegExpпросто попробуйте написать regexpтак:

if (reg.test(/@/))

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

17
15.04.2018 10:15:03

Просто для полноты, здесь у вас есть еще одно регулярное выражение в соответствии с 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

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

Акцент мой

752
20.06.2014 00:24:14
NB: «На практике сегодня » может быть действительным, когда код был написан, еще в 200 раз. Код , вероятно, останется в использовании после этого конкретного года. (Если бы я ни копейки за каждый «Мех, никто никогда не будет использовать 4 + -Письмо TLD за исключением тех , специфические» Я должен был исправить, я мог бы угол в мире меди и никеля рынок;))
Piskvor left the building 13.06.2012 15:51:34
Для практической реализации 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] /
will Farrell 19.07.2012 18:52:27
Кроме того, первая часть должна быть (?: [Az с большой буквы A, чтобы избежать ложных негативов, когда пользователь вводит заглавные буквы в своем адресе электронной почты.
Don Rolling 14.05.2013 14:22:17
@ DonRolling Не делай этого. Это не просто означает «от А до Я, от а до я», это также означает «[\] ^ _` », потому что они находятся между « Z »и« а ». Используйте \wили, что еще лучше, просто строчный адрес электронной почты, прежде чем делать что-либо с ним, потому что это соглашение в любом случае.
kirb 13.03.2016 10:53:48
«Вам нужно будет обновить его по мере добавления новых доменов верхнего уровня». Что ж, так много сейчас - существует более 1500 признанных доменов верхнего уровня.
Nathan Osman 25.03.2017 21:15:19

Вот очень хорошая дискуссия об использовании регулярных выражений для проверки адресов электронной почты; « Сравнение адреса электронной почты, проверяющего регулярные выражения »

Вот текущее верхнее выражение, совместимое с 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
12
28.05.2010 22:05:45
-1 Белый список оставляет желать лучшего - в частности, вы пропустили .jobs. Кроме того, существуют живые IDN (большинство из которых, я признаю, были официально одобрены только после вашего поста - например, .中國в июне 2010 года; но большинство работали годами).
Piskvor left the building 6.06.2011 01:50:02
-1 не используйте постоянные домены верхнего уровня. Там всегда (и будет, например, 2013) могут быть добавлены новые TLD.
miho 7.05.2012 13:56:06
Подтверждено 100 новых TLD. Этот ответ недействителен и никогда не должен использоваться.
Dean Meehan 18.02.2014 12:24:06
Ага. Я сказал это в 2011 году и скажу еще раз: белый список «специальных» доменов со временем будет только ухудшаться, так как будет одобрено больше TLD. Существует более 100 полностью действительных
Piskvor left the building 14.06.2014 15:21:37
Это 2015 год. Ваше выражение не практично. Вы должны записать этот ответ, но вы, вероятно, слишком заняты исправлением всех страниц, на которых написано это выражение. Правильно?
Eric Leroy 6.06.2015 23:40:40

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

/^([\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 года.

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

12
1.10.2010 09:37:31
Они забыли сбежать @.
Alan Moore 1.10.2010 17:38:28

Корректная проверка адреса электронной почты в соответствии с 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Например, перед последней точкой должно быть не менее трех символов a@b.com.

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

55
31.10.2018 09:15:21
Этот fn выглядит хорошо, но лучше ли это, чем регулярное выражение, написанное в верхнем ответе?
Atul Goyal 15.07.2011 09:24:01
Я сомневаюсь в этом. Я использую его только для проверки того, выглядит ли строка как электронное письмо, и оставляю детали для кода на стороне сервера.
Miloš Rašić 18.07.2011 16:18:25
Он проверяет правильность любой строки, например «aaaa», то есть без «@» и «.»
Gennady Shumakher 5.02.2012 10:14:38
Это не должно lastIndexOf () должен вернуть -1, если не находит стрелку.
Miloš Rašić 16.05.2012 16:28:54
«Даже если @в имени пользователя электронной почты он указан как последний символ, он должен быть заключен в кавычки, поэтому он "должен быть между этим @и последним @в адресе». Как насчет "@@"@example.com?
Ry-♦ 9.03.2014 20:04:17

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

<form><input type="email" placeholder="me@example.com" 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.!#$%&'*+/=?^_`{|}~-]+@[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])?)*$/
206
6.06.2019 06:49:09
это хорошо, но проблема в том, что он должен быть внутри formтега и представлен submitвходом, что не каждый может себе позволить. Кроме того, вы не можете оформить сообщение об ошибке.
Jason 12.11.2011 00:08:32
Я добавил ответ ниже, который освобождает вас от формы и отправки. Но да, браузеры обычно также применяют только некоторую проверку правдоподобия, а не полную проверку RFC 822.
Boldewyn 20.12.2012 15:25:28
@ br1: он недействителен только потому, что не существует домена верхнего уровня «а». почему ваша интрасеть имеет решимость на какой-то IP?
flying sheep 4.11.2013 11:16:44
Тип поля электронной почты Html5 принимает электронные письма, такие как user @ email
Puce 19.03.2015 13:42:31
Примечание @ Комментарий Пуце: ввод электронной почты в HTML 5 допускается, user@emailтогда как, например, в PHP - filter_varнет. Это может вызвать проблемы.
texelate 17.10.2019 07:38:27

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

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

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

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

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

24
9.03.2015 17:24:19
Это позволяет вводить столько недействительных адресов электронной почты, что это бесполезный совет.
cazlab 6.01.2012 23:07:44
Это не должно быть невозможно отладить вообще. В этой теме есть много прекрасных примеров, которые проверяют дальше, чем «содержит ли он @». Ваш пример позволяет считать «u @» действительным адресом электронной почты. По крайней мере, оцените, есть ли домен или что-то, что может быть доменом. Ваш пример является примером того, что я бы назвал «агрессивно ленивым кодированием». Я не уверен, почему вы защищаете его, так как это безусловно самый низкий рейтинг в ветке.
cazlab 26.01.2012 09:08:18
@cazlab возможно ты прав. В конце концов я был отклонен. В отличие от вас, я не думаю, что любой из приведенного выше кода показывает легко отлаживать фрагменты. Мой «агрессивно ленивый» подход, по крайней мере, может быть улучшен при необходимости.
Zo72 26.01.2012 11:37:43
Чем это отличается от использования регулярных выражений? (.+)@(.*)делает то же самое и короче.
snostorm 7.04.2012 21:03:11
+1 - если цель состоит в том, чтобы убедиться, что пользователь хотя бы попытался ввести адрес электронной почты, то проверьте, можно ли определить, что адрес электронной почты определенно НЕ является адресом электронной почты. отличное решение. Хорошим примером будет, если вы хотите, чтобы имя пользователя было адресом электронной почты. Если пользователь вводит «sexy_chick_23», то это регулярное выражение можно использовать, чтобы предупредить его, что ожидается электронное письмо. Если набрано что-то похожее на электронное письмо, но это не так, то пользователь никогда не получит электронное письмо с подтверждением и процесс регистрации никогда не будет проверен.
Chris Dutrow 2.09.2012 16:41:11

Я немного изменил ответ Джеймона для людей, которые хотят действительно простой проверки в виде:

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

804
14.03.2020 06:40:15
Вы можете реализовать что-то в 20 раз дольше, что может вызвать проблемы у нескольких пользователей и может оказаться недействительным в будущем, или вы можете взять версию ImmortalFirefly, чтобы убедиться, что они хотя бы приложат усилия, чтобы это выглядело реальным. В зависимости от вашего приложения может быть больше шансов встретить кого-нибудь, кто разозлится из-за того, что вы не принимаете его нетрадиционную электронную почту, а не из-за того, что вызывает проблемы, вводя адреса электронной почты, которые на самом деле не существуют (что они могут сделать в любом случае, введя 100% действительный адрес электронной почты RFC2822, но с использованием незарегистрированного имени пользователя или домена). Upvoted!
user83358 30.07.2012 18:20:04
@ImmortalFirefly, приведенное вами регулярное выражение будет фактически соответствовать name@again@example.com. Попробуйте вставить свою строку в консоль JavaScript. Я полагаю, что ваше намерение состояло в том, чтобы соответствовать только всему тексту, что потребовало бы начала текстовых операторов '^' и конца текста '$'. Тот, который я использую/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test('name@again@example.com')
OregonTrail 9.08.2012 14:58:13
На основании этой проверки это письмо действительно: check @ this..com
Ehsan 19.02.2014 07:18:16
Гектометр Википедия говорит, что "very.unusual.@.unusual.com"@example.comэто действительный адрес электронной почты. /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test('"very.unusual.@.unusual.com"@example.com') // false, К сожалению.
Bacon Bits 17.08.2017 20:20:19
Разве это не позволяет @@@.@? : D
hfossli 7.09.2017 08:02:32

В отличие от 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'); }
12
1.06.2016 05:12:03
Вам не нужно == trueна вашем примере.
Luke Alderton 11.03.2013 11:05:44

Решение Sectrean прекрасно работает, но это не помогло моему линтеру . Поэтому я добавил несколько побегов:

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); 
}
6
14.03.2014 16:32:29
validateEmail ("e_mail@sth.com") и validateEmail ("e.mail@sth.com") оба возвращают falseзначение
Ikrom 22.10.2013 10:04:13
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);   
  }   

Возвращает истину, если адрес электронной почты действителен. В противном случае он вернет false.

-7
5.06.2014 08:43:52

Сделай это:

[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

42
4.03.2019 19:32:07
@Kondal код JavaScript не чувствителен к регистру из-за /iфлага в конце регулярного выражения. Я упоминаю тот факт, что это должно быть сравнение без учета регистра, но я сделаю это более ясным.
Ryan Taylor 25.09.2017 19:02:12
Работал на меня как шарм
Alex 27.10.2019 14:17:04

В современных браузерах вы можете опираться на ответ @ 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 он освобождает вас от расправы с регулярными выражениями и не работает в старых браузерах.

93
25.07.2018 07:07:40
Это умная идея, чтобы разобраться с проблемой, но она не работает, потому что браузеры также имеют дрянную проверку. Например, .@aпроверяется как trueв текущих версиях Chrome, Firefox и Safari.
Hank 2.05.2013 18:44:23
@HenryJackson К сожалению, в этом случае да. Это потому, что в соответствии с RFC это действительный адрес электронной почты (например, интранет). Браузеры будут получать на гриле, если они проверяют слишком узко и выдают ложные негативы.
Boldewyn 3.05.2013 07:02:16
Обновлен, теперь содержит обнаружение функций и постепенную деградацию, теперь он не ломается в новых браузерах, а использует любое регулярное выражение, которое вам нравится.
Ronny 12.04.2015 08:51:58
Хорошее решение. К сожалению, это только для HTML5 +.
Edward Olamisan 6.05.2015 19:13:12
Это, безусловно, лучшее решение исходного вопроса. Да, он использует HTML5, но большинство приложений, которым требуется такой уровень точности, наверняка уже будет в любом случае полагаться на HTML5, так что спорный вопрос. Мы никогда не сможем определить, является ли чья-то электронная почта действительной, не заставляя их проверять ее, так или иначе, поэтому мы действительно не должны тратить столько времени или усилий на ее проверку. Быстрая проверка на любой очевидный синтаксис или попытку наглости - все усилия, которые мы должны приложить.
Woody Payne 17.02.2016 11:49:45
<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>
10
5.06.2014 09:05:36
Может быть, если вы добавили объяснение или описание, чтобы пойти с ним? Я не думаю, что вам действительно нужно показывать какие-либо HTML; все люди обеспокоены, это Javascript и регулярное выражение. Если вы сведете свой ответ только к jacascript и добавите небольшую рекламу, я дам вам голос.
bgmCoder 13.05.2013 13:51:43

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

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

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
11
14.03.2014 16:29:29

Это правильная версия 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);
}
68
25.02.2015 15:18:50
@ БГМ: Вы бы предпочли красивую функцию, которая не работает?
Piskvor left the building 14.06.2014 15:19:00
@Piskvor Нет, я бы предпочел красивую функцию, которая работает. Как насчет вас?
bgmCoder 15.06.2014 17:31:20
@BGM: тогда иди и отредактируй. Ответ, в конце концов, помечен как «сообщество вики».
Piskvor left the building 16.06.2014 09:59:16
Адреса IDN не подтверждены (info@üpöü.com)
D.A.H 17.08.2014 17:38:38

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

<input type="email"/>

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

23
14.03.2014 16:30:43
IE <10 не поддерживает это, как и собственный браузер Android.
Frank Conijn 13.06.2014 11:53:49
Upvoting. IE <10 мертв.
Michael Scheper 27.09.2018 16:31:39

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

email.indexOf("@") > 0

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

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

59
15.04.2018 10:22:07
что если будет более одного символа '@'? другие запрещенные символы? Этой проверке нельзя доверять ...
eatmypants 26.04.2015 10:14:10
Отлично, этот ответ был простым, только дополнительная проверка уровня. уже есть слой на переднем конце, так что это помогает, спасибо
Beep 29.06.2017 10:39:34
Это, безусловно, лучший ответ ИМО. Достаточно хорошо, чтобы поймать большинство случайных входных данных (то есть большинство вещей, которые не являются адресами электронной почты) без каких-либо ложных негативов.
John Montgomery 19.03.2019 00:09:49

Если вы используете Closure, вы можете использовать встроенный goog.format.EmailAddressтип:

http://docs.closure-library.googlecode.com/git/class_goog_format_EmailAddress.html

Например:

goog.format.EmailAddress.isValidAddrSpec("blah@blah.com")

Обратите внимание, что читая источник (ссылка выше), вы можете увидеть, что в комментариях говорится, что 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
3
14.07.2016 11:23:25

Вот как это делает узел-валидатор :

/^(?:[\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])\]))$/
19
15.04.2018 10:22:32

W3Schools предлагает хороший простой и эффективный скрипт для проверки электронной почты:

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

-6
5.06.2014 09:11:04
abc@xyzявляется совершенно действительным адресом электронной почты, который не распознается вашим регулярным выражением.
Toto 29.11.2013 12:31:10
Это не мое регулярное выражение, это регулярное выражение w3schools, и для простой проверки электронной почты, если вы предпочитаете быть слишком строгим, чем недостаточным, это просто работает. Если вы хотите полный пакет, используйте решение Voyager.
Calahad 2.12.2013 23:46:36
Довольно ужасно, однако, это будет проверять много неправильных электронных писем, то есть что-то вроде d @@. Com будет действительным.
Mads Mogenshøj 21.06.2014 19:43:09

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

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
}
14
15.04.2018 10:23:17
abc@xyzявляется совершенно действительным адресом электронной почты, который не распознается вашим регулярным выражением.
Toto 29.11.2013 12:32:42
Нет, это не так. Правильный шаблон электронной почты - что-то@something.something, abc @ xyz не соответствует этому шаблону. Так что это не правильный адрес.
Orchid 6.12.2013 08:09:25
Toto 6.12.2013 08:11:59
У вас была страница в Википедии? ДВУ - это действительное имя хоста. Так abc@tldже действительный адрес электронной почты.
Toto 6.12.2013 08:22:02
Единственный способ подтвердить адрес электронной почты - это отправить письмо и дождаться ответа. Кроме того, вот URL, где вы можете проверить, соответствует ли ваш адрес RFC822: mythic-beasts.com/~pdw/cgi-bin/emailvalidate . Вы можете видеть, что abc @ xyz является действительным адресом для RFC822.
Toto 6.12.2013 09:09:05

Регулярное выражение, предоставляемое 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})?$/

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

8
12.07.2014 02:59:07
Не позволяет + в части имени электронной почты.
Paul Go 9.03.2015 15:19:47
<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>
yoursite@ourearth.com
my.ownsite@ourearth.org
mysite@you.me.net
xxxx@gmail.com
xxxxxx@yahoo.com
</pre>
<pre>
xxxx.ourearth.com [@ is not present] 
xxxx@.com.my [ tld (Top Level domain) can not start with dot "." ]
@you.me.net [ No character before @ ]
xxxx123@gmail.b [ ".b" is not a valid tld ]
xxxx@.org.org [ tld can not start with dot "." ]
.xxxx@mysite.org [ an email should not be start with "." ]
xxxxx()*@gmail.com [ here the regular expression only allows character, digit, underscore and dash ]
xxxx..1234@yahoo.com [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;
    }
    }
3
28.01.2014 05:40:07