Jak zweryfikować adres e-mail w JavaScript

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

[email protected]

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('[email protected]'));

Dla kompletności, Tutaj masz inny regex zgodny z RFC 2822

Oficjalny standard jest znany jako RFC 2822 . Opisuje składnię, której muszą przestrzegać poprawne adresy e-mail. Możesz (ale nie powinieneś - read on) zaimplementuj go za pomocą tego wyrażenia regularnego:

(?:[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ę używając cudzysłowów i nawiasów kwadratowych. nadal będzie dopasuj 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 i tylko określone ogólne domeny najwyższego poziomu. ten regex filtruje atrapy adresów e-mail jak [email protected]. Po dodaniu nowych domen najwyższego poziomu będziesz musiał ją zaktualizować.

[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

Więc nawet jeśli postępujesz zgodnie z oficjalnymi standardami, nadal istnieją kompromisy do osiągnięcia. nie ślepo kopiowanie wyrażeń regularnych z bibliotek internetowych lub forów dyskusyjnych. Zawsze testuj je na własnych danych i za pomocą własnych aplikacji.

_Mine

Wow, tu jest wiele złożoności. Jeśli chcesz tylko wyłapać najbardziej oczywiste błędy składniowe, zrobiłbym coś takiego:

^\S+@\S+$

Zazwyczaj wychwytuje najbardziej oczywiste błędy popełniane przez użytkownika i zapewnia, że formularz jest w większości prawidłowy, czyli o to chodzi w walidacji JavaScript.

Jest coś, co musisz zrozumieć, gdy tylko zdecydujesz się użyć wyrażenia regularnego do walidacji wiadomości e-mail: to prawdopodobnie nie jest dobry pomysł . Kiedy już się z tym uporasz, istnieje wiele implementacji, które mogą pomóc ci w połowie drogi, Ten artykuł ładnie je podsumowuje.

Krótko mówiąc, jedynym sposobem, aby być absolutnie, pozytywnie pewnym, że to, co użytkownik wprowadził, jest w rzeczywistości e-mail, jest wysłanie e-maila i zobacz, co się stanie. Inne to tylko domysły.

HTML5 ma walidację poczty e-mail. Jeśli twoja przeglądarka obsługuje HTML5, możesz użyć następującego kodu.

<form><input type="email" placeholder="[email protected]" required>
    <input type="submit">
</form>

Jsfiddle link

From the HTML5 spec :

A poprawny adres e-mail jest ciągiem znaków, który odpowiada email produkcji następującego ABNF, którego zestawem znaków 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 >

Ten wymóg jest umyślnym naruszeniem RFC 5322, który definiuje składnię adresów e-mail, która jest jednocześnie zbyt ścisłe (przed znakiem"@"), zbyt niejasne (po znaku"@") i zbyt luźne (pozwalając komentarzom, znakom spacji i cytowanym ciągom znaków w sposób nieznany większości użytkowników), aby mogły być tutaj użyte w praktyce.

Następujące 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])?)*$/

Uznałem to za najlepsze rozwiązanie:

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

Pozwala na następujące formaty:

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)

Jest wyraźnie wszechstronny i pozwala wszystkim ważnym międzynarodowym postaciom, jednocześnie wymuszając podstawowe wszystko @ cokolwiek.dowolny format. Blokuje przestrzenie, które są technicznie dozwolone przez RFC, ale są one tak rzadkie, że chętnie to zrobię.

W nowoczesnych przeglądarkach można budować na podstawie odpowiedzi @ Sushil za pomocą czystego 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);
}

I 've got together an example in the fiddle http://jsfiddle.net/boldewyn/2b6d5 / . w połączeniu z wykrywaniem funkcji i walidacją gołych kości z Squirtle' s Answer, uwalnia cię od masakry wyrażeń regularnych i nie bork na starych przeglądarkach.

Jest to 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 dopasować Wyrażenie regularne:

emailAddress.match( / some_regex /);

Oto RFC22 Wyrażenie regularne 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)>)$

Poprawna Walidacja adresu e-mail zgodnie z RFCs nie jest czymś, co można osiągnąć za pomocą jednoliniowego wyrażenia regularnego. Artykuł z najlepszym rozwiązaniem jakie znalazłem w PHP jest co to jest prawidłowy adres e-mail?. Oczywiście został on przeniesiony na Javę. myślę, że funkcja jest zbyt złożona, aby można ją było przenosić i używać w JavaScript. JavaScript / node.Port js: https://www.npmjs.com/package/email-addresses .

Dobrą praktyką jest aby zweryfikować swoje dane na kliencie, ale dwukrotnie sprawdź walidację na serwerze. Mając to na uwadze, możesz po prostu sprawdzić, czy ciąg znaków wygląda jak prawidłowy adres e-mail na kliencie i wykonać ścisłe sprawdzenie na serwerze.

Oto funkcja JavaScript, której używam, aby sprawdzić, czy ciąg znaków wygląda jak poprawny adres pocztowy:

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: Last @ powinno być przed last . Ponieważ @ nie może być częścią nazwy serwera (o ile I wiedzieć).

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

• str.indexOf('@@') == -1: nie powinno być @@ w adresie. Nawet jeśli @ pojawia się jako ostatni znak w Nazwie użytkownika e-maila, musi być zacytowany tak, aby " znajdował się pomiędzy @ a ostatnim @ w adresie.

• lastDotPos > 2: przed ostatnią kropką powinny być co najmniej trzy znaki, na przykład [email protected].

• (str.length - lastDotPos) > 2: powinno być wystarczy znaków po ostatniej kropce, aby utworzyć domenę dwuznakową. Nie jestem pewien, czy wsporniki są konieczne.

Wszystkie adresy e-mail zawierają symbol' at ' (tj.@). Badanie wymaganego warunku:

email.indexOf("@") > 0

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

To zostało skradzione 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])?

Często podczas przechowywania adresów e-mail w bazie danych robię je małymi literami, a w praktyce wyrażenia regularne mogą być oznaczone jako niewrażliwe na wielkość liter. W tych 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 i na 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('[email protected]') );

Uwaga :
Technicznie niektóre e-maile mogą zawierać cudzysłowy w sekcji przed symbolem @ ze znakami ucieczki wewnątrz cudzysłowów (więc twój użytkownik poczty e-mail może być wstrętny i zawierać rzeczy takie jak @ i "...", o ile jest napisany w cudzysłowie). NIKT TEGO NIGDY NIE ROBI! Jest przestarzały. Jest to jednak zawarte w prawdziwym standardzie RFC 2822 i pominięte tutaj.

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

Nie mogę się doczekać rozwiązania tego problemu. Więc zmodyfikowałem Wyrażenie regularne e-mail validation powyżej

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

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

Aby podać przykłady w adres e-mail Wikipedii.

I możesz zobaczyć wynik w tutaj .

Nie należy używać wyrażeń regularnych do walidacji ciągu wejściowego, aby sprawdzić, czy jest to wiadomość e-mail. To zbyt skomplikowane i nie obejmowałoby wszystkich spraw.

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

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

Po prostu sprawdź, czy wprowadzony adres e-mail jest poprawny, czy nie używa HTML.

<input type="email"/>

Nie ma potrzeby pisania funkcji do walidacji.

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

Kilka rzeczy do poprawy:

Zamiast nowego RegExp, po prostu spróbuj napisać regexp Tak:

if (reg.test(/@/))

Po drugie, upewnij się, że kropka pojawia się po znaku @, i upewnij się, że między znakami są znaki @ S i okresy.

Tak robi node-validator :

/^(?:[\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 wewnątrz funkcji walidatora:

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 . Wewnątrz reguły definiują:

eMailId: {
    required: true,
    email: true
}

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

Prawie wszystkie odpowiedzi na te pytania sugerują użycie Regex do walidacji adresów e-mail. Myślę, że Regex jest dobry tylko dla podstawowej walidacji. Wydaje się, że sprawdzanie poprawności adresów e-mail jest w rzeczywistości dwoma oddzielnymi problemami:

1- Walidacja formatu wiadomości e-mail: upewnienie się, czy wiadomość e-mail jest zgodna z formatem i wzorem wiadomości w RFC 5322 i czy TLD rzeczywiście istnieje. A listę wszystkich ważnych domen TLD można znaleźć tutaj .

Na przykład, chociaż adres [email protected] przejdzie regex, nie jest to prawidłowy e-mail, ponieważ ccc nie jest domeną najwyższego poziomu przez IANA.

2- Upewnij się, że wiadomość e-mail rzeczywiście istnieje: w tym celu, jedyną opcją jest , aby wysłać użytkownikom wiadomość e-mail.

Regex update 2018! try this

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

Typscript version complete

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

Regex do walidacji 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 adresów e-mail; "porównywanie adresów e-mail sprawdzanie wyrażeń regularnych "

Tutaj jest obecne wyrażenie top, które jest kompatybilne z JavaScript, dla celów referencyjnych:

/^[-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 jest to:

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

Wzięte z http://fightingforalostcause.net/misc/2006/compare-email-regex.php on Oct 1 '10.

Ale, oczywiście, to ignorowanie internacjonalizacji.

W przeciwieństwie do squirtle , tutaj jest złożone rozwiązanie, ale robi bardzo dobrą robotę sprawdzania poprawności 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('[email protected]')){ console.log('This is email is valid'); }

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

Najczęściej spotykanymi błędami są spacje (szczególnie na początku i końcu) i 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('[email protected]'); // Returns false
check_email(' [email protected]'); // Returns false
check_email('[email protected]'); // 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 wyrażenia regularnego w JS, który przechodzi wszystkie przypadki testowe adresu e-mail:

• [email protected] Valid email

• [email protected] e-mail zawiera kropkę w polu adresu

• [email protected] E-mail zawiera kropkę z subdomeną

• [email protected] znak Plus jest uważany za ważny znak

• [email protected] domena jest poprawnym adresem IP

• email@[192.0.2.123] kwadratowy nawias wokół adresu IP jest uważany valid

• “email”@example.com Cytaty wokół e-maila są uważane za ważne

• [email protected] cyfry w adresie są poprawne

• [email protected] Dash w nazwie domeny jest poprawny

• [email protected] podkreślenie w polu adresu jest poprawne

• [email protected] .name jest poprawna nazwa domeny najwyższego poziomu

• [email protected] kropka w nazwie domeny najwyższego poziomu również uważana za ważną (używając co.jp jako przykład tutaj)

• [email protected] Dash in address pole jest poprawne

Zaczynamy:

Http://regexr.com/3f07j

Lub regex:

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

Standardowa składnia poczty Wikipedii:

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

Pokaż ten test: https://regex101.com/r/LHJ9gU/1