Een e-mailadres valideren in JavaScript

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

Antwoord 3, Autoriteit 15%

Alleen voor volledigheid, Hier heb je nog een andere RFC 2822 compliant regex

De officiële standaard staat bekend als RFC 2822 . Het beschrijft de syntaxis waarin geldige e-mailadressen moeten voldoen aan. U kunt (maar u zou niet – lezen op ) Implementeer het met deze reguliere expressie:

(?:[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 krijgen een meer praktische implementatie van RFC 2822 als we de syntaxis laten gebruiken met behulp van dubbele aanhalingstekens en vierkante haakjes. Het komt nog steeds overeen met 99,99% van alle e-mailadressen in het daadwerkelijke gebruik vandaag.

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

Een verdere wijziging die u zou kunnen maken, is het toestaan ​​van een twee-letterig landcode hoogniveau-domein, en alleen specifieke generieke domeinen op het hoogste niveau. Deze regex filters dummy e-mailadressen zoals [email protected]. U zal het moeten bijwerken terwijl nieuwe domeinen op het hoogste niveau worden toegevoegd .

[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

Dus zelfs als je je aan de officiële normen houdt, moeten er nog afwegingen worden gemaakt. Kopieer reguliere expressies niet blindelings uit online bibliotheken of discussieforums. Test ze altijd op uw eigen gegevens en met uw eigen applicaties.

_{Nadruk van mij}

Antwoord 4, autoriteit 8%

Wauw, er is hier veel complexiteit. Als je alleen de meest voor de hand liggende syntaxisfouten wilt opvangen, zou ik zoiets als dit doen:

^\S+@\S+$

Het detecteert meestal de meest voor de hand liggende fouten die de gebruiker maakt en zorgt ervoor dat het formulier grotendeels klopt, en dat is waar JavaScript-validatie om draait.

Antwoord 5, autoriteit 6%

Er is iets dat je moet begrijpen zodra je besluit een reguliere expressie te gebruiken om e-mails te valideren: Het is waarschijnlijk geen goed idee. Als je daarmee in het reine bent gekomen, zijn er veel implementaties die je halverwege kunnen brengen, deze artikel vat ze mooi samen.

Kortom, de enige manier om er absoluut zeker van te zijn dat wat de gebruiker heeft ingevoerd in feite een e-mail is, is door een e-mail te sturen en te kijken wat er gebeurt. Verder zijn het allemaal maar gissingen.

Antwoord 6, autoriteit 4%

HTML5 zelf heeft e-mailvalidatie. Als uw browser HTML5 ondersteunt, kunt u de volgende code gebruiken.

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

jsFiddle-link

Van de HTML5-specificatie:

Een geldig e-mailadresis een tekenreeks die overeenkomt met de email-productie van de volgende ABNF, waarvan de tekenset Unicode is.

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 >

Deze vereiste is een opzettelijke schendingvan RFC 5322, die een syntaxis voor e-mailadressen definieert die tegelijkertijd te strikt (vóór het “@”-teken), te vaag (na het “@”-teken) en te laks is (waarbij opmerkingen, witruimtetekens en aanhalingstekens op onbekende manieren worden toegestaan voor de meeste gebruikers) om hier van praktisch nut te zijn.

De volgende JavaScript- en Perl-compatibele reguliere expressie is een implementatie van de bovenstaande definitie.

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

Antwoord 7, autoriteit 3%

Ik vond dit de beste oplossing:

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

Het staat de volgende formaten toe:

1. [email protected]
2. [email protected]
3. [email protected]
4. [email protected]
9. #!$%&'*+-/=?^_`{}|[email protected]
6. "()[]:,;@\\\"!#$%&'*+-/=?^_`{}| ~.a"@voorbeeld.org
7. " "@example.org (spatie tussen de aanhalingstekens)
8. üñîçøðé@example.com (Unicode-tekens in lokaal gedeelte)
9. üñîçøðé@üñîçøðé.com (Unicode-tekens in domeingedeelte)
10. Pelé@example.com (Latijn)
11. δοκιμή@παράδειγμα.δοκιμή (Grieks)
12. 我買@屋企.香港 (Chinees)
13. 甲斐@黒川.日本 (Japans)
14. чебурашка@ящик-с-апельсинами.рф (Cyrillisch)

Het is duidelijk veelzijdig en laat de allerbelangrijkste internationale karakters toe, terwijl het nog steeds het basistype [email protected] afdwingt. Het blokkeert ruimtes die technisch zijn toegestaan door RFC, maar ze zijn zo zeldzaam dat ik dit graag doe.

Antwoord 8, autoriteit 2%

In moderne browsers kun je voortbouwen op het antwoord van @Sushil met pure JavaScript en de 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);
}

Ik heb een voorbeeld samengesteld in de viool http://jsfiddle.net/boldewyn/2b6d5/. Gecombineerd met functiedetectie en de kale validatie van Squirtle’s Answer, bevrijdt het je van het bloedbad van reguliere expressies en bork je niet op oude browsers.

Antwoord 9

Dit is de juiste RFC822-versie.

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

Antwoord 10

JavaScript kan overeenkomen met een reguliere expressie:

emailAddress.match( / some_regex /);

Hier is een RFC22reguliere expressie voor e-mails:

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

Antwoord 11

Correcte validatie van e-mailadres in overeenstemming met de RFC’s is niet iets dat kan worden bereikt met een one-liner reguliere expressie. Een artikel met de beste oplossing die ik heb gevonden in PHP is Wat is een geldig e-mailadres?. Het is duidelijk geport naar Java. Ik denk dat de functie te complex is om overgezet en gebruikt te worden in JavaScript.JavaScript/node.js port: https://www.npmjs.com/package/email-addresses.

Een goede gewoonte is om uw gegevens op de client te valideren, maar controleer de validatie nogmaals op de server. Met dit in gedachten kunt u eenvoudig controleren of een string op de client lijkt op een geldig e-mailadres en de strikte controle op de server uitvoeren.

Dit is de JavaScript-functie die ik gebruik om te controleren of een string eruitziet als een geldig e-mailadres:

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

Uitleg:

• lastAtPos < lastDotPos: Laatste @moet vóór laatste .aangezien @geen deel kan uitmaken van de servernaam (voor zover ik weet).

• lastAtPos > 0: er moet iets staan (de gebruikersnaam van de e-mail) voor de laatste @.

• str.indexOf('@@') == -1: Er mag geen @@in het adres staan. Zelfs als @als laatste teken in de gebruikersnaam van de e-mail verschijnt, moet dit tussen aanhalingstekens staan zodat "tussen die @en de laatste @in het adres.

• lastDotPos > 2: er moeten ten minste drie tekens voor de laatste punt staan, bijvoorbeeld [email protected].

• (str.length - lastDotPos) > 2: er moeten voldoende tekens achter de laatste punt staan om een domein van twee tekens te vormen. Ik weet niet zeker of de haakjes nodig zijn.

Antwoord 12

Alle e-mailadressen bevatten een ‘at’ (d.w.z. @) symbool. Test die noodzakelijke voorwaarde:

email.indexOf("@") > 0

Doe geen moeite met ingewikkeldere zaken. Zelfs als je perfect zou kunnen bepalen of een e-mail RFC-syntactisch geldig is, zou dat nog niet zeggen of het toebehoort aan de persoon die het heeft aangeleverd. Dat is wat er echt toe doet.

Stuur een validatiebericht om dat te testen.

Antwoord 13

Dit is gestolen van 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;}

Antwoord 14

Doe dit:

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

Het is gebaseerd op RFC 2822

Test het op https://regex101.com/r/857LZC/1

Vaak, bij het opslaan van e-mailadressen in de database, maak ik ze in kleine letters en in de praktijk kunnen regexs meestal gemarkeerd worden opgemaakt. In die gevallen is dit iets korter:

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

Hier is een voorbeeld van het gebruikt in JavaScript (met de Case Ongevoelige Vlag iaan het einde).

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

Opmerking :
Technisch gezien kunnen sommige e-mails citaten opnemen in de sectie vóór de symbool @met escape-tekens in de offertes (zodat uw e-mailgebruiker onaangenaam kan zijn en spullen bevatten zoals @en "..."zolang het in aanhalingstekens is geschreven). Niemand doet dit ooit! Het is verouderd. Maar het is opgenomen in de ware RFC 2822 standaard en hier weggelaten.

Opmerking 2 :
Het begin van een e-mail (vóór het @ -teken) kan hoofdgevoelig zijn (via de specificatie). Iedereen met een hoofdlettergevoelige e-mail is waarschijnlijk gewend aan het hebben van problemen, en in de praktijk is ongevoelig een veilige aanname. Meer info: zijn e-mailadressen hoofdlettergevoelig?

Meer info: http://www.regular-expressions.info/email.html

Antwoord 15

Ik kijk er echt naar uit om dit probleem op te lossen.
Dus heb ik e-mail validatie gewone expressie boven

gewijzigd

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

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

Om de voorbeelden in wikipedia e-mailadres te geven.

en u kunt het resultaat bekijken in hier .

Antwoord 16

Bekijk eenvoudig of het ingevoerde e-mailadres geldig is of niet met HTML.

<input type="email"/>

Er is geen noodzaak om een ​​functie voor validatie te schrijven.

Antwoord 17

U mag geen reguliere uitdrukkingen gebruiken om een ​​invoerreeks te valideren om te controleren of het een e-mail is. Het is te gecompliceerd en zou niet alle gevallen dekken.

Nu, omdat u slechts 90% van de gevallen kunt bedekken, iets wilt schrijven als:

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

U kunt het verfijnen. ‘AAA @’ is bijvoorbeeld geldig. Maar over het algemeen krijg je de gist. En word niet meegesleept … Een eenvoudige 90% -oplossing is beter dan 100% oplossing die niet werkt.

De wereld heeft eenvoudiger code nodig …

Antwoord 18

Het is moeilijk om een ​​e-mailvalidator 100% correct te krijgen. De enige echte manier om het goed te krijgen, zou zijn om een ​​test-e-mail naar het account te sturen. Dat gezegd hebbende, er zijn een paar basiscontroles die kunnen helpen ervoor te zorgen dat u iets redelijk krijgt.

Sommige dingen om te verbeteren:

In plaats van nieuw RegExp, probeer gewoon de RegExpuit te schrijven als volgt:

if (reg.test(/@/))

Ten tweede, controleer om er zeker van te zijn dat een periode na de @tekenen, en zorg ervoor dat er tekens zijn tussen de @s en perioden.

Antwoord 19

Dit is hoe knoop-validator doet het:

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

Antwoord 20

Een oplossing die het bestaan van de TLD niet controleert, is onvolledig.

Bijna alle antwoorden op deze vragen suggereren het gebruik van Regex om e-mailadressen te valideren. Ik denk dat Regex alleen goed is voor een rudimentaire validatie. Het lijkt erop dat het controleren van de validatie van e-mailadressen eigenlijk twee afzonderlijke problemen zijn:

1- Validatie van e-mailformaat:ervoor zorgen dat de e-mail voldoet aan het formaat en patroon van e-mails in RFC 5322 en of de TLD daadwerkelijk bestaat. Een lijst met alle geldige TLD’s is hierte vinden.

Bijvoorbeeld, hoewel het adres [email protected]de regex zal passeren, is het geen geldig e-mailadres, omdat cccgeen topleveldomein is door IANA.

2- Controleren of de e-mail echt bestaat:Hiervoor is de enige optieom de gebruikers een e-mail te sturen.

Antwoord 21

Gebruik deze code in uw validatorfunctie:

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

Anders kun je jQuerygebruiken. Binnen regels definiëren:

eMailId: {
    required: true,
    email: true
}

Antwoord 22

Regex-update 2018! probeer dit

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-versie voltooid

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

meer info https://git.io/vhEfc

Antwoord 23

In tegenstelling tot squirtle, is hier een complexe oplossing, maar het doet geweldig goed werk om e-mails correct te valideren:

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

Gebruik als volgt:

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

Antwoord 24

Regex voor het valideren van e-mailadres

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

Antwoord 25

Hier is een zeer goede discussie over het gebruik van reguliere expressies om e-mailadressen te valideren; “E-mailadres vergelijken met reguliere expressies“

Hier is de huidige bovenste uitdrukking, die JavaScript-compatibel is, voor referentiedoeleinden:

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

Antwoord 26

Blijkbaar is dat het:

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

Genomen van http://fightingforalostcause.net/misc/2006/compare- email-regex.phpop 1 oktober ’10.

Maar dat is natuurlijk het negeren van internationalisering.

Antwoord 27

Mijn kennis van reguliere uitdrukkingenis niet zo goed. Daarom controleer ik eerst de algemene syntaxis met een eenvoudige reguliere expressie en controleer daarna meer specifieke opties met andere functies. Dit is misschien niet de beste technische oplossing, maar op deze manier ben ik veel flexibeler en sneller.

De meest voorkomende fouten die ik ben tegengekomen zijn spaties (vooral aan het begin en einde) en af en toe een dubbele punt.

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

Antwoord 28

<form name="validation" onSubmit="return checkbae()">
    Please input a valid email address:<br />
    <input type="text" size=18 name="emailcheck">
    <input type="submit" value="Submit">
</form>
<script language="JavaScript1.2">
    var testresults
    function checkemail(){
        var str = document.validation.emailcheck.value
        var filter = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i
        if (filter.test(str))
            testresults = true
        else {
            alert("Please input a valid email address!")
            testresults = false
        }
        return (testresults)
    }
</script>
<script>
    function checkbae(){
        if (document.layers || document.getElementById || document.all)
            return checkemail()
        else
            return true
    }
</script>

Antwoord 29

Wikipedia standaard e-mailsyntaxis:

https://en.wikipedia.org/wiki/Email_address#Examples
https://fr.wikipedia.org/wiki/Adresse_%C3%A9lectronique#Syntaxe_exacte

function validMail(mail)
{
    return /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()\.,;\s@\"]+\.{0,1})+([^<>()\.,;:\s@\"]{2,}|[\d\.]+))$/.test(mail);
}
// VALID MAILS
validMail('[email protected]') // Return true
validMail('[email protected].') // Return true
validMail('[email protected]') // Return true
validMail('user@localserver') // Return true
validMail('[email protected]') // Return true
validMail('user+mailbox/[email protected]') // Return true
validMail('"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com') // Return true
validMail('!#$%&\'*+-/=?^_`.{|}[email protected]') // Return true
validMail('"()<>[]:,;@\\\"!#$%&\'-/=?^_`{}| ~.a"@example.org') // Return true
validMail('"Abc@def"@example.com') // Return true
validMail('"Fred Bloggs"@example.com') // Return true
validMail('"Joe.\\Blow"@example.com') // Return true
validMail('Loïc.Accentué@voilà.fr') // Return true
validMail('" "@example.org') // Return true
validMail('user@[IPv6:2001:DB8::1]') // Return true
// INVALID MAILS
validMail('Abc.example.com') // Return false
validMail('A@b@[email protected]') // Return false
validMail('a"b(c)d,e:f;g<h>i[j\k][email protected]') // Return false
validMail('just"not"[email protected]') // Return false
validMail('this is"not\[email protected]') // Return false
validMail('this\ still\"not\\[email protected]') // Return false
validMail('[email protected]') // Return false
validMail('[email protected]') // Return false

Toon deze test: https://regex101.com/r/LHJ9gU/1

Antwoord 30

Ik was op zoek naar een Regex in JS die alle testgevallen voor e-mailadressen doorstaat:

• [email protected]Geldige e-mail

• [email protected]E-mail bevat punt in het adresveld

• [email protected]E-mail bevat punt met subdomein

• [email protected]Plusteken wordt als geldig teken beschouwd

• [email protected]Domein is geldig IP-adres

• email@[192.0.2.123]Vierkante haakjes rond het IP-adres worden als geldig beschouwd

• “email”@example.comCitaten rond e-mail worden als geldig beschouwd

• [email protected]Cijfers in adres zijn geldig

• [email protected]Streepje in domeinnaam is geldig

• [email protected]Underscore in het adresveld is geldig

• [email protected].nameis een geldige Top Level Domeinnaam

• [email protected]Punt in Top Level Domeinnaam wordt ook als geldig beschouwd (hier wordt co.jpals voorbeeld gebruikt)

• [email protected]Streepje in adresveld is geldig

Hier gaan we:

http://regexr.com/3f07j

of regex:

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