Jak zweryfikować adres e-mail w JavaScript

Czy istnieje wyrażenie regularne do weryfikacji adresu e-mail w JavaScript?

Używanie wyrażeń regularnych jest prawdopodobnie najlepszym sposobem. Można zobaczyć kilka testów tutaj (zaczerpnięte z chromu )

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());
}

Oto przykład regularnej ekspresji, która akceptuje Unicode:

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

Pamiętaj jednak, że nie należy polegać wyłącznie na sprawdzaniu poprawności kodu JavaScript. JavaScript można łatwo wyłączyć. Należy to również zweryfikować po stronie serwera.

Oto przykład powyższego działania:

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>

Lekko zmodyfikowałem odpowiedź Jaymona dla osób, które chcą naprawdę prostej weryfikacji w postaci:

anystring@anystring.anystring

Wyrażenie regularne:

/\S+@\S+\.\S+/

Przykładowa funkcja JavaScript:

function validateEmail(email) 
    {
        var re = /\S+@\S+\.\S+/;
        return re.test(email);
    }
    
console.log(validateEmail('anystring@anystring.anystring'));

Dla kompletności, oto kolejny regex zgodny z RFC 2822

Oficjalny standard jest znany jako RFC 2822 . Opisuje składnię, której muszą przestrzegać prawidłowe adresy e-mail. Możesz ( ale nie powinieneś - czytaj dalej ) zaimplementować to z tym wyrażeniem regularnym:

(?:[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])+)\])

(...) Otrzymujemy bardziej praktyczną implementację RFC 2822, jeśli pominiemy składnię za pomocą podwójnych cudzysłowów i nawiasów kwadratowych. Nadal będzie odpowiadać 99,99% wszystkich obecnie używanych adresów e-mail.

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

Kolejną zmianą, którą możesz wprowadzić, jest zezwolenie na dowolną dwuliterową domenę najwyższego poziomu z kodem kraju i tylko określone ogólne domeny najwyższego poziomu. To wyrażenie regularne filtruje fałszywe adresy e-mail, takie jakasdf@adsf.adsf . Będziesz musiał go zaktualizować w miarę dodawania nowych domen najwyższego poziomu .

[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

Tak więc nawet jeśli przestrzegamy oficjalnych standardów, nadal trzeba dokonać kompromisów. Nie ślepo kopiuj wyrażeń regularnych z bibliotek internetowych lub forów dyskusyjnych. Zawsze testuj je na własnych danych i we własnych aplikacjach.

_{Podkreśl moje}

Wow, tutaj jest dużo złożoności. Jeśli wszystko, co chcesz zrobić, to po prostu złapać najbardziej oczywiste błędy składniowe, zrobiłbym coś takiego:

^\S+@\S+$

Zwykle wychwytuje najbardziej oczywiste błędy popełniane przez użytkownika i zapewnia, że ​​formularz jest w większości poprawny, na tym właśnie polega walidacja JavaScript.

Jest coś, co musisz zrozumieć, gdy tylko zdecydujesz się użyć wyrażenia regularnego do sprawdzania poprawności wiadomości e-mail: Prawdopodobnie nie jest to dobry pomysł . Po tym, jak się z tym pogodzisz, istnieje wiele implementacji, które mogą doprowadzić cię do połowy, ten artykuł ładnie je podsumowuje.

Krótko mówiąc, jedynym sposobem na uzyskanie absolutnej, pozytywnej pewności, że to, co wpisał użytkownik, jest w rzeczywistości wiadomości e-mail, to wysłanie wiadomości e-mail i zobaczenie, co się stanie. Poza tym wszystko to tylko domysły.

Sam HTML5 ma weryfikację adresu e-mail. Jeśli Twoja przeglądarka obsługuje HTML5, możesz użyć następującego kodu.

<form><input type="email" placeholder="me@example.com" required>
    <input type="submit">
</form>

Link do jsFiddle

Ze specyfikacji HTML5 :

Prawidłowy adres e-mail jest ciąg, który pasuje do emailprodukcji następujących ABNF, zestaw znaków, dla których jest 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 >

To wymaganie jest umyślnym naruszeniem RFC 5322, który określa składnię adresów e-mail, która jest jednocześnie zbyt surowa (przed znakiem „@”), zbyt niejasna (po znaku „@”) i zbyt luźna (zezwalająca na komentarze , białych znaków i cytowanych ciągów w sposób nieznany większości użytkowników), które mogą być tutaj przydatne.

Poniższe wyrażenie regularne zgodne z JavaScript i Perl jest implementacją powyższej definicji.

/^[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])?)*$/

Uważam, że jest to najlepsze rozwiązanie:

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

Umożliwia następujące formaty:

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 (spacja między cudzysłowami)
8. üñîçøðé@example.com (znaki Unicode w części lokalnej)
9. üñîçøðé@üñîçøðé.com (znaki Unicode w części domeny)
10. Pelé@example.com (łacina)
11. δοκιμή@παράδειγμα.δοκιμή (grecki)
12. 我 買 @ 屋企. 香港 (chiński)
13. 甲 斐 @ 黒 川. 日本 (japoński)
14. чебурашка@ящик-с-апельсинами.рф (cyrylica)

Jest wyraźnie wszechstronny i pozwala na korzystanie ze wszystkich najważniejszych znaków międzynarodowych, przy jednoczesnym egzekwowaniu podstawowego formatu any@anything.aniething. Będzie blokować spacje, które technicznie są dozwolone przez RFC, ale są one tak rzadkie, że cieszę się, że to robię.

W nowoczesnych przeglądarkach możesz budować na podstawie odpowiedzi @ Sushil z czystym JavaScript i 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);
}

Złożyłem przykład w skrzypce http://jsfiddle.net/boldewyn/2b6d5/ . W połączeniu z wykrywaniem funkcji i sprawdzaniem poprawności gołych kości w odpowiedzi Squirtle's , uwalnia cię od masakry wyrażeń regularnych i nie zawodzi w starych przeglądarkach.

To jest poprawna wersja 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 może pasować do wyrażenia regularnego:

emailAddress.match( / some_regex /);

Oto wyrażenie regularne RFC22 dla wiadomości e-mail:

^((?>[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)>)$

Wszystkie adresy e-mail zawierają symbol „at” (tj. @). Sprawdź ten konieczny warunek:

email.indexOf("@") > 0

Nie przejmuj się niczym bardziej skomplikowanym. Nawet jeśli potrafisz doskonale ustalić, czy wiadomość e-mail jest poprawna pod względem składniowym RFC, nie powiedziałbyś, czy należy ona do osoby, która ją dostarczyła. To jest naprawdę ważne.

Aby to przetestować, wyślij wiadomość sprawdzającą poprawność.

Prawidłowe sprawdzenie poprawności adresu e-mail zgodnie z RFC nie jest czymś, co można osiągnąć za pomocą wyrażenia regularnego jednowierszowego. Artykuł z najlepszym rozwiązaniem, które znalazłem w PHP, to: Jaki jest prawidłowy adres e-mail? . Oczywiście został przeniesiony na Javę. Myślę, że ta funkcja jest zbyt złożona, aby można ją było przenieść i używać w JavaScript. Port JavaScript / node.js: https://www.npmjs.com/package/email-addresses .

Dobrą praktyką jest sprawdzanie poprawności danych na kliencie, ale dokładnie sprawdź poprawność na serwerze. Mając to na uwadze, możesz po prostu sprawdzić, czy ciąg znaków wygląda na prawidłowy adres e-mail na kliencie i wykonać ścisłą kontrolę na serwerze.

Oto funkcja JavaScript, której używam do sprawdzania, czy ciąg znaków wygląda na prawidłowy adres e-mail:

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

Wyjaśnienie:

• lastAtPos < lastDotPos: Ostatni @powinien być przedostatni, .ponieważ @nie może być częścią nazwy serwera (o ile wiem).

• lastAtPos > 0: Powinno być coś (nazwa użytkownika e-maila) przed ostatnim @.

• str.indexOf('@@') == -1: Nie powinno być @@adresu. Nawet jeśli @pojawia się jako ostatni znak w e-mailowej nazwie użytkownika, należy go zacytować, tak "aby znajdował się między tym @a ostatnim @adresem.

• lastDotPos > 2: Na przykład powinny być co najmniej trzy znaki przed ostatnią kropką a@b.com.

• (str.length - lastDotPos) > 2: Po ostatniej kropce powinno być wystarczającej liczby znaków, aby utworzyć domenę dwóch znaków. Nie jestem pewien, czy nawiasy są konieczne.

Zostało to skradzione z 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;}

Zrób to:

[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])?

Dlaczego? Opiera się na RFC 2822 , który jest standardowym WSZYSTKIM adresem e-mail, do którego MUSI się stosować. I nie jestem pewien, dlaczego zawracasz sobie głowę czymś „prostszym” ... i tak skopiujesz i wkleisz;)

Często, gdy przechowuję adresy e-mail w bazie danych, robię je małymi literami, a w praktyce wyrażenia regularne można zwykle oznaczać bez rozróżniania wielkości liter. W takich przypadkach jest to nieco krótsze:

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

Oto przykład użycia go w JavaScript (z flagą bez rozróżniania wielkości liter ina końcu).

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

Uwaga :
Technicznie niektóre wiadomości e-mail mogą zawierać cudzysłowy w sekcji przed @symbolem ze znakami zmiany znaczenia w cudzysłowach (aby użytkownik poczty e-mail mógł być wstrętny i zawierać elementy takie jak @i "..."tak długo, jak jest napisane w cudzysłowach). NIKT NIE ROBI TEGO! To jest przestarzałe. Ale JEST zawarty w prawdziwym standardzie RFC 2822 i tutaj pominięty.

Więcej informacji: http://www.regular-expressions.info/email.html

Naprawdę nie mogę się doczekać rozwiązania tego problemu. Zmodyfikowałem więc wyrażenie regularne sprawdzania poprawności wiadomości e-mail powyżej

• Oryginalny
  /^(([^<>()\[\]\\.,;:\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,}))$/

• Zmodyfikowano
  /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+[^<>()\.,;:\s@\"]{2,})$/

przekazać przykłady z adresu e-mail Wikipedii .

Możesz zobaczyć wynik tutaj .

Nie należy używać wyrażeń regularnych do sprawdzania poprawności ciągu wejściowego w celu sprawdzenia, czy jest to wiadomość e-mail. Jest to zbyt skomplikowane i nie obejmuje wszystkich przypadków.

Teraz, ponieważ możesz pokryć tylko 90% przypadków, napisz coś takiego:

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

Możesz to udoskonalić. Na przykład poprawne jest „aaa @”. Ale ogólnie masz sedno. I nie daj się zwieść ... Proste 90% rozwiązanie jest lepsze niż 100% rozwiązanie, które nie działa.

Świat potrzebuje prostszego kodu ...

Wystarczy sprawdzić, czy podany adres e-mail jest prawidłowy, czy nie używa HTML.

<input type="email"/>

Nie ma potrzeby pisania funkcji do sprawdzania poprawności.

Trudno jest uzyskać poprawność e-maila w 100% poprawną. Jedynym prawdziwym sposobem na poprawienie tego byłoby wysłanie testowego e-maila na konto. To powiedziawszy, istnieje kilka podstawowych kontroli, które mogą pomóc upewnić się, że otrzymujesz coś rozsądnego.

Niektóre rzeczy do poprawy:

Zamiast nowego RegExp, spróbuj napisać regexp:

if (reg.test(/@/))

Po drugie, sprawdź, czy po @znaku pojawia się kropka , i upewnij się, że między @s i kropkami są znaki .

Oto jak to robi walidator węzła :

/^(?:[\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])\]))$/

Użyj tego kodu w funkcji sprawdzania poprawności:

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;
}

W przeciwnym razie możesz użyć jQuery . Reguły wewnętrzne definiują:

eMailId: {
    required: true,
    email: true
}

Aktualizacja Regex 2018! Spróbuj tego

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

pełna wersja maszynopisu

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

więcej informacji https://git.io/vhEfc

Rozwiązanie, które nie sprawdza istnienia TLD, jest niekompletne.

Prawie wszystkie odpowiedzi na te pytania sugerują użycie Regex do sprawdzania poprawności adresów e-mail. Myślę, że Regex nadaje się tylko do podstawowej weryfikacji. Wygląda na to, że sprawdzanie poprawności adresów e-mail to tak naprawdę dwa osobne problemy:

1- Sprawdzanie poprawności formatu wiadomości e-mail: Upewnij się, że wiadomość e-mail jest zgodna z formatem i wzorcem wiadomości e-mail w RFC 5322 i czy TLD faktycznie istnieje. Lista wszystkich prawidłowych TLD znajduje się tutaj .

Na przykład, mimo że adres example@example.cccprzejdzie wyrażenie regularne, nie jest to prawidłowy adres e-mail, ponieważccc nie jest domeną najwyższego poziomu przez IANA.

2- Upewnij się, że e-mail faktycznie istnieje: W tym celu jedyną opcją jest wysłanie użytkownikom wiadomości e-mail .

Ponownie sprawdź poprawność adresu e-mail

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

Oto bardzo dobra dyskusja na temat używania wyrażeń regularnych do sprawdzania poprawności adresów e-mail; „ Porównywanie adresu e-mail sprawdzającego poprawność wyrażeń regularnych ”

Oto aktualne najważniejsze wyrażenie, które jest kompatybilne z JavaScript, w celach informacyjnych:

/^[-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

Najwyraźniej to wszystko:

/^([\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

Zaczerpnięte z http://fightingforalostcause.net/misc/2006/compare-email-regex.php z 1 października 10.

Ale to oczywiście ignoruje internacjonalizację.

W przeciwieństwie do squirtle , tutaj jest złożone rozwiązanie, ale wykonuje świetną robotę, sprawdzając poprawność wiadomości e-mail:

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

Użyj tak:

if (isEmail('youremail@yourdomain.com')){ console.log('This is email is valid'); }

Moja znajomość wyrażeń regularnych nie jest zbyt dobra. Dlatego najpierw sprawdzam ogólną składnię za pomocą prostego wyrażenia regularnego, a następnie sprawdzam bardziej szczegółowe opcje z innymi funkcjami. To może nie być najlepsze rozwiązanie techniczne, ale w ten sposób jestem bardziej elastyczny i szybszy.

Najczęstsze błędy, które napotkałem, to spacje (szczególnie na początku i na końcu), a czasami podwójna kropka.

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>

Szukałem Regex w JS, który przechodzi wszystkie przypadki testowe adresów e-mail:

• email@example.com Ważny email

• firstname.lastname@example.com E-mail zawiera kropkę w polu adresu

• email@subdomain.example.com E-mail zawiera kropkę z subdomeną

• firstname+lastname@example.com Znak plus jest uważany za prawidłowy znak

• email@192.0.2.123 Domena jest prawidłowym adresem IP

• email@[192.0.2.123] Kwadratowy nawias wokół adresu IP jest uważany za prawidłowy

• “email”@example.com Cytaty wokół wiadomości e-mail są uważane za prawidłowe

• 1234567890@example.com Cyfry w adresie są prawidłowe

• email@domain-one.example Kreska w nazwie domeny jest poprawna

• _______@example.com Podkreślenie w polu adresu jest prawidłowe

• email@example.name .name jest prawidłową nazwą domeny najwyższego poziomu

• email@example.co.jpKropka w nazwie domeny najwyższego poziomu również jest uważana za prawidłową ( co.jpna przykładzie tutaj)

• firstname-lastname@example.com Kreska w polu adresu jest poprawna

No to ruszamy :

http://regexr.com/3f07j

LUB wyrażenie regularne:

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

Wyrażenie regularne dostarczone przez Microsoft w ramach ASP.NET MVC to

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

Które zamieszczam tutaj na wypadek, gdyby był wadliwy - chociaż zawsze był idealny dla moich potrzeb.