How can I validate an email address in JavaScript?

JavascriptHtmlEmail Validation

Javascript Problem Overview

I'd like to check if the user input is an email address in JavaScript, before sending it to a server or attempting to send an email to it, to prevent the most basic mistyping. How could I achieve this?

Javascript Solutions

Solution 1 - Javascript

Using regular expressions is probably the best way. You can see a bunch of tests here (taken from chromium)

const validateEmail = (email) => {
  return String(email)

Here's the example of a regular expression that accepts unicode:

const re =

But keep in mind that one should not rely only upon JavaScript validation. JavaScript can easily be disabled. This should be validated on the server side as well.

Here's an example of the above in action:

const validateEmail = (email) => {
  return email.match(

const validate = () => {
  const $result = $('#result');
  const email = $('#email').val();

  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;

$('#email').on('input', validate);

And this is the html:

<script src=""></script>

<label for="email">Enter an email address: </label>
<input id="email" />
<h2 id="result"></h2>

Solution 2 - Javascript

I've slightly modified Jaymon's answer for people who want really simple validation in the form of:


The regular expression:


To prevent matching multiple @ signs:


Example JavaScript function:

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

Solution 3 - Javascript

Just for completeness, here you have another RFC 2822 compliant regex

>The official standard is known as RFC 2822. It describes the syntax that valid email addresses must adhere to. You can (but you shouldn'tread on) implement it with this regular expression: > > (?:[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])+)\]) > >(...) We get a more practical implementation of RFC 2822 if we omit the syntax using double quotes and square brackets. It will still match 99.99% of all email addresses in actual use today. > > [a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])? > > A further change you could make is to allow any two-letter country code top level domain, and only specific generic top level domains. This regex filters dummy email addresses like [email protected]. You will need to update it as new top-level domains are added. > > [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 > > So even when following official standards, there are still trade-offs to be made. Don't blindly copy regular expressions from online libraries or discussion forums. Always test them on your own data and with your own applications.

Emphasis mine

Solution 4 - Javascript

Wow, there are lots of complexity here. If all you want to do is just catch the most obvious syntax errors, I would do something like this:


It usually catches the most obvious errors that the user makes and assures that the form is mostly right, which is what JavaScript validation is all about.

EDIT: We can also check for '.' in the email using


Solution 5 - Javascript

There's something you have to understand the second you decide to use a regular expression to validate emails: It's probably not a good idea. Once you have come to terms with that, there are many implementations out there that can get you halfway there, this article sums them up nicely.

In short, however, the only way to be absolutely, positively sure that what the user entered is in fact an email is to actually send an email and see what happens. Other than that it's all just guesses.

Solution 6 - Javascript

HTML5 itself has email validation. If your browser supports HTML5 then you can use the following code.

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

jsFiddle link

From the HTML5 spec:

> A valid e-mail address is a string that matches the email production of the following ABNF, the character set for which is 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 > > > This requirement is a willful violation of RFC 5322, which defines a syntax for e-mail addresses that is simultaneously too strict (before the "@" character), too vague (after the "@" character), and too lax (allowing comments, whitespace characters, and quoted strings in manners unfamiliar to most users) to be of practical use here. > > The following JavaScript- and Perl-compatible regular expression is an implementation of the above definition. > > /^[a-zA-Z0-9.!#$%&'+/=?^_`{|}~-]+@a-zA-Z0-9?(?:.a-zA-Z0-9?)*$/

Solution 7 - Javascript

I have found this to be the best solution:


It allows the following formats:

  1. [email protected]
  2. [email protected]
  3. [email protected]
  4. [email protected]
  5. #!$%&'*+-/=?^_`{}|[email protected]
  6. "()<>[]:,;@\"!#$%&'*+-/=?^_`{}| ~.a"
  7. " " (space between the quotes)
  8. üñîçøðé (Unicode characters in local part)
  9. üñîçøðé@üñîçøðé.com (Unicode characters in domain part)
  10. Pelé (Latin)
  11. δοκιμή@παράδειγμα.δοκιμή (Greek)
  12. 我買@屋企.香港 (Chinese)
  13. 甲斐@黒川.日本 (Japanese)
  14. чебурашка@ящик-с-апельсинами.рф (Cyrillic)

It's clearly versatile and allows the all-important international characters, while still enforcing the basic [email protected] format. It will block spaces which are technically allowed by RFC, but they are so rare that I'm happy to do this.

Solution 8 - Javascript

In modern browsers you can build on top of @Sushil's answer with pure JavaScript and the 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 put together an example in the fiddle Combined with feature detection and the bare-bones validation from Squirtle's Answer, it frees you from the regular expression massacre and does not bork on old browsers.

Solution 9 - Javascript

JavaScript can match a regular expression:

emailAddress.match( / some_regex /);

Here's an RFC22 regular expression for emails:


Solution 10 - Javascript

This is the correct RFC822 version.

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

Solution 11 - Javascript

Correct validation of email address in compliance with the RFCs is not something that can be achieved with a one-liner regular expression. An article with the best solution I've found in PHP is What is a valid email address?. Obviously, it has been ported to Java. I think the function is too complex to be ported and used in JavaScript. JavaScript/node.js port:

A good practice is to validate your data on the client, but double-check the validation on the server. With this in mind, you can simply check whether a string looks like a valid email address on the client and perform the strict check on the server.

Here's the JavaScript function I use to check if a string looks like a valid mail address:

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: Last @ should be before last . since @ cannot be part of server name (as far as I know).

  • lastAtPos > 0: There should be something (the email username) before the last @.

  • str.indexOf('@@') == -1: There should be no @@ in the address. Even if @ appears as the last character in email username, it has to be quoted so " would be between that @ and the last @ in the address.

  • lastDotPos > 2: There should be at least three characters before the last dot, for example [email protected].

  • (str.length - lastDotPos) > 2: There should be enough characters after the last dot to form a two-character domain. I'm not sure if the brackets are necessary.

Solution 12 - Javascript

All email addresses contain an 'at' (i.e. @) symbol. Test that necessary condition:


Or, if you need to support IE/older browsers:

email.indexOf('@') > 0

Don't bother with anything more complicated. Even if you could perfectly determine whether an email is RFC-syntactically valid, that wouldn't tell you whether it belongs to the person who supplied it. That's what really matters.

To test that, send a validation message.

Solution 13 - Javascript

This was stolen from

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;
  {return false;}

Solution 14 - Javascript

Do this:


It's based on RFC 2822

Test it at

Often when storing email addresses in the database I make them lowercase and, in practice, regexs can usually be marked case insensitive. In those cases this is slightly shorter:


Here's an example of it being used in JavaScript (with the case insensitive flag i at 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]') );

Technically some emails can include quotes in the section before the @ symbol with escape characters inside the quotes (so your email user can be obnoxious and contain stuff like @ and "..." as long as it's written in quotes). NOBODY DOES THIS EVER! It's obsolete. But, it IS included in the true RFC 2822 standard and omitted here.

Note 2: The beginning of an email (before the @ sign) can be case sensitive (via the spec). However, anyone with a case-sensitive email is probably used to having issues, and, in practice, case insensitive is a safe assumption. More info:

More info:

Solution 15 - Javascript

I'm really looking forward to solve this problem. So I modified email validation regular expression above

  • Original

  • Modified

to pass the examples in Wikipedia Email Address.

And you can see the result in here.

enter image description here

Solution 16 - Javascript

Simply check out if the entered email address is valid or not using HTML.

<input type="email"/>

There isn't any need to write a function for validation.

Solution 17 - Javascript

You should not use regular expressions to validate an input string to check if it's an email. It's too complicated and would not cover all the cases.

Now since you can only cover 90% of the cases, write something like:

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

You can refine it. For instance, 'aaa@' is valid. But overall you get the gist. And don't get carried away... A simple 90% solution is better than 100% solution that does not work.

The world needs simpler code...

Solution 18 - Javascript

It's hard to get an email validator 100% correct. The only real way to get it correct would be to send a test email to the account. That said, there are a few basic checks that can help make sure that you're getting something reasonable.

Some things to improve:

Instead of new RegExp, just try writing the regexp out like this:

if (reg.test(/@/))

Second, check to make sure that a period comes after the @ sign, and make sure that there are characters between the @s and periods.

Solution 19 - Javascript

This is how node-validator does it:


Solution 20 - Javascript

Wikipedia standard mail syntax :

Function :

function validMail(mail)
	return /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+([^<>()\.,;:\s@\"]{2,}|[\d\.]+))$/.test(mail);

Valids mails :

validMail('') // Return true
validMail('') // Return true
validMail('Abc@') // Return true
validMail('user@localserver') // Return true
validMail('') // Return true
validMail('user+mailbox/') // Return true
validMail('"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"') // Return true
validMail('!#$%&\'*+-/=?^_`.{|}') // Return true
validMail('"()<>[]:,;@\\\"!#$%&\'-/=?^_`{}| ~.a"') // Return true
validMail('"Abc@def"') // Return true
validMail('"Fred Bloggs"') // Return true
validMail('"Joe.\\Blow"') // Return true
validMail('Loïc.Accentué@voilà.fr') // Return true
validMail('" "') // Return true
validMail('user@[IPv6:2001:DB8::1]') // Return true

Invalids mails :

validMail('') // 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

Show this test :

Solution 21 - Javascript

A solution that does not check the existence of the TLD is incomplete.

Almost all answers to this questions suggest using Regex to validate emails addresses. I think Regex is only good for a rudimentary validation. It seems that the checking validation of email addresses is actually two separate problems:

1- Validation of email format: Making sure if the email complies with the format and pattern of emails in RFC 5322 and if the TLD actually exists. A list of all valid TLDs can be found here.

For example, although the address [email protected] will pass the regex, it is not a valid email, because ccc is not a top-level domain by IANA.

2- Making sure the email actually exists: For doing this, the only option is to send the users an email.

Solution 22 - Javascript

Use this code inside your validator function:

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;

Else you can use jQuery. Inside rules define:

eMailId: {
    required: true,
    email: true

Solution 23 - Javascript

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)) {

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

more info

Solution 24 - Javascript

In contrast to squirtle, here is a complex solution, but it does a mighty fine job of validating emails properly:

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

Use like so:

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

Solution 25 - Javascript

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)

function checkbae() {
  if (document.layers || document.getElementById || document.all)
    return checkemail()
    return 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">

Solution 26 - Javascript

My knowledge of regular expressions is not that good. That's why I check the general syntax with a simple regular expression first and check more specific options with other functions afterwards. This may not be not the best technical solution, but this way I'm way more flexible and faster.

The most common errors I've come across are spaces (especially at the beginning and end) and occasionally a double dot.

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

Solution 27 - Javascript

Regex for validating email address


Solution 28 - Javascript

Here is a very good discussion about using regular expressions to validate email addresses; "Comparing E-mail Address Validating Regular Expressions"

Here is the current top expression, that is JavaScript compatible, for reference purposes:


Solution 29 - Javascript

Apparently, that's it:


Taken from on Oct 1 '10.

But, of course, that's ignoring internationalization.

Solution 30 - Javascript

I was looking for a Regex in JS that passes all Email Address test cases:

Here we go :

OR regex:

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

Solution 31 - Javascript

How to write Particular Regular Expression in android or java.

  1. USER_NAME = "^[A-Za-z0-9_-]{min number of character,max number of character}$";

  2. TELEPHONE = "(^\\+)?[0-9()-]*";

  3. TELEPHONE_OPTIONAL = "^($|(^\\+)?[0-9()-]*)$";

  4. EMAIL = "[a-zA-Z0-9_\\.\\+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-\\.]+";

  5. EMAIL_OPTIONAL = "^($|[a-zA-Z0-9_\\.\\+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-\\.]+)$";

  6. WEB_URL = "^($|(http:\\/\\/|https:\\/\\/)?(www.)?([a-zA-Z0-9]+).[a-zA-Z0-9]*.[a-z]{3}.?([a-z]+)?)$";

  7. WEB_URL_YOUTUBE_BE = "https?\\:\\/\\/(www\\.)?youtu(\\.)?be(\\.com)?\\/.*(\\?v=|\\/v\\/)?[a-zA-Z0-9_\\-]+";

  8. POSTAL_ADDRESS = "[a-zA-Z\\d\\s\\-\\,\\#\\.\\+]+";

  9. FIELD_NOT_EMPTY = "[^\\s]*";

  10. PINCODE = "^([0-9]{6})?$";

  11. IFSC_CODE = "^[^\\s]{4}\\d{7}$";

  12. SWIFT_CODE = "^([0-9]{10})?$";

  13. PINCODE = "^([0-9]{6})?$";

Solution 32 - Javascript

Wow, there are a lot of answers that contain slightly different regular expressions. I've tried many that I've got different results and a variety of different issues with all of them.

For UI validation, I'm good with the most basic check of looking for an @ sign. It's important to note, that I always do server-side validation with a standard "validate email" that contains a unique link for the user to confirm their email address.

if (email.indexOf('@') > 0)

I have purposely chosen 0 even with zero-based as it also ensures there is a single character before the @.

Solution 33 - Javascript

In my case, I wanted to avoid ~ and # that's why I have used another solution:

function validEmail(email){
  const regex = /^((?!\.)[\w\-_.]*[^.])(@\w+)(\.\w+(\.\w+)?[^.\W])$/;
  return regex.test(email);

function validEmail(email){
  const regex = /^((?!\.)[\w\-_.]*[^.])(@\w+)(\.\w+(\.\w+)?[^.\W])$/;
  return regex.test(email);

const emails = ['[email protected]','[email protected]','[email protected]','pio_#[email protected]','','[email protected]#om','[email protected]*om','pio^[email protected]']

for(const email of emails){
  document.write(email+' : '+validEmail(email)+'</br>');

Solution 34 - Javascript

Most of the answers here are not linter friendly, it's a mess! Some of them are also outdated! After a lot of time spending, I decided to use an external library named email-validator, install it easily by npm for example and import/require it in your own project:

const validator = require("email-validator");
validator.validate("[email protected]"); // true

import * as EmailValidator from 'email-validator';
EmailValidator.validate("[email protected]"); // true

Solution 35 - Javascript

The regular expression provided by Microsoft within ASP.NET MVC is


Which I post here in case it's flawed - though it's always been perfect for my needs.

Solution 36 - Javascript

Sectrean's solution works great, but it was failing my linter. So I added some escapes:

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

Solution 37 - Javascript

I've mixed @mevius and @Boldewyn Code to Create this ultimate code for email verification using 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,}))$/;
  var input = document.createElement('input');
  input.type = 'email';
  input.value = email;
  return typeof input.checkValidity == 'function' ? input.checkValidity() : re.test(email);

I have shared this code on my blog here.

Solution 38 - Javascript

This is a JavaScript translation of the validation suggested by the official Rails guide used by thousands of websites:


Relatively simple but tests against most common errors.

Tested on a dataset of thousands of emails and it had zero false negatives/positives.

Example usage:

const emailRegex = /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i;

emailRegex.test('[email protected]');    // true

// Multi-word domains
emailRegex.test('[email protected]');  // true
emailRegex.test('[email protected]'); // true

// Valid special characters
emailRegex.test('unusual+but+valid+email1900=/!#$%&\'*+-/=?^_`.{|}') // true

// Trailing dots
emailRegex.test('[email protected].'); // false

// No domain
emailRegex.test('email@example');        // false

// Leading space
emailRegex.test(' [email protected]');   // false

// Trailing space
emailRegex.test('[email protected] ');   // false

// Incorrect domains
emailRegex.test('email@example,com ');   // false

// Other invalid emails
emailRegex.test('')        // false
emailRegex.test('invalid@[email protected]') // false
emailRegex.test('[email protected]')       // false

Solution 39 - Javascript

I prefer to keep it simple and keep my users happy. I also prefer code which is easy to understand. RegEx is not.

function isValidEmail(value) {
    const atLocation = value.lastIndexOf("@");
    const dotLocation = value.lastIndexOf("."); 
    return (
        atLocation > 0 &&
        dotLocation > atLocation + 1 &&
        dotLocation < value.length - 1
  • Get the location of the last "@" and the last "."
  • Make sure the "@" is not the first char (there is something before it)
  • Make sure the "." is after the "@" and that there is at least one char between them
  • Make sure there is at least a single char after the "."

Will this allow invalid email addresses to pass? Sure, but I don't think you need much more for a good user experience that allows you to enable/disable a button, display an error message, etc. You only know for sure that an email address is valid when you attempt to send an email to that address.

Solution 40 - Javascript

Here is a function I use for front end email validation. (The Regular Expression came from parsley.js)

<!DOCTYPE html>
    <title>Our Company</title>
	    .form-style {
		    color: #ccc;
    <h1>Email Validation Form Example</h1>
    <input type="text" name="email" id="emailInput" class="form-style">
	    function validateEmail(emailAddress) {
		    var regularExpression = /^((([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]))){2,6}$/i;
		     return regularExpression.test(emailAddress);

	    function showEmailValidationState(event) {
	        if (validateEmail( {
		        document.getElementById("emailInput").style.color = 'black';
	document.getElementById("emailInput").addEventListener("keyup", showEmailValidationState);

Solution 41 - Javascript

The best practice is to either use HTML5 built-in email tag.

<input type="email" name="email">

or the common email syntax as recognizing @ and . from the string is given below.


> Note that this would still produce invalid email that will still match > the regex, its almost impossible to catch them all but this will > improve the situation a little.

Solution 42 - Javascript

Following Regex validations:

  • No spacial characters before @
  • (-) and (.) should not be together after @ No special characters after @ 2 characters must before @ Email length should be less 128 characters

function validateEmail(email) {
var chrbeforAt = email.substr(0, email.indexOf('@'));
if (!($.trim(email).length > 127)) {
    if (chrbeforAt.length >= 2) {
        var re = /^(([^<>()[\]{}'^?\\.,!|//#%*-+=&;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
		//var re = /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
		return re.test(email);
    } else {
        return false;
} else {
    return false;

Solution 43 - Javascript

Use the regular expression:



function validateEmail(email) {
    var re = /^[a-z][a-zA-Z0-9_.]*(\.[a-zA-Z][a-zA-Z0-9_.]*)?@[a-z][a-zA-Z-0-9]*\.[a-z]+(\.[a-z]+)?$/;
    return re.test(email);

It should allow only @ , . , _

Solution 44 - Javascript

You can also try

var string = "[email protected]"
var exp = /(\w(=?@)\w+\.{1}[a-zA-Z]{2,})/i

Solution 45 - Javascript

You can use this regex (from w3resource (*not related to W3C)):


If you use Node you can use this in the back-end as well as the front-end.

I don't know other back-end languages so I cannot evaluate for other use cases.

Solution 46 - Javascript

If you're using Closure you can use the built-in goog.format.EmailAddress type:


For example:

goog.format.EmailAddress.isValidAddrSpec("[email protected]")

Note that by reading the source (linked above) you can see the comments state that IDN are not supported and that it only aims to cover most addresses:

// This is a fairly naive implementation, but it covers 99% of use cases.
// For more details, see
// TODO(mariakhomenko): we should also be handling i18n domain names as per

Solution 47 - Javascript

**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.**
*Example of valid email id*
<pre> [@ is not present] 
[email protected] [ tld (Top Level domain) can not start with dot "." ] [ No character before @ ]
xxxx123@gmail.b [ ".b" is not a valid tld ]
[email protected] [ tld can not start with dot "." ] [ an email should not be start with "." ]
xxxxx()* [ here the regular expression only allows character, digit, underscore and dash ] [double dots are not allowed
**javascript mail code**

    function ValidateEmail(inputText)
    var mailformat = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
    return true;
    alert("You have entered an invalid email address!");
    return false;

Solution 48 - Javascript

the best one :D (RFC-friendly & no error "too complex") :

function	isMail(mail)
    pattuser = /^([A-Z0-9_%+\-!#$&'*\/=?^`{|}~]+\.?)*[A-Z0-9_%+\-!#$&'*\/=?^`{|}~]+$/i;
    pattdomain = /^([A-Z0-9-]+\.?)*[A-Z0-9-]+(\.[A-Z]{2,9})+$/i;
    tab = mail.split("@");
    if (tab.length != 2)
        return false;
    return (pattuser.test(tab[0]) && pattdomain.test(tab[1]));

Solution 49 - Javascript

If you are using ng-pattern and material this does the job.

vm.validateEmail = '([a-zA-Z0-9_.]{1,})((@[a-zA-Z]{2,})[\\\.]([a-zA-Z]{2}|[a-zA-Z]{3}))';

Solution 50 - Javascript

Here is the recommended Regex pattern for HTML5 on MDN:

>Browsers that support the email input type automatically provide validation to ensure that only text that matches the standard format for Internet e-mail addresses is entered into the input box. Browsers that implement the specification should be using an algorithm equivalent to the following regular expression:


Solution 51 - Javascript

If you get this error: Using regular expressions is security-sensitive.

Then here is what you are looking for. This solution is free from " Regular expression Denial of Service (ReDoS) "

Regex to validate emails without (ReDoS):


Please let me know if this solution works for you. Thanks.

Solution 52 - Javascript

Following Regex validations:

  • No spacial characters before @

  • (-) and (.) should not be together after @

  • No special characters after @ 2 characters must before @

  • Email length should be less 128 characters

      function validateEmail(email) {
      	var chrbeforAt = email.substr(0, email.indexOf('@'));
      	if (!($.trim(email).length > 127)) {
      		if (chrbeforAt.length >= 2) {
      			var re = /^(([^<>()[\]{}'^?\\.,!|//#%*-+=&;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
      			return re.test(email);
      		} else {
      			return false;
      	} else {
      		return false;

Solution 53 - Javascript

Whoever is using @pvl solution and wants it to pass ESLint Prefer-template then here's a version where I used template literals instead of string concatenation.

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

	let reValidEmail = new RegExp(sValidEmail);

	return reValidEmail.test(email);

Solution 54 - Javascript

In nodeJS you can also use validator node module and simply use like that

Install the library with npm install validator

var validator = require('validator');

validator.isEmail('[email protected]'); //=> true 

Solution 55 - Javascript

There are some complex RegEx written here, that also works.

I tested this one and it works too:


Please test this here :

Hope this helps.

Solution 56 - Javascript

How about creating a function which will test any string against emails' pattern using regular expression in JavaScript, as we know email addresses can be quite different in different regions, like in UK and Australia it usually ends up with or, so I tried to cover those as well, also check if the string passed to the function, something like this:

var isEmail = function(str) {
  return typeof str==='string' && /^[\w+\d+._]+\@[\w+\d+_+]+\.[\w+\d+._]{2,8}$/.test(str);

and check if it's email like below:

isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]'); //true
isEmail('[email protected]#sswzazaaaa'); //false
isEmail('[email protected]'); //false

Solution 57 - Javascript

ES6 sample

const validateEmail=(email)=> /^(([^<>()\[\]\\.,;:\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,}))$/.test(email);

Solution 58 - Javascript

Here's a simple regex that would just check for the basic format of an email e.g., [email protected]:


Solution 59 - Javascript

This question is more dificult to answer than seems at first sight.

There were loads of people around the world looking for "the regex to rule them all" but the truth is that there are tones of email providers.

What's the problem? Well, " cannot exists but it may exists an address like that through another provider "[email protected].

Why? According to the RFC:

I'll take an excerpt to facilitate the lecture:

The local-part of the email address may use any of these ASCII characters:

- uppercase and lowercase Latin letters A to Z and a to z;
- digits 0 to 9;
- special characters !#$%&'*+-/=?^_`{|}~;
- dot ., provided that it is not the first or last character unless quoted, and provided also that it does not appear consecutively unless quoted (e.g. is not allowed but "John..Doe" is allowed);[6]
Note that some mail servers wildcard local parts, typically the characters following a plus and less often the characters following a minus, so fred+bah@domain and fred+foo@domain might end up in the same inbox as fred+@domain or even as fred@domain. This can be useful for tagging emails for sorting, see below, and for spam control. Braces { and } are also used in that fashion, although less often.
- space and "(),:;<>@[\] characters are allowed with restrictions (they are only allowed inside a quoted string, as described in the paragraph below, and in addition, a backslash or double-quote must be preceded by a backslash);
- comments are allowed with parentheses at either end of the local-part; e.g. john.smith(comment) and (comment) are both equivalent to

So, i can own an email address like that:


If you try this address i bet it will fail in all or the major part of regex posted all across the net. But remember this address follows the RFC rules so it's fair valid.

Imagine my frustration at not being able to register anywhere checked with those regex!!

The only one who really can validate an email address is the provider of the email address.

How to deal with, so?

It doesn't matter if a user adds a non-valid e-mail in almost all cases. You can rely on HTML 5 input type="email" that is running near to RFC, little chance to fail. HTML5 input type="email" info:

For example, this is an RFC valid email:

"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"

But the html5 validation will tell you that the text before @ must not contain " or () chars for example, which is actually incorrect.

Anyway, you should do this by accepting the email address and sending an email message to that email address, with a code/link the user must visit to confirm validity.

A good practice while doing this is the "enter your e-mail again" input to avoid user typing errors. If this is not enough for you, add a pre-submit modal-window with a title "is this your current e-mail?", then the mail entered by the user inside an h2 tag, you know, to show clearly which e-mail they entered, then a "yes, submit" button.

Solution 60 - Javascript

General email regex (RFC 5322 Official Standard):



Solution 61 - Javascript

Search for the @ sign in the input field.

Solution 62 - Javascript

I add my Regex - i solved for me more little issues like characters from other languages or capital letters


Solution 63 - Javascript

Use the browser/runtime to handle parsing the input by prepending a protocol and pass it to the URL API, trapping any errors and check the resulting username and hostname properties of the result. It will handle basically all transformations and possibilities (punycode of character sets, etc). This only establishes that the input is parsable, not that is valid--that is only possible through checking if the destination machine receives messages for that alias. This provides a close (imo reasonable) guess though, and can be expanded to be more specific and realistic if you're comfortable both maintaining it and also risking invalid rejections. (Note it doesn't attempt to address IPv4 or IPv6 addresses, simply the broad range of customer-facing scenarios using a domain.)

function validEmail(email=''){
    var $0, url, isValid = false, emailPatternInput = /^[^@]{1,64}@[^@]{4,253}$/, emailPatternUrl = /^[^@]{1,64}@[a-z][a-z0-9\.-]{3,252}$/i;
	email = email.trim();
        url = new URL('http://'+email);
        $0 = `${url.username}@${url.hostname}`;
		isValid = emailPatternInput.test( email );
        if(!isValid) throw 'invalid email pattern on input:' + email;
        isValid = emailPatternUrl.test( $0 );
        if(!isValid) throw 'invalid email pattern on url:' + $0;
        console.log(`email looks legit "${email}" checking url-parts: "${$0 === email ? '-SAME-':$0}"`);
        console.error(`probably not an email address: "${email}"`, err);
    return isValid;

['user+this@はじめよう.みんな', 'stuff@things', '[email protected]', 'Jean+Franç[email protected]','هيا@יאללה', '试@例子.测试.مثال.آزمایشی', 'not@@really', 'no'].forEach(email=>console.log(validEmail(email), email));

This is the both the simplest and most generally permissive example I can come up with. Please edit it in cases where it can be made to be more accurate while maintain its simplicity and reasonable generally permissive validity.

Also see MDN URL docs URL, window.URL and Nodejs for URL APIs.

Solution 64 - Javascript

You may try RegExp

function isValidEmail( value ) {
	return /^[\w\-\.\+]+\@[a-zA-Z0-9\.\-]+\.[a-zA-z0-9]{2,5}$/.test( value );

console.log( isValidEmail("[email protected]") )

Solution 65 - Javascript

// Try this regular Expression by ES6 function

const emailValidate = (email) => {
  const regexp= /^[\w.%+-]+@[\w.-]+\.[\w]{2,6}$/;
  return regexp.test(email);

Solution 66 - Javascript

Found the perfect regular expression. It excludes double @, two "." in a row, languages other than English and extra characters at the beginning of the line (".", "-", "!", etc.)

const regexp = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
if (!this.value.match(regexp)) {
// on error, we get into the condition
// this - email input

Solution 67 - Javascript

If you are using AngularJS, just add type="email" to the input element:


In case there is no input element, it can be created dynamically:

var isEmail = $compile('<input ng-model="m" type="email">')($rootScope.$new()).

if (isEmail('[email protected]')) {

Solution 68 - Javascript

I know its not regex but any way...

This is example with node and npm package email-existence this is ultimate checking if email exist and if its in the right form :)

This will ping the email if its responding if it got no response it will return false or else true.

function doesEmailExist(email) {
    var emailExistence = require('email-existence');
    return emailExistence.check(email,function (err,status) {
            if (status) {
                return status;
            else {
                throw new Error('Email does not exist');

Solution 69 - Javascript

If you want to use Jquery and want to have modern approach then use JQuery input mask with validation.

Demo on how simple jquery input mask is here:

Example of simple input mask for date forexample NOT full validation

 <input id="date" type="text" placeholder="YYYY-MM-DD"/>

and the script:


Solution 70 - Javascript

This regexp prevents duplicate domain names like [email protected], it will allow only domain two time like [email protected]. It also does not allow statring from number like [email protected]

regexp: /^([a-zA-Z])+([a-zA-Z0-9_.+-])+\@(([a-zA-Z])+\.+?(com|co|in|org|net|edu|info|gov|vekomy))\.?(com|co|in|org|net|edu|info|gov)?$/,  

All The Best !!!!!

Solution 71 - Javascript

I'd like to add a short note about non-ASCII characters. Rnevius's (and co.) solution is brilliant, but it allows to add Cyrillic, Japanese, Emoticons and other unicode symbols which may be restricted by some servers.

The code below will print true though it contains UTF-8 character Ё.

console.log (/^(([^<>()[]\.,;:\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,}))$/.test ('Ё'))

In my case all non-ASCII symbols are prohibited so I have modified the original expression to exclude all characters above U+007F:


Maybe this will help someone to prevent undesired behaviour.

Solution 72 - Javascript

 <input type="email" class="form-control" required="required" placeholder="Email Address" name="Email" id="Email" autocomplete="Email">
 <button class="btn-1 shadow-0 full-width" type="button" id="register">Register account</button>

Solution 73 - Javascript

Here is a solution that works and includes validation/notification fuctionality in a form:

You can run it at this link


(function() {
  'use strict';

  window.addEventListener('load', function() {
    var form = document.getElementById('needs-validation');
    form.addEventListener('submit', function(event) {
      if (form.checkValidity() === false) {
    }, false);
  }, false);


<p class='title'>
    <b>Email validation</b>
  <hr size="30px;">

<form id="needs-validation" novalidate>
  <p class='form_text'>Try it out!</p>
  <div class="form-row">
    <div class="col-12">
      <input type="email" class="form-control" placeholder="Email Address" required>
        <div class="invalid-feedback">
          Please enter a valid email address.
  <div class="row">
    <div class="col-12">
      <button type="submit" 
          class="btn btn-default btn-block">Sign up now

Solution 74 - Javascript

I wrote a JavaScript email validator which is fully compatile with PHP's filter_var($value, FILTER_VALIDATE_EMAIL) implementation.

import validateEmail from 'filter-validate-email'

const value = '...'
const result = validateEmail(value)

is equivalent to:


$value = '...';
$result = (bool)filter_var($value, FILTER_VALIDATE_EMAIL, FILTER_FLAG_EMAIL_UNICODE);

Solution 75 - Javascript

You cold use and simply do:

var validator = require('validator');

validator.isEmail('[email protected]'); //=> true

Note that this can work on the client.

Solution 76 - Javascript

Here's how I do it. I'm using match() to check for the standard email pattern and I'm adding a class to the input text to notify the user accordingly. Hope that helps!

  $('#submit').on('click', function(){
      var email = $('#email').val();
      var pat = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
      if (email.match(pat)){
        return false;
      } else {
        return false;

.input-error {
  border: 1px solid red;
  color: red;

.input-valid {
  border: 1px solid green;
  color: green;

<script src=""></script>
    <input type="text" id="email" placeholder="[email protected]" class="">
    <input type="submit" id="submit" value="Send"/>

Solution 77 - Javascript

If you want something a human can read and maintain, I would recommend Masala Parser (I'm one of the creators of it).

import {C,Streams} from '@masala/parser'

const illegalCharset = ' @\u00A0\n\t';
const extendedIllegalCharset = illegalCharset + '.';

// Assume '[email protected]'
export function simpleEmail() {

    return C.charNotIn(illegalCharset).rep() // 'nicolas'
        .then(subDns())  //''
        .then(C.charNotIn(extendedIllegalCharset).rep()) //'uk'
        .eos(); // Must be end of the char stream

// [email protected] => extract ''
function  subDns() {
    return C.charNotIn(extendedIllegalCharset).rep().then(C.char('.')).rep()

function validateEmail(email:string) {
    console.log(email + ': ' + (simpleEmail().parse(Streams.ofString(email)).isAccepted()));

validateEmail('[email protected]'); // True
validateEmail('nz@co.'); // False, trailing "."

If you want to accept the ultimate ugly email version, you can add in quotes in the first part:

function inQuote() {
    return C.char('"')

function allEmail() {

    return inQuote().or(C.charNotIn(illegalCharset))
        .rep() // repeat (inQuote or anyCharacter)
        .eos() // Must be end of the character stream
        // Create a structure
        .map(function (characters) { return ({ email: characters.join('') }); });

'"nicolas""love-quotes"' is officially valid, but should it be in your system?

At least with Masala, you give yourself a chance to understand it. And so for the next year, colleague.

Solution 78 - Javascript

These will work with the top used emails(they match exactly the rules of each one).




Solution 79 - Javascript

     // Html form call function name at submit button

    <form name="form1" action="#"> 
    <input type='text' name='text1'/>
    <input type="submit" name="submit" value="Submit" 

    // Write the function name ValidateEmail below

     function ValidateEmail(inputText)
  var mailformat = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/;
    alert("Valid email address!");
    return true;
    alert("You have entered an invalid email address!");
    return false;

Solution 80 - Javascript

Yet another perfect regexp for email validation


You can test it here

Solution 81 - Javascript

One of my coworker shared this regex with me. I like it a lot.

function isValidEmailAddress (email) {
    var validEmail = false;
    if (email) {
        email = email.trim().toLowerCase();
        var pattern = /^[\w-']+(\.[\w-']+)*@([a-zA-Z0-9]+[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*?\.[a-zA-Z]{2,6}|(\d{1,3}\.){3}\d{1,3})(:\d{4})?$/;
        validEmail = pattern.exec(email);
    return validEmail;

if (typeof String.prototype.trim !== 'function') {
    String.prototype.trim = function() {
        return this.replace(/^\s+|\s+$/g, '');

Solution 82 - Javascript


It allows:

Solution 83 - Javascript

If you define your regular expression as a string then all backslashes need to be escaped, so instead of '\w' you should have '\w'.

Alternatively, define it as a regular expression:

var pattern = /^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$/; 

Solution 84 - Javascript

Now ReactNative Version 0.46 Use Below code for email Validation.

 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,}))$/;
     if (re.test(email)) {
     } else {
       alert('email: ' + "Please enter valid emailID.")

Solution 85 - Javascript

There is my version of an email validator. This code is done with object-oriented programming and realized as a class with static methods. You will find two versions of the validators: strict(EmailValidator.validate) and kind(EmailValidator.validateKind).

The first throws an error if an email is invalid and returns email otherwise. The second returns Boolean value that says if an email is valid. I prefer the strict version in most of the cases.

export class EmailValidator {
     * @param {string} email
     * @return {string}
     * @throws {Error}
    static validate(email) {
        email = this.prepareEmail(email);

        const isValid = this.validateKind(email);

        if (isValid)
            return email;

        throw new Error(`Got invalid email: ${email}.`);

     * @param {string} email
     * @return {boolean}
    static validateKind(email) {
        email = this.prepareEmail(email);

        const regex = this.getRegex();

        return regex.test(email);

     * @return {RegExp}
     * @private
    static getRegex() {
        return /^(([^<>()\[\]\\.,;:\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,}))$/;

     * @param {string} email
     * @return {string}
     * @private
    static prepareEmail(email) {
        return String(email).toLowerCase();

To validate an email you can follow these ways:

// First way.

try {
    EmailValidator.validate('[email protected]');
} catch (e) {
// Second way.

const email = '[email protected]';
const isValid = EmailValidator.validateKind(email);

if (isValid)
    console.log(`Email is valid: ${email}.`);
    console.log(`Email is invalid: ${email}.`);

Solution 86 - Javascript

I am using this function

 * @param {*} email
export const validateEmail = email => {
	return new RegExp(/[\w-]+@([\w-]+\.)+[\w-]+/gm).test(email);

Solution 87 - Javascript

for email validation you can create your custom function and use regex syntax for validate email:

function validateEmail(email){
        var reg = /^([A-Za-z0-9_\-\.])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/;
       //your custom code here to check your email address 

Solution 88 - Javascript

This works well for a simple email regex:


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

To test:

const emailRegex = /^[^@ ]+@[^@ ]+\.[^@ ]+$/
const result1 = emailRegex.test('[email protected]')
console.log(result1) // true
const result2 = emailRegex.test('hel@[email protected]')
console.log(result2) // false

Solution 89 - Javascript

Use the URL interface in JavaScript to parse the address in the minimum practical expected format user@host then check that it looks reasonable. Next send a message to it and see if that works (for example require the recipient validate a one-time token via the address). Note that this handles punycode, internationalization, as shown in the samples below.

an example with simple tests:

function validEmail(input=''){
    const emailPatternInput = /^[^@]{1,64}@[^@]{4,253}$/, emailPatternUrl = /^[^@]{1,64}@[a-z][a-z0-9\.-]{3,252}$/i;
    let email, url, valid = false, error, same = false;
        email = input.trim();
        // handles punycode, etc using browser's own maintained implementation
        url = new URL('http://'+email);
        let urlderived = `${url.username}@${url.hostname}`;
        same = urlderived === email;
        valid = emailPatternInput.test( email );
        if(!valid) throw new Error('invalid email pattern on input:' + email);
        valid = emailPatternUrl.test( urlderived );
        if(!valid) throw new Error('invalid email pattern on url:' + urlderived);
        error = err;
    return {email, url, same, valid, error};

, '[email protected]'
, 'stuff@things'
, '[email protected]'
, 'Jean+Franç[email protected]','هيا@יאללה'
, '试@例子.测试.مثال.آزمایشی'
, 'not@@really'
, 'no'
].forEach(email=>console.log(validEmail(email), email));

Solution 90 - Javascript

function ValidateEmail(mail) 
  if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
    return (true)
  alert("You have entered an invalid email address!")
  return (false)

Ref URL:

Solution 91 - Javascript

This works for me:

function Email(mail)
 if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
    return (true)
    alert("Invalid email address!")
    return (false)

Solution 92 - Javascript

A shorter answer to your question is: Validating" an e-mail address with a reg-ex is something that any internet based service provider should desist from. The possibilities of kinds of domain names and e-mail addresses have increased so much in terms of variety, any attempt at validation, which is not well thought may end up denying some valid users into your system.

However, there is one good library available in Javascript i.e. "validator.js". It is a popular javascript package for various validations and can be used to validate & normalize email before sending email. It has good compliance when it comes to being inclusive towards IDNs and Internationalized Email addresses.

The longer answer to this can be found below:

There are three RFCs that lay down the foundation for the "Internet Message Format"

  1. RFC 822
  2. RFC 2822 (Supercedes RFC 822)
  3. RFC 5322 (Supercedes RFC 2822)

The RFC 5322, however, defines the e-mail IDs and their naming structure in the most technical manner. That is more suitable laying down the foundation an Internet Standard that liberal enough to allow all the use-cases yet, conservative enough to bind it in some formalism.

However, the e-mail validation requirement from the software developer community, has the following needs -

  • to stave off unwanted spammers
  • to ensure the user does not make inadvertent mistake
  • to ensure that the e-mail ID belongs to the actual person inputting it

They are not exactly interested in implementing a technically all-encompassing definition that allows all the forms (IP addresses, including port IDs and all) of e-mail id. The solution suitable for their use-case is expected to solely ensure that all the legitimate e-mail holders should be able to get through. The definition of ""legitimate"" differes vastly from techical stand-point (RFC 5322 way) to usability stand-point(this solution). The usability aspect of the validation aims to ensure that all the e-mail IDs validated by the validation mechanism belong to actual people, using them for their communication purposes. This, thus introduces another angle to the validation process, ensuring an actually ""in-use"" e-mail ID, a requirement for which RFC-5322 definition is clearly not sufficient.

Thus, on practical grounds, the actual requirements boil down to this -

  1. To ensure some very basic validation checks
  2. To ensure that the inputted e-mail is in use

Second requirement typically involves, sending a standard response seeking e-mail to the inputted e-mail ID and authenticating the user based on the action delineated in the response mechanism. This is the most widely used mechanism to ensure the second requirement of validating an ""in use"" e-mail ID. This does involve round-tripping from the back-end server implementation and is not a straight-forward single-screen implementaion, however, one cannot do away with this.

The first requirement, stems from the need that the developers do not want totally ""non e-mail like"" strings to pass as an e-mail. This typically involves blanks, strings without ""@"" sign or without a domain name. Given the punycode representations of the domain names, if one needs to enable domain validation, they need to engage in full-fledged implementation that ensures a valid domain name. Thus, given the basic nature of requirement in this regard, validating for ""@."" is the only apt way of satisfying the requirement.

A typical regex that can satisfy this requirement is: ^[^@\s]+@[^@\s.]+.[^@\s.]+$ The above regex, follows the standard Perl regular-expression standard, widely followed by majority of the programming languages. The validation statement is: @.

For those who want to go one step deeper into the more relevant implementations, they can follow the following validation methodology. @

For - Follow the guidelines by the ""Universal Acceptance Steering Group"" - UASG-026 - For , you can follow any domain validation methodology using standard libraries, depending on your programming language. For the recent studies on the subject, follow the document UASG-018A - In addition, those who are interested to know the overall process, challenges and issues one may come across while implementing the Internationalized Email Solution, they can also go through the following RFCs: RFC 6530 (Overview and Framework for Internationalized Email), RFC 6531 (SMTP Extension for Internationalized Email), RFC 6532 (Internationalized Email Headers), RFC 6533 (Internationalized Delivery Status and Disposition Notifications), RFC 6855 (IMAP Support for UTF-8), RFC 6856 (Post Office Protocol Version 3 (POP3) Support for UTF-8), RFC 6857 (Post-Delivery Message Downgrading for Internationalized Email Messages), RFC 6858 (Simplified POP and IMAP Downgrading for Internationalized Email)."

Solution 93 - Javascript

The personal_info part contains the following ASCII characters.

  1. Uppercase (A-Z) and lowercase (a-z) English letters. Digits (0-9).

  2. Characters ! # $ % & ' * + - / = ? ^ _ ` { | } ~

  3. Character . ( period, dot or fullstop) provided that it is not the first or last character and it will not come one after the other.

The domain name [for example com, org, net, in, us, info] part contains letters, digits, hyphens, and dots.

 function ValidateEmail(mail) 
 if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(myForm.emailAddr.value))
    return (true)
    alert("You have entered an invalid email address!")
    return (false)

Solution 94 - Javascript

You could also use RegExp:

function validateEmail(str) {
    return new RegExp(/([\w\.\-_]+)?\w+@[\w-_]+(\.\w+){1,}/, 'igm').test(str);

See the Regular Expressions guide on MDN for more info.

Solution 95 - Javascript

Simple suggestion, since i've seen confusion through the answers.

function validaEmail(email){


      return true;


  return false;

Solution 96 - Javascript

Very simple in JavaScript. follow this code.

function validate(){
    var email = document.getElementById('Email');
    var filter = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;

    if (!filter.test(email.value))
        alert('Please Enter the valid email address');
        return false;
        return true;

HTML code for this:

form name="form"
     method="POST" onsubmit="return validate();" >
    <input type="text" placeholder="Enter ur Email Id" id="Email" name="Email" />
    <input type="submit" id="submit" value="save" name="Like" class="button" />

Solution 97 - Javascript

Simple regex for email-Id

 String EMAIL_PATTERN ="^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$";

Solution 98 - Javascript

function validatecontactEmail(email) { 
 if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(email))  
    return (true)  
    return (false)  


Solution 99 - Javascript

W3Schools gives a good simple and efficient script to validate an email:

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;

Note that you will have to remove spaces if there are any though, with something like this:

.replace(/ /g,'')

Source: JavaScript Form Validation

Solution 100 - Javascript

Validation regex for email:

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

if(email=="") {
    window.plugins.toast.showShortBottom( "Please enter the details. ", function(a) {
        console.log('toast success: ' + a);
    }, function(b) { });
} else if(!rex_email.test(email)) {
    window.plugins.toast.showShortBottom( "Please enter the valid email id. ", function(a) {
        console.log('toast success: ' + a);
    }, function(b) { });


All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
Questionpix0rView Question on Stackoverflow
Solution 1 - JavascriptJohn RutherfordView Answer on Stackoverflow
Solution 2 - JavascriptC. LeeView Answer on Stackoverflow
Solution 3 - JavascriptEsteban KüberView Answer on Stackoverflow
Solution 4 - JavascriptJaymonView Answer on Stackoverflow
Solution 5 - JavascriptPaolo BergantinoView Answer on Stackoverflow
Solution 6 - JavascriptAnoopView Answer on Stackoverflow
Solution 7 - JavascriptAndrewView Answer on Stackoverflow
Solution 8 - JavascriptBoldewynView Answer on Stackoverflow
Solution 9 - JavascriptBen ScheirmanView Answer on Stackoverflow
Solution 10 - JavascriptBob van LuijtView Answer on Stackoverflow
Solution 11 - JavascriptMiloš RašićView Answer on Stackoverflow
Solution 12 - JavascriptColonel PanicView Answer on Stackoverflow
Solution 13 - JavascriptAdam McKeeView Answer on Stackoverflow
Solution 14 - JavascriptRyan TaylorView Answer on Stackoverflow
Solution 15 - JavascriptCVE-RICKView Answer on Stackoverflow
Solution 16 - Javascriptuser2496033View Answer on Stackoverflow
Solution 17 - JavascriptZo72View Answer on Stackoverflow
Solution 18 - JavascriptjacobangelView Answer on Stackoverflow
Solution 19 - JavascriptperaView Answer on Stackoverflow
Solution 20 - JavascriptLiberateurView Answer on Stackoverflow
Solution 21 - JavascriptbmanView Answer on Stackoverflow
Solution 22 - JavascriptOrchidView Answer on Stackoverflow
Solution 23 - JavascriptJuan PabloView Answer on Stackoverflow
Solution 24 - JavascriptSteve ChanView Answer on Stackoverflow
Solution 25 - JavascriptTugrulView Answer on Stackoverflow
Solution 26 - JavascriptLinkmichielView Answer on Stackoverflow
Solution 27 - JavascriptPrabhat KaseraView Answer on Stackoverflow
Solution 28 - JavascriptEric SchoonoverView Answer on Stackoverflow
Solution 29 - JavascriptFélix SaparelliView Answer on Stackoverflow
Solution 30 - JavascriptNeginView Answer on Stackoverflow
Solution 31 - JavascriptPrince DholakiyaView Answer on Stackoverflow
Solution 32 - JavascriptendyourifView Answer on Stackoverflow
Solution 33 - JavascriptRenish GotechaView Answer on Stackoverflow
Solution 34 - JavascriptEbrahimView Answer on Stackoverflow
Solution 35 - JavascriptNeil ThompsonView Answer on Stackoverflow
Solution 36 - JavascriptDarren CatoView Answer on Stackoverflow
Solution 37 - JavascriptShubham KumarView Answer on Stackoverflow
Solution 38 - JavascriptSbbsView Answer on Stackoverflow
Solution 39 - Javascriptuser1843640View Answer on Stackoverflow
Solution 40 - Javascriptzeros-and-onesView Answer on Stackoverflow
Solution 41 - JavascriptcyberrspirittView Answer on Stackoverflow
Solution 42 - JavascriptCode SpyView Answer on Stackoverflow
Solution 43 - JavascriptPriyaView Answer on Stackoverflow
Solution 44 - Javascripthmharsh3View Answer on Stackoverflow
Solution 45 - JavascriptMattia RasuloView Answer on Stackoverflow
Solution 46 - JavascriptSimon SteeleView Answer on Stackoverflow
Solution 47 - JavascriptFerrakkem BhuiyanView Answer on Stackoverflow
Solution 48 - JavascriptDestyNovaView Answer on Stackoverflow
Solution 49 - JavascriptKentonbmaxView Answer on Stackoverflow
Solution 50 - JavascriptisapirView Answer on Stackoverflow
Solution 51 - JavascriptJaskaran SinghView Answer on Stackoverflow
Solution 52 - JavascriptCode SpyView Answer on Stackoverflow
Solution 53 - JavascriptchemicView Answer on Stackoverflow
Solution 54 - JavascriptHimanshu TeotiaView Answer on Stackoverflow
Solution 55 - JavascriptAbhay ShiroView Answer on Stackoverflow
Solution 56 - JavascriptAlirezaView Answer on Stackoverflow
Solution 57 - JavascriptBehnam MohammadiView Answer on Stackoverflow
Solution 58 - JavascriptMenelaos KotsollarisView Answer on Stackoverflow
Solution 59 - JavascriptJoelBonetRView Answer on Stackoverflow
Solution 60 - JavascriptAntonioView Answer on Stackoverflow
Solution 61 - JavascriptPaxView Answer on Stackoverflow
Solution 62 - JavascriptIdanView Answer on Stackoverflow
Solution 63 - JavascriptjimmontView Answer on Stackoverflow
Solution 64 - JavascriptRajib ChyView Answer on Stackoverflow
Solution 65 - JavascriptForce BoltView Answer on Stackoverflow
Solution 66 - JavascriptRoman BondarView Answer on Stackoverflow
Solution 67 - JavascriptVitalii FedorenkoView Answer on Stackoverflow
Solution 68 - Javascriptuser2081554View Answer on Stackoverflow
Solution 69 - JavascriptDinesh DevkotaView Answer on Stackoverflow
Solution 70 - JavascriptBrijeshkumarView Answer on Stackoverflow
Solution 71 - JavascripttakatanView Answer on Stackoverflow
Solution 72 - JavascriptMizanur RahamanView Answer on Stackoverflow
Solution 73 - JavascriptaabiroView Answer on Stackoverflow
Solution 74 - JavascriptmpywView Answer on Stackoverflow
Solution 75 - JavascriptranieribtView Answer on Stackoverflow
Solution 76 - JavascriptkarlzafirisView Answer on Stackoverflow
Solution 77 - JavascriptNicolas ZozolView Answer on Stackoverflow
Solution 78 - JavascriptEboubakerView Answer on Stackoverflow
Solution 79 - JavascriptNazmul HaqueView Answer on Stackoverflow
Solution 80 - JavascriptFDiskView Answer on Stackoverflow
Solution 81 - JavascriptYogesh JindalView Answer on Stackoverflow
Solution 82 - Javascriptjaydev thakkarView Answer on Stackoverflow
Solution 83 - JavascriptJangli CoderView Answer on Stackoverflow
Solution 84 - JavascriptKirit ModiView Answer on Stackoverflow
Solution 85 - JavascriptB. BohdanView Answer on Stackoverflow
Solution 86 - JavascriptRaheelView Answer on Stackoverflow
Solution 87 - JavascriptPurvi BarotView Answer on Stackoverflow
Solution 88 - Javascriptdanday74View Answer on Stackoverflow
Solution 89 - JavascriptjimmontView Answer on Stackoverflow
Solution 90 - Javascriptegor518View Answer on Stackoverflow
Solution 91 - JavascriptKavan FatehiView Answer on Stackoverflow
Solution 92 - JavascriptThinkTransView Answer on Stackoverflow
Solution 93 - JavascriptKhaliq IzrailView Answer on Stackoverflow
Solution 94 - JavascripttecnocrataView Answer on Stackoverflow
Solution 95 - JavascriptGuilherme SantanaView Answer on Stackoverflow
Solution 96 - JavascriptSakthi KarthikView Answer on Stackoverflow
Solution 97 - JavascriptVinod RangaView Answer on Stackoverflow
Solution 98 - JavascriptRacoonView Answer on Stackoverflow
Solution 99 - JavascriptCalahadView Answer on Stackoverflow
Solution 100 - JavascriptAnil SinghaniaView Answer on Stackoverflow