Як перевірити електронну адресу в JavaScript

Чи є регулярний вираз для підтвердження електронної адреси в JavaScript?

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

function validateEmail(email) {
    const re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    return re.test(String(email).toLowerCase());
}

Ось приклад регулярного виразу, який приймає unicode:

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

Але майте на увазі, що не слід покладатися лише на перевірку JavaScript. JavaScript легко відключити. Це також має бути підтверджено і на стороні сервера.

Ось приклад вищезазначеного в дії:

function validateEmail(email) {
  const re = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
  return re.test(email);
}

function validate() {
  const $result = $("#result");
  const email = $("#email").val();
  $result.text("");

  if (validateEmail(email)) {
    $result.text(email + " is valid :)");
    $result.css("color", "green");
  } else {
    $result.text(email + " is not valid :(");
    $result.css("color", "red");
  }
  return false;
}

$("#validate").on("click", validate);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<form>
  <p>Enter an email address:</p>
  <input id='email'>
  <button type='submit' id='validate'>Validate!</button>
</form>

<h2 id='result'></h2>

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

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

Просто для повноти, тут у вас є ще один регулярний вирівнювання, сумісний з 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

Тож навіть дотримуючись офіційних стандартів, ще потрібно зробити компроміси. Не слід сліпо копіювати регулярні вирази з онлайн-бібліотек чи дискусійних форумів. Завжди перевіряйте їх на власних даних та у власних програмах.

_{Наголос мій}

Вау, тут багато складності. Якщо все, що ви хочете зробити, це просто зловити найочевидніші синтаксичні помилки, я б зробив щось подібне:

^\S+@\S+$

Зазвичай він фіксує найочевидніші помилки, які робить користувач, і запевняє, що форма здебільшого вірна, саме для цього і полягає перевірка JavaScript.

Ви повинні зрозуміти те, що ви вирішили використовувати регулярний вираз для перевірки електронних листів: це, мабуть, не дуже гарна ідея . Після того, як ви з цим погодилися, існує багато реалізацій, які можуть привести вас на півдорозі, ця стаття їх добре підводить.

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

Сам 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])?)*$/

Я вважав це найкращим рішенням:

/^[^\s@]+@[^\s@]+\.[^\s@]+$/

Це дозволяє наступні формати:

1. prettyandsimple@example.com
2. very.common@example.com
3. disposable.style.email.with+symbol@example.com
4. other.email-with-dash@example.com
9. #!$%&'*+-/=?^_`{}|~@example.org
6. "() []:,; @ \\\"! # $% & '* + - / =? ^ _ `{} | ~ .a "@ example.org
7. "" @ example.org (пробіл між цитатами)
8. üñîçøðé@example.com (символи Unicode в локальній частині)
9. üñîçøðé@üñîçøðé.com (символи Unicode в частині домену)
10. Pelé@example.com (латинська)
11. δοκιμή@παράδειγμα.δοκιμή (грецька)
12. 我 買 @ 屋企. 香港 (китайська)
13. 甲 斐 @ 黒 川. 日本 (японська)
14. чебурашка@ящик-с-апельсинамі.рф (кирилиця)

Він чітко універсальний та дозволяє виконувати всі важливі міжнародні символи, при цьому все ж застосовуючи базовий формат something@anything.anything. Це заблокує пробіли, які технічно дозволено RFC, але вони настільки рідкісні, що я радий це зробити.

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

Це правильна версія RFC822.

function checkEmail(emailAddress) {
  var sQtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]';
  var sDtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]';
  var sAtom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+';
  var sQuotedPair = '\\x5c[\\x00-\\x7f]';
  var sDomainLiteral = '\\x5b(' + sDtext + '|' + sQuotedPair + ')*\\x5d';
  var sQuotedString = '\\x22(' + sQtext + '|' + sQuotedPair + ')*\\x22';
  var sDomain_ref = sAtom;
  var sSubDomain = '(' + sDomain_ref + '|' + sDomainLiteral + ')';
  var sWord = '(' + sAtom + '|' + sQuotedString + ')';
  var sDomain = sSubDomain + '(\\x2e' + sSubDomain + ')*';
  var sLocalPart = sWord + '(\\x2e' + sWord + ')*';
  var sAddrSpec = sLocalPart + '\\x40' + sDomain; // complete RFC822 email address spec
  var sValidEmail = '^' + sAddrSpec + '$'; // as whole string

  var reValidEmail = new RegExp(sValidEmail);

  return reValidEmail.test(emailAddress);
}

JavaScript може відповідати звичайному виразу:

emailAddress.match( / some_regex /);

Ось регулярний вираз RFC22 для електронних листів:

^((?>[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+\x20*|"((?=[\x01-\x7f])[^"\\]|\\[\x01-\x7f])*
"\x20*)*(?<angle><))?((?!\.)(?>\.?[a-zA-Z\d!#$%&'*+\-/=?^_`{|}~]+)+|"((?=[\x01-\x
7f])[^"\\]|\\[\x01-\x7f])*")@(((?!-)[a-zA-Z\d\-]+(?<!-)\.)+[a-zA-Z]{2,}|\[(((?(?<
!\[)\.)(25[0-5]|2[0-4]\d|[01]?\d?\d)){4}|[a-zA-Z\d\-]*[a-zA-Z\d]:((?=[\x01-\x7f])
[^\\\[\]]|\\[\x01-\x7f])+)\])(?(angle)>)$

Усі адреси електронної пошти містять символ "at" (тобто @). Перевірте цю необхідну умову:

email.indexOf("@") > 0

Не турбуйтеся чимось складнішим. Навіть якби ви могли чудово визначити, чи є електронний лист синтаксично дійсним, це не означає, чи належить він тому, хто його постачав. Ось що насправді має значення.

Щоб перевірити це, надішліть повідомлення про перевірку.

Правильна перевірка адреси електронної пошти відповідно до 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: Після останньої крапки має бути достатньо символів, щоб сформувати домен з двома символами. Я не впевнений, чи потрібні дужки.

Це було вкрадено з 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;}

Зробити це:

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

Примітка .
Технічно деякі електронні листи можуть містити лапки в розділі перед @символом із символами втечі всередині лапок (щоб ваш користувач електронної пошти міг бути неприємним та містити такі речі, як @і до "..."тих пір, поки це написано в лапках). НІКОЛИ НЕ РОБИТЬ ЦІЙ! Це застаріло. Але він включений у справжній стандарт RFC 2822 і тут пропущений.

Більше інформації: http://www.regular-expressions.info/email.html

Я дуже сподіваюся вирішити цю проблему. Тому я змінив регулярне вираз перевірки електронної пошти вище

• Оригінал
  /^(([^<>()\[\]\\.,;:\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,})$/

щоб передати приклади у Вікіпедії .

І результат ви можете побачити тут .

Не слід використовувати регулярні вирази для перевірки рядка введення, щоб перевірити, чи це електронний лист. Це занадто складно і не охоплювало б усіх справ.

Тепер, оскільки ви можете покрити лише 90% випадків, напишіть щось на кшталт:

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

Ви можете його вдосконалити. Наприклад, "aaa @" є дійсним. Але в цілому ви отримуєте суть. І не захоплюйтесь ... Простий 90% -й розчин краще, ніж 100% -ний розчин, який не працює.

Світ потребує простішого коду ...

Просто перевірте, чи введена адреса електронної пошти дійсна чи не використовується HTML.

<input type="email"/>

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

Важко отримати валідатор електронної пошти на 100% правильний. Єдиний реальний спосіб виправити це - надіслати тестовий лист на рахунок. Однак, є кілька основних перевірок, які допоможуть переконатися, що ви отримуєте щось розумне.

Деякі вдосконалення:

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

if (reg.test(/@/))

По-друге, перевірте, чи настає @знак після знака, і переконайтеся, що між символами @s та періодами є символи .

Ось як це робить валідатор вузлів :

/^(?:[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+\.)*[\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+@(?:(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-](?!\.)){0,61}[a-zA-Z0-9]?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9\-](?!$)){0,61}[a-zA-Z0-9]?)|(?:\[(?:(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\]))$/

Використовуйте цей код у вашій функції валідатора:

var emailID = document.forms["formName"]["form element id"].value;
atpos = emailID.indexOf("@");
dotpos = emailID.lastIndexOf(".");
if (atpos < 1 || ( dotpos - atpos < 2 ))
{
    alert("Please enter correct email ID")
    return false;
}

Інакше ви можете використовувати jQuery . Правила всередині визначають:

eMailId: {
    required: true,
    email: true
}

Оновлення Regex 2018! спробуйте це

let val = 'email@domain.com';
if(/^[a-z0-9][a-z0-9-_\.]+@([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[a-z]{2,10})?$/.test(val)) {
   console.log('passed');
}

версія машинопису завершена

//
export const emailValid = (val:string):boolean => /^[a-z0-9][a-z0-9-_\.]+@([a-z]|[a-z0-9]?[a-z0-9-]+[a-z0-9])\.[a-z0-9]{2,10}(?:\.[a-z]{2,10})?$/.test(val);

більше інформації https://git.io/vhEfc

Рішення, яке не перевіряє існування TLD, є неповним.

Майже всі відповіді на ці запитання пропонують використовувати Regex для перевірки адрес електронної пошти. Я думаю, що Regex корисний лише для рудиментарної перевірки. Схоже, перевірка перевірки електронних адрес - це фактично дві окремі проблеми:

1- Перевірка формату електронної пошти: Переконайтесь, що відповідність електронному листу формату та шаблону електронних листів у RFC 5322 та чи TLD насправді існує. Список усіх дійсних TLD можна знайти тут .

Наприклад, хоча адреса example@example.cccпередасть регулярний вираз, він не є дійсним електронною поштою, оскільки cccIANA не є доменом вищого рівня.

2- Переконайтесь, що електронна пошта насправді існує: Для цього єдиний варіант - надіслати користувачам електронний лист .

Regex для підтвердження електронної адреси

[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])+

Ось дуже гарна дискусія щодо використання регулярних виразів для перевірки адрес електронної пошти; " Порівняння електронної адреси, що підтверджує регулярні вирази "

Ось поточний верхній вираз, який сумісний з JavaScript, для довідок:

/^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+)*\.(aero|arpa|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org|pro|travel|mobi|[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i

Мабуть, це все:

/^([\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://fightingforalostWeather.net/misc/2006/compare-email-regex.php 1 жовтня 10 року.

Але, звичайно, це ігнорування інтернаціоналізації.

На відміну від 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'); }

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

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

function check_email(val){
    if(!val.match(/\S+@\S+\.\S+/)){ // Jaymon's / Squirtle's solution
        // Do something
        return false;
    }
    if( val.indexOf(' ')!=-1 || val.indexOf('..')!=-1){
        // Do something
        return false;
    }
    return true;
}

check_email('check@thiscom'); // Returns false
check_email('check@this..com'); // Returns false
check_email(' check@this.com'); // Returns false
check_email('check@this.com'); // Returns true

<form name="validation" onSubmit="return checkbae()">
    Please input a valid email address:<br />

    <input type="text" size=18 name="emailcheck">
    <input type="submit" value="Submit">
</form>

<script language="JavaScript1.2">
    var testresults
    function checkemail(){
        var str = document.validation.emailcheck.value
        var filter = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i
        if (filter.test(str))
            testresults = true
        else {
            alert("Please input a valid email address!")
            testresults = false
        }
        return (testresults)
    }
</script>

<script>
    function checkbae(){
        if (document.layers || document.getElementById || document.all)
            return checkemail()
        else
            return true
    }
</script>

Я шукав Regex в JS, який передає всі тестові випадки електронної адреси:

• email@example.com Дійсний електронний лист

• firstname.lastname@example.com Електронна пошта містить крапки в адресному полі

• email@subdomain.example.com Електронна пошта містить крапку з субдоменом

• firstname+lastname@example.com Знак плюс вважається дійсним символом

• email@192.0.2.123 Домен є дійсною IP-адресою

• email@[192.0.2.123] Квадратна дужка навколо IP-адреси вважається дійсною

• “email”@example.com Цитати навколо електронної пошти вважаються дійсними

• 1234567890@example.com Цифри в адресі дійсні

• email@domain-one.example Тире в доменному імені дійсне

• _______@example.com Підкреслення в полі адреси є дійсним

• email@example.name .name дійсне ім'я домену верхнього рівня

• email@example.co.jpТочка в доменному домені верхнього рівня також вважається дійсною (використовуючи co.jpяк приклад тут)

• firstname-lastname@example.com Тире в адресному полі є дійсним

Ось і ми :

http://regexr.com/3f07j

АБО регекс:

Regex = /(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@[*[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+]*/

Регулярний вираз, що надається Microsoft в рамках ASP.NET MVC, - це

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

Я розміщую тут на випадок, коли це недосконало - хоча це завжди було ідеально для моїх потреб.