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?
How can I validate an email address in JavaScript?
Asked Answered
@Alex The reason I added this comment is that the suggested regex in the accepted answer will not allow existing live email addresses which is a bad start for a customer, and the really big problem is that even IF the address was accepted it still does not say if it works. The only way to reliably verify that a supplied email is a working valid email is to send a mail with a verification link. So, if your use case does not demand that you verify the email, just do a minimal test for @, otherwise use a verification email. Regex will only provide bad user experience. –
Stradivari
@David Mårtensson I added a + on your thoughts. However I do think that a verification email-link thing also can be bad user experience. One that can make you lose a customer. –
Hying
@Hying Sure, but what is the purpose of a regex validation when you will not know if its a valid email anyway. If you do not want to intrude on the customer with a validation link just do the most simple validation <something> at <something> and leave it at that. It will ensure that the customer at least added something that might be an email, anything more it mostly a waste of code until you get to actually validating. You could possibly check if the domain exists with a dns lookup. –
Stradivari
@DavidMårtensson A customer that mistypes one character in her e-mail will have it regexp validated where it still is wrong. The result will be: no communication possible. To me that is the worst user experience one can imagine. A validation confirmation will engage the user in a conversation which shows respect and genuine interest in customers needs. –
Disincentive
Very similar: How can I validate an email address using a regular expression? –
Rouge
If this question is to stay open it needs to remove "validation", otherwise it should to closed. –
Searcy
@Disincentive I agree that regex helps only to check the standard email format, but it will not confirm entered email address is valid or reachable. This problem is addressed by a few real-time email validation tools. You might need to check clearout.io/integrations/real-time-javascript-email-validation. It even helps to suggest the mistyped email address. –
Psychoneurosis
Does this answer your question? How can I validate an email address using a regular expression? –
Ineffectual
I have to admit, I don't understand why there's some much validation going on when you can't predict if the user made a basic type using the valid characters anyway. Just a check for @ and at least one dot is enough at the start. –
Activism
Using regular expressions is probably the best way of validating an email address in JavaScript. View a bunch of tests on JSFiddle taken from Chromium.
const validateEmail = (email) => {
return String(email)
.toLowerCase()
.match(
/^(([^<>()[\]\\.,;:\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,}))$/
);
};
The following is an example of a regular expression that accepts unicode.
const re =
/^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
Keep in mind that one should not rely on JavaScript validation alone, as JavaScript can be easily disabled by the client. Furthermore, it is important to validate on the server side.
The following snippet of code is an example of JavaScript validating an email address on the client side.
const validateEmail = (email) => {
return email.match(
/^(([^<>()[\]\\.,;:\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,}))$/
);
};
const 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 invalid.');
$result.css('color', 'red');
}
return false;
}
$('#email').on('input', validate);<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<label for="email">Enter email address</label>
<input id="email" type="email">
<p id="result"></p> This regex eliminates valid, in-use emails. Do not use. Google for "RFC822" or "RFC2822" to get a proper regex. –
Hypercorrect
This doesn't even accept the examples in RFC 822. Some simple cases it doesn't match a\@[email protected], a(b)@c.com. See the RFC for more. Here's a regex that won't reject any valid addresses [^@]+@[^@]+\.[^@]+ and protects against common errors. –
Mantooth
You cannot validate email addresses, period. The only one who can validate an email address is the provider of the email address. For example, this answer says these email addresses:
%[email protected], "%2"@gmail.com, "a..b"@gmail.com, "a_b"@gmail.com, [email protected], [email protected] , [email protected] are all valid, but Gmail will never allow any of these email addresses. 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. –
Panjabi @KevinFegan let's be realistic: you would not be using JavaScript to confirm whether an e-mail is authentic. I see this validation as perfectly reasonable when a user signs up. You probably do not want to bother sending verification e-mails to addresses that cannot possibly exist. Some might also have outbound e-mail limits, making it north worth it to send e-mails to
email@localhost, i don't have an email or any other funny user inputs. –
Menado [email protected] - showing is valid which should not –
Intensity
@KevinFegan You can't validate an email address, but you can recognise obviously invalid ones. Basically anything that will stop your outgoing mail server from even attempting to send the message. –
Potable
This kind of email [email protected] is not validated by the regex from the answer. I've tested this one and it worked: ^[\w.]+@[a-z]+.\w{2,3}$ –
Maestas
@lasmini Gomes this regex is hopelessly naive. brian@li is a valid email address. also [email protected] is also valid. Also [email protected] is also valid. And is use A LOT by testers because the +123 is ignored by gmail. –
Cleanup
this is invalid
sean.o'[email protected] and your code couldn't verify that, It says valid email. –
Buckjumper Invalidates valid emails, such as [email protected] –
Christie
@GautamParmar, actually [email protected] is valid. If you have a gmail account, test it (add a + before @ in yours). –
Folk
function validateEmail(email) { // Regular expression pattern for email validation const pattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/; return pattern.test(email); } // Test the function const email = "[email protected]"; if (validateEmail(email)) { console.log("Email is valid."); } else { console.log("Email is not valid."); } –
Earthlight
I've slightly modified Jaymon's answer for people who want really simple validation in the form of:
[email protected]
The regular expression:
/^\S+@\S+\.\S+$/
To prevent matching multiple @ signs:
/^[^\s@]+@[^\s@]+\.[^\s@]+$/
The above regexes match the whole string, remove the leading and ^ and trailing $ if you want to match anywhere in the string. The example below matches anywhere in the string.
If you do want to match the whole sring, you may want to trim() the string first.
Example JavaScript function:
function validateEmail(email) {
var re = /\S+@\S+\.\S+/;
return re.test(email);
}
console.log(validateEmail('my email is [email protected]')); // true
console.log(validateEmail('my email is anystring@anystring .any')); // false You can implement something 20x as long that might cause problems for a few users and might not be valid in the future, or you can grab ImmortalFirefly's version to make sure they at least put in the effort to make it look real. Depending on your application it may be more likely to come across someone will get mad because you don't accept their unconventional email, rather than someone who causes problems by entering email addresses that don't really exist (which they can do anyways by entering a 100% valid RFC2822 email address but using an unregistered username or domain). Upvoted! –
Abecedarian
@ImmortalFirefly, the regex you provided will actually match
name@[email protected]. Try pasting your line into a JavaScript console. I believe your intention was to match only the entire text, which would require the beginning of text '^' and end of text '$' operators. The one I'm using is /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test('name@[email protected]') –
Lancer The second regexp does not require a top-level domain, i.e. it accepts
user@domain. But AFAIK this is actually a valid e-mail address, although uncommon. The first regexp requires a TLD, so it doesn't cover these types of addresses. –
Meatiness Emails can contain multiple
@ signs (as comments), also an email doesn't have to contain a period. –
Miki @Miki is this also the reason why an email will be valid after you input an @ sign without having any periods after? –
Romaineromains
@JoseG. Yes. E.g.
http://ai is someone's valid domain, so they could use e.g. a@ai as their email. –
Miki 2 issues: Is
[^\s@] no string followed by @? Why do you use \s and \S? Is it related to whitespaces? –
Roselynroseman @Roselynroseman
[^\s@] means "neither a whitespace character nor @". [xyz] means any one of x, y or z, and [^xyz] means any one character except x, y or z. \s means "any whitespace character". \S means "any character that is not whitespace". –
Cummine 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't — read 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)\bSo 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
NB: "In actual use today" may have been valid when the code was written, back in 200x. The code will likely remain in use beyond that specific year. (If I had a dime for every "meh, no one will ever use a 4+-letter TLD except those specific ones" I had to fix, I could corner the world's copper and nickel market ;)) –
Towards
Note that this doesn't catch some valid email addresses, like these emoji ones: mailoji.com –
Barrel
@Toastrackenigma if someone is using an emoji email doesn't deserve to subscribe to my website. As easy as that. –
Placatory
@ChristianVincenzoTraina the last one rejects my e-mail address on a .rocks domain. if this stops me from your newsletter then maybe it's good for me that I don't get Ignorant Daily to my inbox, but a list of services stopping me from using this domain includes: country-wide public transport system, an airline, medical services, ... –
Anastatius
@Anastatius the last one is just unmaintainable. The number of top-level domains exploded since 2009 –
Placatory
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:
^\S+@\S+$
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
/^\S+@\S+\.\S+$/
+1 as sending email and seeing what happens is the only real sure way to validate an email address , theres no need to do more than a simple regex match. –
Profligate
But it won't accept "Mohit Atray"@gmail.com because it contains space character. Maybe we should just use /^\S.*@\S+$/ regex. –
Posology
That's still not valid. Spaces are permitted in the local-part as long as they are properly escaped (in double quotes). –
Hypercorrect
@RandalSchwartz your comment regarding whitespaces before @ is already written by mohit I think. –
Roselynroseman
How to add
{2,6} to make sure the string after the period is between 2 and 6 chars long? –
Bewilderment 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.
@Profligate -- a "regex invalid" address is almost always valid, because whatever regex you use to validate an email address is almost certainly wrong and will exclude valid email addresses. An email address is
name_part@domain_part and practically anything, including an @, is valid in the name_part; The address foo@[email protected] is legal, although it must be escaped as foo\@bar@machine..... Once the email reaches the domain e.g. 'example.com' that domain can route the mail "locally" so "strange" usernames and hostnames can exist. –
Mariettamariette HTML5 itself has email validation. If your browser supports HTML5 then you can use the following code.
<form>
<label>Email Address
<input type="email" placeholder="[email protected]" required>
</label>
<input type="submit">
</form>
jsFiddle link
From the HTML5 spec:
A valid e-mail address is a string that matches the
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-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
this is good, but the problem with this is that it must be inside a
form tag and submitted by a submit input, which not everyone has the luxury of doing. Also, you can't really style the error message. –
Histoplasmosis At first I found this answer useful, but I tried with some invalid email address and the regex said there were valid... by example :
bar@domain (extension is missing), A@b@[email protected] (multiple @) and so on (cf en.wikipedia.org/wiki/Email_address#Examples). I found a nice regex here: emailregex.com –
Anastasia @ThomasChampion Multiple "@" IS valid. First point is valid though. –
Larhondalari
@Larhondalari Multiple
@ is valid only if the extra "@" appear in username part and is wrapped in double quote. It seems that also the second point (missing extension) is not valid anymore since 2013 (icann.org/en/announcements/details/…), but yes it depends, I guess someone could consider extension optional. Finally, I choose the module address from joi: joi.dev/module/address/api/?v=4.1.0#emailisvalidemail-options to validate email addresss in my app. –
Anastasia This is wrong, you can change the markup from the inspector and bypass the validation. It should be done only for the ux, but its not enough on its own –
Davisson
I have found this to be the best solution:
/^[^\s@]+@[^\s@]+\.[^\s@]+$/
It allows the following formats:
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)
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.
This will pass the email "asd@asd..". Shouldn't the TLD be at least 2 characters, and not a dot? –
Tiaratibbetts
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 http://jsfiddle.net/boldewyn/2b6d5/. 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.
This should be the accepted answer by a long shot. Let browser vendors with on staff regex gurus maintain massively complicated regexes for email addresses. Your average frontend dev building a form for collecting email does not often have time to master verbose regex. Yes you have to rely on the regex the vendor provides, but if you need something more complex, do it on the server and or send an actual email and check the response –
Edelmiraedelson
This is the almost perfect solution. Only little thing that should be added is a check for empty field. HTML5 'email' type accepts an empty string as a valid input. –
Yttrium
That’s what the
input.required = true; line should take care of ;-) –
Crusted HTML5 'email' type accepts an empty string incase the field is not requierd. But if user decide to enter the email, it need to be valide. –
Oto
I might repeat myself, but have you noticed the
input.required = true; line? –
Crusted Also worth thinking about: It's robust against future changes, as it doesn't hard-code the actual regex. I like this aspect. –
Schleswig
I like this solution, but it sill has some cases where it returns
false instead of true. For example: email@[123.123.123.123], "email"@example.com, much.”more\ unusual”@example.com, very.unusual.”@”[email protected], very.”(),:;<>[]”.VERY.”very@\\ "very”[email protected] –
Adams Yes, that’s because the HTML 5 spec hard-codes the regex for e-mail address validation to the 99.9% subset of RFC 2822, that is in actual use. But agreed, if you have special requirements (e.g. intranet or legacy addresses), then this solution might not cut the mustard for you. –
Crusted
I like this solution the most, but I have just noticed that
sdf@sd is validated as a correct email... –
Germander @PhilippMochine : because
sdf@sd is a valid email address : dotless domain has some specific uses where you can practically validate who can access devices that can send emails. It's not because the ICANN strongly discourages the continuation of dotless domains that the entire world must upgrade their systems with no exceptions. Like a knive, it's not because it can hurt you will prohibit it everywhere. Again, to validate an email, send one and see what happens, don't use a regex; or use a regex and accept some custommers won't stay. The point is discouraged doesn't mean invalid. –
Cunctation What @KarlStephen said. Think of a web app for an intranet application. A browser rejecting e-mail addresses like
user@localhost would be worse than useless. It would actively hinder the correct fill-out of the form. –
Crusted This solution does work stackoverflow.com/questions/73799704/…, checkValidity fails for empty email string as well "a@b" email format –
Allimportant
It would only fail, if the field is not required. In my answer I set it to be required, hence
checkValidity() catches empty inputs. This was discussed above already. And the a@b case was discussed, too, namely in the very comment above yours. I’m totally unsure, what then the point of your comment is. Sorry. –
Crusted JavaScript can match a regular expression:
emailAddress.match( / some_regex /);
Here's an RFC22 regular expression for emails:
^((?>[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)>)$
@Kato: It uses some incompatible extensions, including
(?> to stop backtracking and (?<angle><)…(?(angle)>) to avoid providing a lengthy |. –
Alcheringa The
match method returns an array, the test method, which returns a boolean, would be better for this situation. –
Baugh All email addresses contain an 'at' (i.e. @) symbol. Test that necessary condition:
email.includes('@')
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.
what if there will be more than one '@' symbol? other restricted symbols? This validation cannot be trusted... –
Elmer
is a@b valid email ? –
Nguyetni
Its better than most, yes you could have more than one @ with this, but that could also be a valid email like "@"@mydomain.jskd or elldffs(this is @ comment)@mydomain.kjfdij. Both are syntactically valid emails –
Stradivari
@Nguyetni Yes It is. –
Miki
@Elmer If you're using string-level validation to determine whether you can "trust" the email entered, you're already doing it wrong. Using it for anything other than catching mistakes is a lost cause, and most mistakes that don't get caught by this are going to be something that no regex can catch anyway because they'll probably still look like a valid email. –
Joacima
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: https://www.npmjs.com/package/email-addresses.
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);
}
Explanation:
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.
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);
}
IDN addresses are not validated (info@üpöü.com) –
Frosty
'a@a' returns valid: jsfiddle.net/pmiranda/guoyh4dv –
Dame
@Dame That is a valid email address. –
Miki
@Miki it has not top-level domain (separated by periods) datatracker.ietf.org/doc/html/rfc3696 –
Dame
@Dame E.g.
http://ai is someone's valid domain, so they could use e.g. a@ai as their email. –
Miki Agreed with @Miki – this is a valid address –
Nakada
This was stolen from 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;}
Do this:
^([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])?)$
It's based on RFC 2822
Test it at https://regex101.com/r/857lzc/1
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:
[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?
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]') );
Note:
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: Are email addresses case sensitive?
[email protected] - showing is valid which should not –
Intensity
@GautamParmar gmail and others ignore symbols; mail sent to [email protected] would end up in [email protected]'s email inbox. –
Templas
I'm really looking forward to solve this problem. So I modified email validation regular expression above
Original
/^(([^<>()\[\]\\.,;:\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,}))$/Modified
/^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+[^<>()\.,;:\s@\"]{2,})$/
to pass the examples in Wikipedia Email Address.
And you can see the result in here.
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.
This one is easiest solution, we can also use external library like email validator to makes things easier, as mentioned here qawithexperts.com/article/javascript/… –
Whittaker
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...
This allows the entry of so many invalid email addresses it is useless advice. –
Pinkney
Wikipedia standard mail syntax :
https://en.wikipedia.org/wiki/Email_address#Examples https://fr.wikipedia.org/wiki/Adresse_%C3%A9lectronique#Syntaxe_exacte
Function :
function validMail(mail)
{
return /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+([^<>()\.,;:\s@\"]{2,}|[\d\.]+))$/.test(mail);
}
Valid emails :
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 emails :
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
Show this test : https://regex101.com/r/LHJ9gU/1
This address "abc@example" shall return false, but it return true. The wiki page mentioned that: "it must match the requirements for a hostname" en.wikipedia.org/wiki/Email_address#Domain –
Favin
abc.def@mail return true :( –
Prizefight Regex updated! 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);
more info https://git.io/vhEfc
I don't see this as useful at all for much of the world--and a non-trivial audience for many customers. It fails for internationalized usernames and domains. My answer below addresses this using the URL interface which already has support built into most runtimes. ref: https://mcmap.net/q/18752/-how-can-i-validate-an-email-address-in-javascript –
Counterfoil
Maybe make the regex case insensitive. Otherwise it will fail the email address with the uppercase characters. –
Favin
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.
This is how node-validator does it:
/^(?:[\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])\]))$/
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.
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
}
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()
else
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">
</form>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'); }
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
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:
/^[-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
Extremely outdated now. –
Milestone
Regex for validating email address
[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])+
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 @.
Apparently, that's it:
/^([\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
Taken from http://fightingforalostcause.net/misc/2006/compare-email-regex.php on Oct 1 '10.
But, of course, that's ignoring internationalization.
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]',
'pio_pio@#factory.com',
'[email protected]#om',
'[email protected]*om',
'pio^[email protected]'
]
for(const email of emails){
document.write(email+' : '+validEmail(email)+'</br>');
} This answer - and a few others in this thread - do not escape the hyphen. From what I can see (September 2021) this poses no problem in browsers - at least the Webkit variants. However, this might change. At the time of writing PHP7.3 fails to compile the regex without escaping the hyphen. Future proof your browser side code by escaping the hyphen
\- rather than just -. –
Undulant I was looking for a Regex in JS that passes all Email Address test cases:
[email protected]Valid email[email protected]Email contains dot in the address field[email protected]Email contains dot with subdomain[email protected]Plus sign is considered valid character[email protected]Domain is valid IP addressemail@[192.0.2.123]Square bracket around IP address is considered valid“email”@example.comQuotes around email is considered valid[email protected]Digits in address are valid[email protected]Dash in domain name is valid[email protected]Underscore in the address field is valid[email protected].nameis valid Top Level Domain name[email protected]Dot in Top Level Domain name also considered valid (usingco.jpas example here)[email protected]Dash in address field is valid
Here we go :
OR regex:
Regex = /(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@[*[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+]*/
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:
https://www.npmjs.com/package/email-validator
//NodeJs
const validator = require("email-validator");
validator.validate("[email protected]"); // true
//TypeScript/JavaScript
import * as EmailValidator from 'email-validator';
EmailValidator.validate("[email protected]"); // true
It's not the answer to the question, but it helped me and saved my time. This email-validator package seem to help round about half a million other (downloads) per week. So worth to mention and deserves some upvotes. –
Saintsimonianism
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.
This will fail for emails ending in a comment containing a @, for example " [email protected] (this is @ comment)" which is a valid email –
Stradivari
The regular expression provided by Microsoft within ASP.NET MVC is
/^[\w-]+(\.[\w-]+)*@([a-z0-9-]+(\.[a-z0-9-]+)*?\.[a-z]{2,6}|(\d{1,3}\.){3}\d{1,3})(:\d{4})?$/
Which I post here in case it's flawed - though it's always been perfect for my needs.
Doesn't allow +'s in the name part of the email. –
Illuviation
This is a JavaScript translation of the validation suggested by the official Rails guide used by thousands of websites:
/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
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=/!#$%&\'*+-/=?^_`.{|}[email protected]') // 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('invalid.email.com') // false
emailRegex.test('invalid@[email protected]') // false
emailRegex.test('[email protected]') // false
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.
^[a-zA-Z0-9_\-.]+@[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-.]+$
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.
See earlier comment 32 this is good, but the problem with this is that it must be inside a form tag and submitted by a submit input, which not everyone has the luxury of doing. Also, you can't really style the error message. – @Histoplasmosis Nov 12 '11 at 0:08 –
Caulk
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);
}
validateEmail("[email protected]") and validateEmail("[email protected]") both return
false value –
Cobaltous The answer to this question (if you stood back and really thought about it) is that you can't really prevent a user from mistyping their e-mail. Everybody is providing answers that match all the possible letters but nobody has really taken into account the full myriad of characters that can be used.
I refer you to this post and the answer explaining the amount of characters that can be accepted:- Remove invalid characters from e-mail
You can't predict if the letters are the exact way the user intended them to be - which is the most common mistake.. missing a letter out or typing the wrong letter.
Ultimately, no matter what you do in Javascript you will always need your backend script to check if the e-mail was sent successfully too and it will probably have a validation process in place too.
So if you wanted to ensure it was some sort of e-mail address and not their username you only really need to check if there's an @ symbol in there and at least 1 dot and leave all the rest to your backend code.
I have provided a very basic function that demonstrates a delayed check for real-time input and an instant check. Javascript is acting as a first checkpoint to validate the basics to save posting invalid content and annoying the user.
It will always assume the bigger check is at the backend though.
// Very simple, non-library dependent client-side e-mail validator
var emailv = {
// Timeout handler for checkDelay()
to: null,
// The core function that takes a string and validates it
check : function(em){
// Check 1 - The split ensures there's only one @
var c1 = em.split('@').length == 2;
// Check 2 - Must be at least 1 dot too
var c2 = em.indexOf('.') > 0;
// Check 3 - ensures there's always something after a @ or dot
var c3 = !(em.slice(-1)=="@"||em.slice(-1)==".");
return (c1&&c2&&c3); // If all TRUE, great.
},
// Shortcut to quickly check any text input by dom id
checkById : function(inputId){
d = document.getElementById(inputId);
return d?emailv.check(d.value):false;
},
// Check delay for checking on real-time inputs
checkDelay: function(em){
clearTimeout(emailv.to);
emailv.to = setTimeout("emailv.checkDelayP2('"+em+"')",1000);
},
// Part two of Check delay
checkDelayP2: function(em){
if(emailv.check(em)){ // Javascript filter says it seems okay
// For sakes of this demo, pretend we are now making a background
// check to see if e-mail is taken. We tell the user to wait..
emailv.status("Wait..");
// Pretend the background check took 2 seconds
// and said e-mail was available
setTimeout("emailv.status('OK')",2000);
} else {
// Javascript say it's bad, mmmkay?
emailv.status("BAD E-mail");
}
},
status : function(s){
document.getElementById('emailstatus').innerHTML=s;
}
}<h2>1 of 2 - Delayed check</h2>
<ul>
<li><strong>Waits until the user has stopped typing</strong></li>
<li>Useful for when you want to then send e-mail to background database to check if it exists.</li>
<li>Allows them 1 idle second before checking the e-mail address.</li>
</ul>
<input type="text" size="50" id="youremail" name="youremail" onkeyup="emailv.checkDelay(this.value)" onpaste="emailv.checkDelay(this.value)" />
<span id='emailstatus'></span>
<h2>2 of 2 - Instant Check</h2>
<input type="text" size="50" id="youremail2" name="youremail2" />
<a href="Javascript:void(0)" onclick="alert(emailv.checkById('youremail2')?'Seems okay to me':'This e-mail is dodgy')">Check e-mail</a>It would be better to avoid stopping the user entering a valid e-mail than to apply so many restrictions that it becomes complicated.
This is just my opinion!
Here is a function I use for front end email validation. (The Regular Expression came from parsley.js)
<!DOCTYPE html>
<html>
<head>
<title>Our Company</title>
<style>
.form-style {
color: #ccc;
}
</style>
</head>
<body>
<h1>Email Validation Form Example</h1>
<input type="text" name="email" id="emailInput" class="form-style">
<script>
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(event.target.value)) {
document.getElementById("emailInput").style.color = 'black';
}
}
document.getElementById("emailInput").addEventListener("keyup", showEmailValidationState);
</script>
</body>
</html>
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):
/^[a-z0-9](?!.*?[^\na-z0-9]{2})[^\s@]+@[^\s@]+\.[^\s@]+[a-z0-9]$/
Please let me know if this solution works for you. Thanks.
You can use this regex (from w3resource (*not related to W3C)):
/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(emailValue)
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.
This regex fails on '[email protected]' and on '[email protected]'. Do not use. –
Fitzgerald
user+addition is a valid email and longdomain is not necessarily invalid.. –
Syncopate
Exactly, no regex will ever be able to fully verify the format of an email and even if it would, it cannot know domain specific rules, just check for an @ and be done with it or send a verification email. Anything else is just asking for trouble. –
Stradivari
You can also try
var string = "[email protected]"
var exp = /(\w(=?@)\w+\.{1}[a-zA-Z]{2,})/i
alert(exp.test(string))
Use the regular expression:
/^[a-z][a-zA-Z0-9_.]*(\.[a-zA-Z][a-zA-Z0-9_.]*)?@[a-z][a-zA-Z-0-9]*\.[a-z]+(\.[a-z]+)?$/
Example:
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 @ , . , _
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;
}
}
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.
https://developer.mozilla.org/en-US/docs/Web/API/URL
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;
try{
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);
}catch(err){
error = err;
};
return {email, url, same, valid, error};
}
[
'user+this@はじめよう.みんな'
, '[email protected]'
, 'stuff@things'
, '[email protected]'
, 'Jean+Franç[email protected]','هيا@יאללה'
, '试@例子.测试.مثال.آزمایشی'
, 'not@@really'
, 'no'
].forEach(email=>console.log(validEmail(email), email));
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:
/^[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])?)*$/
https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email#Validation
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}))';
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]));
}
<pre>
**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.**
</pre>
*Example of valid email id*
<pre>
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
</pre>
<pre>
xxxx.ourearth.com [@ is not present]
[email protected] [ tld (Top Level domain) can not start with dot "." ]
@you.me.net [ No character before @ ]
[email protected] [ ".b" is not a valid tld ]
[email protected] [ tld can not start with dot "." ]
[email protected] [ an email should not be start with "." ]
xxxxx()*@gmail.com [ here the regular expression only allows character, digit, underscore and dash ]
[email protected] [double dots are not allowed
</pre>
**javascript mail code**
function ValidateEmail(inputText)
{
var mailformat = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
if(inputText.value.match(mailformat))
{
document.form1.text1.focus();
return true;
}
else
{
alert("You have entered an invalid email address!");
document.form1.text1.focus();
return false;
}
}
I might be reading your regexp incorrectly but seems like your only allowing 2-3 chars as top domain? en.wikipedia.org/wiki/List_of_Internet_top-level_domains –
Ayannaaycock
If you're using Closure you can use the built-in goog.format.EmailAddress type:
http://docs.closure-library.googlecode.com/git/class_goog_format_EmailAddress.html
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 http://en.wikipedia.org/wiki/Email_address#Syntax
// TODO(mariakhomenko): we should also be handling i18n domain names as per
// http://en.wikipedia.org/wiki/Internationalized_domain_name
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();
try{
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}"`);
}catch(err){
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.
General email regex (RFC 5322 Official Standard): https://emailregex.com/
JavaScript:
/^(([^<>()\[\]\\.,;:\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,}))$/
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, "a_z%@gmail.com cannot exists but it may exists an address like that through another provider "[email protected].
Why? According to the RFC: https://en.wikipedia.org/wiki/Email_address#RFC_specification.
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. [email protected] is not allowed but "John..Doe"@example.com 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)@example.com and (comment)[email protected] are both equivalent to [email protected].
So, i can own an email address like that:
A__z/J0hn.sm{it!}[email protected]
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: https://www.w3.org/TR/2012/WD-html-markup-20121011/input.email.html
For example, this is an RFC valid email:
"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com
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.
Here's a simple regex that would just check for the basic format of an email e.g., [email protected]:
\S+@\S+\.\S+
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);
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 .co.uk or .com.au, 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
What happens with
[email protected] or phil.h\@\@[email protected]? –
Ruminate There are some complex RegEx written here, that also works.
I tested this one and it works too:
[a-zA-Z0-9._]+[@]+[a-zA-Z0-9]+[.]+[a-zA-Z]{2,6}
Please test this here : http://www.regextester.com/?fam=97334
Hope this helps.
me@localhost fails. –
Ruminate 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
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);
}
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; } }
Yet another perfect regexp for email validation
/^([^\s\@])+\@(([^\s\@\.])+\.)+([^\s\.]{2,})+$/
You can test it here https://regex101.com/r/FV3pUI/2
// Html form call function name at submit button
<form name="form1" action="#">
<input type='text' name='text1'/>
<input type="submit" name="submit" value="Submit"
onclick="ValidateEmail(document.form1.text1)"/>
</from>
// Write the function name ValidateEmail below
<script>
function ValidateEmail(inputText)
{
var mailformat = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/;
if(inputText.value.match(mailformat))
{
alert("Valid email address!");
document.form1.text1.focus();
return true;
}
else
{
alert("You have entered an invalid email address!");
document.form1.text1.focus();
return false;
}
}
</script>
These will work with the top used emails(they match exactly the rules of each one).
Gmail
/^[a-z]((?!\.\.)([a-z\.])){4,28}[a-z0-9]@gmail.com$/i
Yahoo
/^[a-z]((?!\.\.)([\w\.])){3,30}[\w]@yahoo.com$/i
Outlook/Hotmail
/[a-z]((?!\.\.)([\w\.])){0,62}[\w]@(outlook.com|hotmail.com)$/i
Do you know that
\w already includes \d and _? Please, have a look at these sites: TLD list; valid/invalid addresses; regex for RFC822 email address –
Mecke @Mecke that's right, i don't know how i lost it there, i actually used this regex in my database handaling :\, thanks again. –
Pathoneurosis
Gmail's domain is not
@google.com, it's @gmail.com or (for very old accounts) @googlemail.com –
Ostracoderm 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(C.char('@'))
.then(subDns()) //'internal.masala.co.'
.then(C.charNotIn(extendedIllegalCharset).rep()) //'uk'
.eos(); // Must be end of the char stream
}
// [email protected] => extract 'internal.masala.co.'
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('"')
.then(C.notChar('"').rep())
.then(C.char('"'))
}
function allEmail() {
return inQuote().or(C.charNotIn(illegalCharset))
.rep() // repeat (inQuote or anyCharacter)
.then(C.char('@'))
.then(subDns())
.then(C.charNotIn(extendedIllegalCharset).rep())
.eos() // Must be end of the character stream
// Create a structure
.map(function (characters) { return ({ email: characters.join('') }); });
}
'"nicolas""love-quotes"@masala.co.uk' 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.
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!
$(document).ready(function(){
$('#submit').on('click', function(){
var email = $('#email').val();
var pat = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
if (email.match(pat)){
$('#email')
.addClass('input-valid');
return false;
} else {
$('#email')
.addClass('input-error')
.val('');
return false;
}
});
});.input-error {
border: 1px solid red;
color: red;
}
.input-valid {
border: 1px solid green;
color: green;
}<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<form>
<input type="text" id="email" placeholder="[email protected]" class="">
<input type="submit" id="submit" value="Send"/>
</form>I wrote a JavaScript email validator which is fully compatile with PHP's filter_var($value, FILTER_VALIDATE_EMAIL) implementation.
https://github.com/mpyw/FILTER_VALIDATE_EMAIL.js
import validateEmail from 'filter-validate-email'
const value = '...'
const result = validateEmail(value)
is equivalent to:
<?php
$value = '...';
$result = (bool)filter_var($value, FILTER_VALIDATE_EMAIL, FILTER_FLAG_EMAIL_UNICODE);
Here is a solution that works and includes validation/notification fuctionality in a form:
You can run it at this link
JAVASCRIPT
(function() {
'use strict';
window.addEventListener('load', function() {
var form = document.getElementById('needs-validation');
form.addEventListener('submit', function(event) {
if (form.checkValidity() === false) {
event.preventDefault();
}
form.classList.add('was-validated');
event.preventDefault();
}, false);
}, false);
})();
HTML
<p class='title'>
<b>Email validation</b>
<hr size="30px;">
</p>
<br>
<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>
</div>
<div class="row">
<div class="col-12">
<button type="submit"
class="btn btn-default btn-block">Sign up now
</button>
</div>
</div>
</form>
<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>
$("#register").click(function(){
var rea = /^[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])?)*$/;
var Email = $("#Email").val();
var x = rea.test(Email);
if (!x) {
alert('Type Your valid Email');
return false;
}
</script>
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 ('Ё@example.org'))In my case all non-ASCII symbols are prohibited so I have modified the original expression to exclude all characters above U+007F:
/^(([^\u0080-\uffff<>()\[\]\\.,;:\s@"]+(\.[^\u0080-\uffff<>()\[\]\\.,;:\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,}))$/Maybe this will help someone to prevent undesired behaviour.
Nah I think this is an unusual enough use case that it should be its own answer –
Pretense
If you want to use Jquery and want to have modern approach then use JQuery input mask with validation.
http://bseth99.github.io/projects/jquery-ui/5-jquery-masks.html
Demo on how simple jquery input mask is here: http://codepen.io/anon/pen/gpRyBp
Example of simple input mask for date forexample NOT full validation
<input id="date" type="text" placeholder="YYYY-MM-DD"/>
and the script:
$("#date").mask("9999-99-99",{placeholder:"YYYY-MM-DD"});
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');
}
});
}
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()).
controller('ngModel').$validators["email"];
if (isEmail('[email protected]')) {
console.log('valid');
}
But what is this email parser function? Could you post it so that one can use it without angular? –
Bangkok
Yes, if you are going to post a black box answer please dig up the RegEx behind the email parser function and show us what it's using.. –
Emilioemily
// Try this regular Expression by ES6 function
const emailValidate = (email) => {
const regexp= /^[\w.%+-]+@[\w.-]+\.[\w]{2,6}$/;
return regexp.test(email);
}
This is a good example of why people say don't use regex for this. Take just a single piece of this, the assertion that a top-level domain will be 6 letters or less. This rejects just under half of all valid TLDs -- there are currently over 650 TLDs that are more than 6 characters, you can see them all at data.iana.org/TLD/tlds-alpha-by-domain.txt –
Rambow
const validateEmail = (email: string) => { const regex = /^\w+([.-]?\w+)*@\w+([.-]?\w+)*(\.\w{2,3})+$/; return regex.test(email); }; –
Intension
I am using this function
/**
* @param {*} email
*/
export const validateEmail = email => {
return new RegExp(/[\w-]+@([\w-]+\.)+[\w-]+/gm).test(email);
};
Doesn't work for Unicode.
validateEmail('køkø@gmail.com') === false. Forget validation using checks like this. Test for @ and just send the user an email. –
Hundredfold 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) {
console.error(e.message);
}
// Second way.
const email = '[email protected]';
const isValid = EmailValidator.validateKind(email);
if (isValid)
console.log(`Email is valid: ${email}.`);
else
console.log(`Email is invalid: ${email}.`);
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}$/;
\b[a-z][\w\d_\.]+@\w+\.[a-z]{2}[a-z]?\.?[a-z]{,2}\s
It allows:
[email protected]
[email protected]
[email protected]
[email protected]
Nice try: 2 updates here: For match ranges, we provide
{min,max}. A blank min is error, but can have a blank max. I mean [a-z]{,2} is wrong, write as {0,2}. Moreover: your regex shows kamal@_gmail.com as valid which is not! –
Distemper 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, '');
};
}
© 2022 - 2024 — McMap. All rights reserved.