Cara memvalidasi alamat email dalam JavaScript

Apakah ada ekspresi reguler untuk memvalidasi alamat email dalam JavaScript?

Menggunakan ekspresi reguler mungkin adalah cara terbaik. Anda dapat melihat banyak tes di sini (diambil dari kromium )

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

Berikut adalah contoh dari expresi reguler yang menerima unicode:

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

Tetapi perlu diingat bahwa seseorang tidak hanya bergantung pada validasi JavaScript. JavaScript dapat dengan mudah dinonaktifkan. Ini harus divalidasi di sisi server juga.

Berikut ini contoh tindakan di atas:

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>

Saya sedikit mengubah jawaban Jaymon untuk orang-orang yang ingin validasi sangat sederhana dalam bentuk:

anystring@anystring.anystring

Ekspresi reguler:

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

Contoh fungsi JavaScript:

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

Hanya untuk kelengkapan, di sini Anda memiliki regex yang kompatibel dengan RFC 2822

Standar resmi dikenal sebagai RFC 2822 . Ini menjelaskan sintaksis yang harus dipatuhi oleh alamat email yang valid. Anda dapat ( tetapi Anda tidak boleh - baca terus ) menerapkannya dengan ekspresi reguler ini:

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

(...) Kami mendapatkan implementasi RFC 2822 yang lebih praktis jika kami menghilangkan sintaks menggunakan tanda kutip ganda dan tanda kurung siku. Masih akan cocok dengan 99,99% dari semua alamat email yang digunakan saat ini.

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

Perubahan lebih lanjut yang dapat Anda lakukan adalah mengizinkan domain tingkat atas kode dua huruf apa saja, dan hanya domain tingkat atas generik tertentu. Regex ini menyaring seperti alamat email dummy[email protected] . Anda perlu memperbaruinya saat domain tingkat atas baru ditambahkan .

[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

Jadi, bahkan ketika mengikuti standar resmi, masih ada trade-off yang harus dilakukan. Jangan membabi buta menyalin ekspresi reguler dari perpustakaan online atau forum diskusi. Selalu mengujinya pada data Anda sendiri dan dengan aplikasi Anda sendiri.

_{Tekankan milikku}

Wow, ada banyak kerumitan di sini. Jika semua yang ingin Anda lakukan hanyalah menangkap kesalahan sintaksis yang paling jelas, saya akan melakukan sesuatu seperti ini:

^\S+@\S+$

Biasanya menangkap kesalahan paling jelas yang dibuat pengguna dan memastikan bahwa formulir sebagian besar benar, yang merupakan inti dari validasi JavaScript.

Ada sesuatu yang harus Anda pahami begitu Anda memutuskan untuk menggunakan ekspresi reguler untuk memvalidasi email: Ini mungkin bukan ide yang baik . Setelah Anda sepakat dengan hal itu, ada banyak implementasi di luar sana yang dapat membantu Anda di sana, artikel ini merangkumnya dengan baik.

Singkatnya, bagaimanapun, satu-satunya cara untuk benar-benar yakin bahwa apa yang dimasukkan pengguna sebenarnya adalah email adalah benar-benar mengirim email dan melihat apa yang terjadi. Selain itu semua hanya tebakan.

HTML5 sendiri memiliki validasi email. Jika browser Anda mendukung HTML5 maka Anda dapat menggunakan kode berikut.

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

tautan jsFiddle

Dari spesifikasi HTML5 :

Sebuah alamat e-mail yang valid adalah string yang cocok dengan emailproduksi ABNF berikut, set karakter yang merupakan 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 >

Persyaratan ini adalah pelanggaran yang disengaja terhadap RFC 5322, yang mendefinisikan sintaks untuk alamat email yang secara bersamaan terlalu ketat (sebelum karakter "@"), terlalu kabur (setelah karakter "@"), dan terlalu longgar (memungkinkan komentar , karakter spasi putih, dan string kutipan dalam perilaku yang tidak dikenal oleh sebagian besar pengguna) agar praktis digunakan di sini.

Ekspresi reguler yang kompatibel dengan JavaScript dan Perl adalah implementasi dari definisi di atas.

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

Saya menemukan ini sebagai solusi terbaik:

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

Ini memungkinkan format berikut:

1. [email protected]
2. [email protected]
3. [email protected]
4. [email protected]
9. #!$%&'*+-/=?^_`{}|[email protected]
6. "() []:,; @ \\\"! # $% & '* + - / =? ^ _ `{} | ~ .a "@ example.org
7. "" @ example.org (spasi di antara tanda kutip)
8. üñîçøðé@example.com (Karakter Unicode di bagian lokal)
9. üñîçøðé@üñîçøðé.com (Karakter Unicode di bagian domain)
10. Pelé@example.com (Latin)
11. δοκιμή@παράδειγμα.δοκιμή (Yunani)
12. 我 買 @ 屋企. 香港 (Bahasa Cina)
13. 甲 斐 @ 黒 川. 日本 (Jepang)
14. чебурашка@ящик-с-апельсинами.рф (Cyrillic)

Ini jelas serbaguna dan memungkinkan karakter internasional yang sangat penting, sambil tetap menegakkan format dasar [email protected]. Ini akan memblokir ruang yang secara teknis diizinkan oleh RFC, tetapi mereka sangat jarang sehingga saya senang melakukannya.

Di browser modern, Anda dapat membangun di atas jawaban @ Sushil dengan JavaScript murni dan 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);
}

Saya telah mengumpulkan contoh di biola http://jsfiddle.net/boldewyn/2b6d5/ . Dikombinasikan dengan deteksi fitur dan validasi tanpa tulang dari Squirtle's Answer , itu membebaskan Anda dari pembantaian ekspresi reguler dan tidak mengganggu browser lama.

Ini adalah versi RFC822 yang benar.

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 dapat mencocokkan ekspresi reguler:

emailAddress.match( / some_regex /);

Berikut ini ekspresi reguler RFC22 untuk email:

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

Semua alamat email berisi simbol 'at' (yaitu @). Uji kondisi yang diperlukan:

email.indexOf("@") > 0

Jangan repot-repot dengan hal yang lebih rumit. Sekalipun Anda dapat dengan sempurna menentukan apakah suatu email adalah RFC-secara sintaksis valid, itu tidak akan memberi tahu Anda apakah itu milik orang yang menyediakannya. Itu yang sangat penting.

Untuk mengujinya, kirim pesan validasi.

Validasi yang benar dari alamat email sesuai dengan RFC bukanlah sesuatu yang dapat dicapai dengan ekspresi reguler satu-liner. Artikel dengan solusi terbaik yang saya temukan di PHP adalah Apa alamat email yang valid? . Jelas, itu telah porting ke Jawa. Saya pikir fungsinya terlalu kompleks untuk porting dan digunakan dalam JavaScript. Port JavaScript / node.js: https://www.npmjs.com/package/email-addresses .

Praktik yang baik adalah memvalidasi data Anda di klien, tetapi periksa kembali validasinya di server. Dengan mengingat hal ini, Anda dapat dengan mudah memeriksa apakah suatu string terlihat seperti alamat email yang valid pada klien dan melakukan pemeriksaan ketat pada server.

Inilah fungsi JavaScript yang saya gunakan untuk memeriksa apakah string terlihat seperti alamat email yang valid:

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

Penjelasan:

• lastAtPos < lastDotPos: Terakhir @harus sebelum terakhir .karena @tidak dapat menjadi bagian dari nama server (sejauh yang saya tahu).

• lastAtPos > 0: Harus ada sesuatu (nama pengguna email) sebelum yang terakhir @.

• str.indexOf('@@') == -1: Seharusnya tidak ada @@di alamat. Bahkan jika @muncul sebagai karakter terakhir dalam nama pengguna email, itu harus dikutip sehingga "akan menjadi antara itu @dan yang terakhir @di alamat.

• lastDotPos > 2: Harus ada setidaknya tiga karakter sebelum titik terakhir, misalnya [email protected].

• (str.length - lastDotPos) > 2: Seharusnya ada cukup karakter setelah titik terakhir untuk membentuk domain dua karakter. Saya tidak yakin apakah tanda kurung diperlukan.

Ini dicuri dari 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;}

Melakukan hal ini:

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

Mengapa? Ini didasarkan pada RFC 2822 , yang merupakan standar SEMUA alamat email HARUS dipatuhi. Dan saya tidak yakin mengapa Anda akan repot dengan sesuatu yang "lebih sederhana" ... Anda akan menyalin dan menempelkannya;)

Seringkali ketika menyimpan alamat email dalam database saya membuatnya menjadi huruf kecil dan, dalam praktiknya, regexs biasanya dapat ditandai sebagai huruf tidak peka. Dalam kasus ini, ini sedikit lebih pendek:

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

Berikut adalah contoh penggunaannya dalam JavaScript (dengan tanda case case iin the end).

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

Catatan :
Secara teknis beberapa email dapat menyertakan tanda kutip di bagian sebelum @simbol dengan karakter pelarian di dalam tanda kutip (sehingga pengguna email Anda bisa menjengkelkan dan mengandung hal-hal seperti @dan "..."selama itu ditulis dalam tanda kutip). TIDAK ADA YANG PERNAH ADA INI! Sudah usang. Tapi, itu termasuk dalam standar RFC 2822 yang sebenarnya , dan dihilangkan di sini.

Info lebih lanjut: http://www.regular-expressions.info/email.html

Saya sangat menantikan untuk menyelesaikan masalah ini. Jadi saya memodifikasi validasi reguler ekspresi email di atas

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

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

untuk memberikan contoh di Alamat Email Wikipedia .

Dan Anda dapat melihat hasilnya di sini .

Anda tidak boleh menggunakan ekspresi reguler untuk memvalidasi string input untuk memeriksa apakah itu email. Ini terlalu rumit dan tidak akan mencakup semua kasus.

Sekarang karena Anda hanya dapat menutupi 90% dari kasing, tulis sesuatu seperti:

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

Anda bisa memperbaikinya. Misalnya, 'aaa @' valid. Tapi secara keseluruhan Anda mendapatkan intinya. Dan jangan terbawa ... Solusi 90% sederhana lebih baik daripada solusi 100% yang tidak bekerja.

Dunia membutuhkan kode yang lebih sederhana ...

Cukup periksa apakah alamat email yang dimasukkan valid atau tidak menggunakan HTML.

<input type="email"/>

Tidak perlu menulis fungsi untuk validasi.

Sulit untuk mendapatkan validator email 100% benar. Satu-satunya cara nyata untuk memperbaikinya adalah dengan mengirim email percobaan ke akun. Yang mengatakan, ada beberapa pemeriksaan dasar yang dapat membantu memastikan bahwa Anda mendapatkan sesuatu yang masuk akal.

Beberapa hal untuk ditingkatkan:

Alih-alih baru RegExp, cobalah menulis regexpseperti ini:

if (reg.test(/@/))

Kedua, periksa untuk memastikan bahwa suatu periode muncul setelah @tanda, dan pastikan bahwa ada karakter antara tanda @dan periode.

Inilah cara simpul-validator melakukannya:

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

Gunakan kode ini di dalam fungsi validator Anda:

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

Lain Anda bisa menggunakan jQuery . Aturan di dalam mendefinisikan:

eMailId: {
    required: true,
    email: true
}

Pembaruan Regex 2018! coba ini

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

versi naskah lengkap

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

info lebih lanjut https://git.io/vhEfc

Solusi yang tidak memeriksa keberadaan TLD tidak lengkap.

Hampir semua jawaban untuk pertanyaan ini menyarankan menggunakan Regex untuk memvalidasi alamat email. Saya pikir Regex hanya baik untuk validasi yang belum sempurna. Tampaknya validasi pengecekan alamat email sebenarnya adalah dua masalah terpisah:

1- Validasi format email: Memastikan apakah email tersebut sesuai dengan format dan pola email di RFC 5322 dan apakah TLD benar-benar ada. Daftar semua TLD yang valid dapat ditemukan di sini .

Misalnya, meskipun alamat [email protected]akan melewati regex, itu bukan email yang valid, karena cccbukan domain tingkat atas oleh IANA.

2- Memastikan email itu benar-benar ada: Untuk melakukan ini, satu-satunya pilihan adalah mengirim email kepada pengguna .

Regex untuk memvalidasi alamat email

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

Berikut ini adalah diskusi yang sangat baik tentang penggunaan ekspresi reguler untuk memvalidasi alamat email; " Membandingkan Alamat E-mail yang Memvalidasi Ekspresi Reguler "

Berikut adalah ekspresi teratas saat ini, yaitu JavaScript yang kompatibel, untuk tujuan referensi:

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

Ternyata, itu dia:

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

Diambil dari http://fightingforalostcause.net/misc/2006/compare-email-regex.php pada 1 Oktober '10.

Tetapi, tentu saja, itu mengabaikan internasionalisasi.

Berbeda dengan squirtle , ini adalah solusi yang rumit, tetapi ia melakukan pekerjaan yang sangat baik untuk memvalidasi email dengan benar:

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

Gunakan seperti ini:

if (isEmail('[email protected]')){ console.log('This is email is valid'); }

Pengetahuan saya tentang ekspresi reguler tidak sebaik itu. Itu sebabnya saya memeriksa sintaks umum dengan ekspresi reguler sederhana terlebih dahulu dan memeriksa opsi yang lebih spesifik dengan fungsi lain sesudahnya. Ini mungkin bukan solusi teknis terbaik, tapi dengan cara ini saya lebih fleksibel dan lebih cepat.

Kesalahan paling umum yang saya temui adalah spasi (terutama di awal dan akhir) dan terkadang titik ganda.

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>

Saya sedang mencari Regex di JS yang melewati semua kasus uji Alamat Email:

• [email protected] Email yang valid

• [email protected] Email berisi titik di bidang alamat

• [email protected] Email berisi titik dengan subdomain

• [email protected] Tanda plus dianggap karakter yang valid

• [email protected] Domain adalah alamat IP yang valid

• email@[192.0.2.123] Braket persegi di sekitar alamat IP dianggap valid

• “email”@example.com Kutipan di sekitar email dianggap valid

• [email protected] Digit dalam alamat valid

• [email protected] Tanda hubung dalam nama domain valid

• [email protected] Garis bawah di bidang alamat valid

• [email protected] .name adalah nama Domain Top Level yang valid

• [email protected]Dot di Top Level Domain name juga dianggap valid (menggunakan co.jpseperti contoh di sini)

• [email protected] Tanda hubung di bidang alamat valid

Di sini kita pergi:

http://regexr.com/3f07j

ATAU regex:

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

Ekspresi reguler yang disediakan oleh Microsoft dalam ASP.NET MVC adalah

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

Yang saya posting di sini kalau-kalau itu cacat - meskipun selalu sempurna untuk kebutuhan saya.