Een snelle en eenvoudige gids voor JavaScript-reguliere expressies

Wilt u JavaScript leren? Ontvang mijn gratis ebook op jshandbook.com

Inleiding tot reguliere expressies

Een reguliere expressie (ook wel regex genoemd) is een snelle manier om met tekstreeksen te werken.

Door een reguliere expressie met een speciale syntaxis te formuleren, kunt u:

  • zoek naar tekst in een string
  • vervang substrings in een string
  • en extraheer informatie uit een string

Bijna elke programmeertaal biedt enige implementatie van reguliere expressies. Er zijn kleine verschillen tussen elke implementatie, maar de algemene concepten zijn bijna overal van toepassing.

Reguliere expressies dateren uit de jaren 1950, toen ze werden geformaliseerd als een conceptueel zoekpatroon voor algoritmen voor stringverwerking.

Geïmplementeerd in UNIX-tools zoals grep, sed en in populaire teksteditors, werden regexes steeds populairder. Ze werden geïntroduceerd in de programmeertaal Perl en later ook in vele andere.

JavaScript is, samen met Perl, een van de programmeertalen die ondersteuning biedt voor reguliere expressies die rechtstreeks in de taal zijn ingebouwd.

Moeilijk maar nuttig

Reguliere expressies kunnen voor de beginner en voor de professionele ontwikkelaar vaak onzin lijken, als je niet de tijd investeert die nodig is om ze te begrijpen.

Cryptische reguliere expressies zijn moeilijk te schrijven, moeilijk te lezen en moeilijk te onderhouden / wijzigen.

Maar soms is een reguliere expressie de enige verstandige manier om wat stringmanipulatie uit te voeren, dus het is een zeer waardevol hulpmiddel in uw zak.

Deze tutorial heeft als doel u op een eenvoudige manier kennis te laten maken met JavaScript-reguliere expressies en u alle informatie te geven om reguliere expressies te lezen en te maken.

De vuistregel is dat eenvoudige reguliere expressies eenvoudig te lezen en te schrijven zijn, terwijl complexe reguliere expressies snel een puinhoop kunnen worden als je de basis niet begrijpt.

Hoe ziet een reguliere expressie eruit?

In JavaScript is een reguliere expressie een object dat op twee manieren kan worden gedefinieerd.

De eerste is door een nieuw RegExp-object te instantiëren met behulp van de constructor:

const re1 = new RegExp ('hey')

De tweede gebruikt de letterlijke vorm van de reguliere expressie:

const re1 = / hey /

Je weet dat JavaScript objectliteralen en arrayliterals heeft? Het heeft ook regexliterals.

In het bovenstaande voorbeeld wordt he het patroon genoemd. In de letterlijke vorm wordt het afgebakend door voorwaartse schuine strepen, terwijl dat bij de objectconstructor niet het geval is.

Dit is het eerste belangrijke verschil tussen de twee vormen, maar we zullen later anderen zien.

Hoe werkt het?

De reguliere expressie die we hierboven als re1 hebben gedefinieerd, is heel eenvoudig. Het doorzoekt de string hey, zonder enige beperking. De tekenreeks kan veel tekst bevatten, en hallo in het midden, en de regex is tevreden. Het kan ook gewoon hé bevatten, en de regex zou ook tevreden zijn.

Dat is vrij simpel.

U kunt de regex testen met RegExp.test (String), die een Boolean retourneert:

re1.test ('hey') // 
re1.test ('blablabla hey blablabla') // 
re1.test ('hij') // 
re1.test ('blablabla') // 

In het bovenstaande voorbeeld hebben we net gecontroleerd of "hey" voldoet aan het reguliere expressiepatroon dat is opgeslagen in re1.

Dit is de eenvoudigste die het kan zijn, maar nu weet je al veel concepten over regexes.

Verankering

/Hallo/

komt overeen met waar het in de string werd geplaatst.

Als je tekenreeksen wilt vergelijken die met he beginnen, gebruik je de operator ^:

/^hey/.test('hey ') // 
/^hey/.test('bla hey ') // 

Als je strings wilt matchen die eindigen op hey, gebruik dan de $ operator:

/hey$/.test('hey ') // 
/hey$/.test('bla hey ') // 
/hey$/.test('hey you ') // 

Combineer die en combineer strings die precies overeenkomen met he, en alleen die string:

/^hey$/.test('hey ') // 

Om een ​​string te matchen die begint met een substring en eindigt met een andere, kunt u. * Gebruiken, die overeenkomt met elk karakter dat 0 of meer keren wordt herhaald:

/^hey.*joe$/.test('hey joe ') // 
/^hey.*joe$/.test('heyjoe ') // 
/^hey.*joe$/.test('hey hoe gaat het joe ') // 
/^hey.*joe$/.test('hey joe! ') // 

Match items in bereiken

In plaats van een bepaalde tekenreeks te matchen, kunt u ervoor kiezen om elk teken in een bereik te matchen, zoals:

/ [a-z] / // a, b, c, ..., x, y, z
/ [A-Z] / // A, B, C, ..., X, Y, Z
/ [a-c] / // a, b, c
/ [0-9] / // 0, 1, 2, 3, ..., 8, 9

Deze regexen komen overeen met tekenreeksen die ten minste een van de tekens in die bereiken bevatten:

/ cialisa-z cialis/.test('a ') // 
/ cialisa-z cialis/.test('1 ') // 
/ cialisa-z cialis/.test('A ') // 
/ cialisa-cBuch/.test('d ') // 
/ cialisa-cBuch/.test('dc ') // 

Bereiken kunnen worden gecombineerd:

/ [A-Za-Z0-9] /
/ CialisA-Za-z0-9Buch/.test('a ') // 
/ CialisA-Za-z0-9Buch/.test('1 ') // 
/ CialisA-Za-z0-9Buch/.test('A ') // 

Meerdere keren overeenkomen met een bereikitem

U kunt controleren of een string slechts één teken in een bereik bevat met behulp van de - char:

/ ^ [A-Za-z0-9] $ /
/^ Delft
/^ cialisA-Za-z0-9Buch$/.test('Ab ') // 

Een patroon ontkennen

Het ^ teken aan het begin van een patroon verankert het aan het begin van een string.

Gebruikt binnen een bereik, ontkent het het, dus:

/[^A-Za-z0-9Buch/.test('a ') // 
/[^A-Za-z0-9Buch/.test('1 ') // 
/[^A-Za-z0-9Buch/.test('A ') // 
/[^A-Za-z0-9Buch/.test('@ ') // 
  • \ d komt overeen met elk cijfer, gelijk aan [0-9]
  • \ D komt overeen met elk teken dat geen cijfer is, gelijk aan [^ 0-9]
  • \ w komt overeen met elk alfanumeriek teken, gelijk aan [A-Za-z0-9]
  • \ W komt overeen met elk niet-alfanumeriek teken, gelijk aan [^ A-Za-z0-9]
  • \ s komt overeen met elk witruimteteken: spaties, tabs, nieuwe regels en Unicode-spaties
  • \ S komt overeen met elk teken dat geen witruimte is
  • \ 0 komt overeen met null
  • \ n komt overeen met een nieuweteken
  • \ t komt overeen met een tabteken
  • \ uXXXX komt overeen met een Unicode-teken met code XXXX (vereist de vlag u)
  • . komt overeen met elk teken dat geen nieuweteken is (bijv. \ n) (tenzij u de vlag s gebruikt, later uitgelegd)
  • [^] komt overeen met elk teken, inclusief newline-tekens. Het is handig voor tekenreeksen met meerdere regels.

Reguliere expressie keuzes

Als u de ene of de andere string wilt zoeken, gebruikt u de | operator.

/hey|ho/.test('hey ') // 
/hey|ho/.test('ho ') // 

quantifiers

Stel dat u deze regex hebt die controleert of een string één cijfer bevat en niets anders:

/ ^ \ D $ /

U kunt de? kwantificeerder om het optioneel te maken, dus nul of één vereist:

/ ^ \ D? $ /

maar wat als u meerdere cijfers wilt matchen?

Je kunt het op 4 manieren doen, met +, *, {n} en {n, m}. Laten we deze een voor een bekijken.

+

Overeenkomen met een of meer (> = 1) items

/ ^ \ D + $ /
/^\d+$/.test('12 ') // 
/^\d+$/.test('14 ') // 
/^\d+$/.test('144343 ') // 
/ ^ \ d + $ /. test ('') // 
/^\d+$/.test('1a ') // 

*

Overeenkomen met 0 of meer (> = 0) items

/ ^ \ D + $ /
/^\d*$/.test('12 ') // 
/^\d*$/.test('14 ') // 
/^\d*$/.test('144343 ') // 
/ ^ \ d * $ /. test ('') // 
/^\d*$/.test('1a ') // 

{N}

Pas precies n items aan

/ ^ \ D {3} $ /
/^\d{3}$/.test('123 ') // 
/^\d{3}$/.test('12 ') // 
/^\d{3}$/.test('1234 ') // 
/^ cialisA-Za-z0-9{{3}$/.test('Abc ') // 

{N, m}

Match tussen n en m tijden:

/ ^ \ D {3,5} $ /
/^\d{3,5}$/.test('123 ') // 
/^\d{3,5}$/.test('1234 ') // 
/^\d{3,5}$/.test('12345 ') // 
/^\d{3,5}$/.test('123456 ') // 

m kan worden weggelaten om een ​​open einde te hebben, dus je hebt minstens n items:

/ ^ \ D {3} $ /
/^\d{3,}$/.test('12 ') // 
/^\d{3,}$/.test('123 ') // 
/^\d{3,}$/.test('12345 ') // 
/^\d{3,}$/.test('123456789 ') // 

Optionele artikelen

Een item volgen met? maakt het optioneel:

/ ^ \ D {3} \ w? $ /
/^\d{3}\w?$/.test('123 ') // 
/^\d{3}\w?$/.test('123a ') // 
/^\d{3}\w?$/.test('123ab ') // 

groepen

Met haakjes kunt u groepen tekens maken: (...)

Dit voorbeeld komt overeen met exact 3 cijfers gevolgd door een of meer alfanumerieke tekens:

/ ^ (\ D {3}) (\ w +) $ /
/^(\d{3})(\w+)$/.test('123 ') // 
/^(\d{3})(\w+)$/.test('123s ') // 
/^(\d{3})(\w+)$/.test('123something ') // 
/^(\d{3})(\w+)$/.test('1234 ') // 

Herhalingstekens achter een groep die haakjes sluiten, verwijzen naar de hele groep:

/ ^ (\ D {2}) + $ /
/^(\d{2})+$/.test('12 ') // 
/^(\d{2})+$/.test('123 ') // 
/^(\d{2})+$/.test('1234 ') // 

Groepen vastleggen

Tot nu toe hebben we gezien hoe tekenreeksen te testen en te controleren of ze een bepaald patroon bevatten.

Een heel cool kenmerk van reguliere expressies is de mogelijkheid om delen van een string vast te leggen en in een array te plaatsen.

U kunt dit doen met behulp van Groups, en in het bijzonder Capturing Groups.

Standaard is een groep een vastleggroep. Nu gebruiken we in plaats van RegExp.test (String), die alleen een Boolean retourneert als aan het patroon is voldaan, String.match (RegExp) of RegExp.exec (String).

Ze zijn exact hetzelfde en retourneren een array met de hele overeenkomende tekenreeks in het eerste item en vervolgens elke overeenkomende groepsinhoud.

Als er geen overeenkomst is, wordt nul geretourneerd:

'123s'.match (/ ^ (\ d {3}) (\ w +) $ /)
// Array ["123s", "123", "s"]
/^(\d{3})(\w+)$/.exec('123s')
// Array ["123s", "123", "s"]
'Hey'.match (/ (hey | ho) /)
// Array ["hey", "hey"]
/(hey|ho)/.exec('hey ')
// Array ["hey", "hey"]
/(hey|ho)/.exec('ha! ')
//nul

Wanneer een groep meerdere keren wordt gematcht, wordt alleen de laatste match in de resultatenmatrix geplaatst:

'123456789'.match (/ (\ d) + /)
// Array ["123456789", "9"]

Optionele groepen

Een vastleggroep kan optioneel worden gemaakt met (...) ?. Als het niet wordt gevonden, bevat de resulterende array-slot ongedefinieerd:

/^(\d{3})(\s)?(\w+)$/.exec('123 s ')
// Array ["123 s", "123", "", "s"]
/^(\d{3})(\s)?(\w+)$/.exec('123s')
// Array ["123s", "123", undefined, "s"]

Referentie overeenkomende groepen

Aan elke overeenkomende groep wordt een nummer toegewezen. $ 1 verwijst naar de eerste, $ 2 naar de tweede, enzovoort. Dit is handig als we het later hebben over het vervangen van delen van een string.

Benoemde vastleggroepen

Dit is een nieuwe ES2018-functie.

Een groep kan worden toegewezen aan een naam, in plaats van alleen een slot toegewezen te krijgen in de resulterende array:

const re = / (?  \ d {4}) - (?  \ d {2}) - (?  \ d {2}) /
const result = re.exec ('2015-01-02')
// result.groups.year === '2015';
// result.groups.month === '01';
// result.groups.day === '02';

Match en exec gebruiken zonder groepen

Er is een verschil tussen het gebruik van match en exec zonder groepen: het eerste item in de array is niet de hele overeenkomende string, maar de match direct:

/hey|ho/.exec('hey ')
// [ "Hallo" ]
/(hey).(ho)/.exec('hey ho ')
// ["hey ho", "hey", "ho"]

Niet-vastleggende groepen

Aangezien standaardgroepen Groepen vastleggen zijn, hebt u een manier nodig om sommige groepen in de resulterende array te negeren. Dit is mogelijk met behulp van Noncapturing Groups, die beginnen met een (?: ...)

'123s'.match (/ ^ (\ d {3}) (: \ s) (\ w +) $ /)
//nul
'123 s'.match (/ ^ (\ d {3}) (?: \ S) (\ w +) $ /)
// Array ["123 s", "123", "s"]

vlaggen

U kunt de volgende vlaggen gebruiken voor elke reguliere expressie:

  • g: komt meerdere keren overeen met het patroon
  • i: maakt de regex-case ongevoelig
  • m: schakelt de multiline-modus in. In deze modus komen ^ en $ overeen met het begin en einde van de hele string. Zonder dit komen ze met meerlijnige tekenreeksen overeen met het begin en einde van elke regel.
  • u: maakt ondersteuning voor unicode mogelijk (geïntroduceerd in ES6 / ES2015)
  • s: (nieuw in ES2018) kort voor een enkele regel, het veroorzaakt de. om ook nieuwe lijntekens te matchen.

Vlaggen kunnen worden gecombineerd en ze worden aan het einde van de string toegevoegd in regex-literals:

/hey/ig.test('HEy ') // 

of als de tweede parameter met RegExp-objectconstructors:

nieuwe RegExp ('hey', 'ig'). test ('HEy') // 

Een regex inspecteren

Bij een regex kunt u de eigenschappen ervan inspecteren:

  • bron de patroonstring
  • multiline true met de m-vlag
  • globaal waar met de g-vlag
  • negeerCase true met de i vlag
  • lastIndex
/^(\w{3})$/i.source // "^ (\\ d {3}) (\\ w +) $"
/^(\w{3})$/i.multiline // false
/^(\w{3})$/i.lastIndex // 0
/^(\w{3})$/i.ignoreCase // true
/^(\w{3})$/i.global // false

Ontsnappen

Deze karakters zijn speciaal:

  • \
  • /
  • []
  • ()
  • {}
  • ?
  • +
  • *
  • |
  • .
  • ^
  • $

Ze zijn speciaal omdat ze controletekens zijn die een betekenis hebben in het reguliere expressiepatroon. Als je ze in het patroon als overeenkomende tekens wilt gebruiken, moet je ze ontsnappen door een backslash voor te stellen:

/ ^ \\ $ /
/ ^ \ ^ $ / // /^\^$/.test('^ ') 
/ ^ \ $$ / // /^\$$/.test('$ ') 

String grenzen

\ b en \ B laten u inspecteren of een string aan het begin of aan het einde van een woord staat:

  • \ b komt overeen met een reeks tekens aan het begin of einde van een woord
  • \ B komt overeen met een set tekens niet aan het begin of einde van een woord

Voorbeeld:

'Ik zag een beer'.match (/ \ bbear /) // Array ["bear"]
'Ik zag een baard'.match (/ \ bbear /) // Array ["bear"]
'Ik zag een baard'.match (/ \ bbear \ b /) // null
'cool_bear'.match (/ \ bbear \ b /) // null

Vervangen met reguliere expressies

We hebben al gezien hoe we kunnen controleren of een string een patroon bevat.

We zagen ook hoe delen van een string naar een array konden worden geëxtraheerd, passend bij een patroon.

Laten we eens kijken hoe we delen van een string kunnen vervangen op basis van een patroon.

Het String-object in JavaScript heeft een methode repla (), die zonder reguliere expressies kan worden gebruikt om een ​​enkele vervanging uit te voeren op een string:

"Hallo wereld!". Vervangen ('wereld', 'hond')
// Hallo hond!
"Mijn hond is een goede hond!". Vervangen ('hond', 'kat')
// Mijn kat is een goede hond!

Deze methode accepteert ook een reguliere expressie als argument:

"Hallo wereld!". Vervangen (/ wereld /, 'hond') // Hallo hond!

Het gebruik van de g-vlag is de enige manier om meerdere exemplaren in een string in vanille JavaScript te vervangen:

"Mijn hond is een goede hond!". Vervangen (/ dog / g, 'cat')
// Mijn kat is een goede kat!

Met groepen kunnen we meer leuke dingen doen, zoals delen van een string verplaatsen:

"Hallo wereld!". Vervangen (/ (\ w +), (\ w +)! /, '$ 2: $ 1 !!!')
// "wereld: Hallo !!!"

In plaats van een string te gebruiken, kunt u een functie gebruiken om zelfs nog mooiere dingen te doen. Het ontvangt een aantal argumenten zoals die geretourneerd door String.match (RegExp) of RegExp.exec (String), met een aantal argumenten die afhankelijk zijn van het aantal groepen:

"Hallo wereld!". Vervangen (/ (\ w +), (\ w +)! /, (MatchedString, eerste, tweede) => {
  console.log (eerst);
  console.log (seconde);
  retourneer `$ {second.toUpperCase ()}: $ {first} !!!`
})
// "WERELD: Hallo !!!"

gulzigheid

Reguliere uitdrukkingen worden standaard standaard hebzuchtig genoemd.

Wat betekent het?

Neem deze regex:

/\$(.+)\s?/

Het wordt verondersteld een dollarbedrag uit een string te extraheren:

/\$(.+)\s?/.exec('Dit kost $ 100 ') [1]
// 100

maar als we meer woorden achter het nummer hebben, wordt het gek:

/\$(.+)\s?/.exec('Dit kost $ 100 en het is minder dan $ 200 ') [1] // 100 en het is minder dan $ 200

Waarom? Omdat de regex na het $ -teken overeenkomt met elk teken met. +, En deze stopt pas wanneer het einde van de tekenreeks is bereikt. Vervolgens eindigt het omdat \ s? maakt de eindruimte optioneel.

Om dit op te lossen, moeten we de regex vertellen dat hij lui is en zo min mogelijk overeenkomsten uitvoert. We kunnen dit doen met behulp van de? symbool achter de kwantificeerder:

/\$(.+?)\s/.exec('Dit kost $ 100 en het is minder dan $ 200 ') [1]
// 100
Ik heb de? Verwijderd na \ s. Anders kwam het alleen overeen met het eerste nummer, omdat de spatie optioneel was

Dus, betekent verschillende dingen op basis van zijn positie, omdat het zowel een kwantificeerder als een luie modusindicator kan zijn.

Lookaheads: combineer een string afhankelijk van wat erop volgt

Gebruik? = Om een ​​string te matchen die wordt gevolgd door een specifieke substring:

/ Roger (? = Waters) /
/ Roger (? = Waters) /. Test ('Roger is my dog') // false
/ Roger (? = Waters) /. Test ('Roger is mijn hond en Roger Waters is een beroemde muzikant')
// true

?! voert de inverse bewerking uit, passend als een string niet wordt gevolgd door een specifieke substring:

/ Roger (?! Waters) /
/ Roger (?! Waters) /. Test ('Roger is my dog') // true
/ Roger (?! Waters) /. Test ('Roger Waters is a famous musician')
// false

Lookbehinds: combineer een string afhankelijk van wat eraan voorafgaat

Dit is een ES2018-functie.

Lookaheads gebruiken het? = Symbool. Lookbehinds gebruiken? <=.

/ (? <= Roger) Waters /
/ (? <= Roger) Waters / .test ('Pink Waters is my dog')
// false
/ (? <= Roger) Waters / .test ('Roger is mijn hond en Roger Waters is een beroemde muzikant')
// true

Een blik achter wordt teniet gedaan met behulp van?

/ (? 
/ (? 
/ (? 

Reguliere expressies en Unicode

De vlag u is verplicht bij het werken met Unicode-strings. Dit is met name van toepassing wanneer u tekens in astrale vlakken (die niet zijn opgenomen in de eerste 1600 Unicode-tekens) moet kunnen verwerken.

Emoji's zijn een goed voorbeeld, maar ze zijn niet de enige.

Als u die vlag niet toevoegt, werkt deze eenvoudige regex die moet overeenkomen met één teken niet, omdat voor JavaScript die emoji intern wordt weergegeven door 2 tekens (zie Unicode in JavaScript):

/^.$/.test('a ') // 
/^.$/.test(' ') // 
/^.$/u.test(' ') // 

Gebruik dus altijd de vlag u.

Unicode verwerkt, net als normale tekens, bereik:

/ cialisa-z cialis/.test('a ') // 
/ Cialis1-9Buch/.test('1 ') // 
/ Cialis-{/u.test(' ') // 
/ Cialis-{/u.test(' ') // 

JavaScript controleert de interne codeweergave, dus < < omdat \ u1F436 <\ u1F43A <\ u1F98A. Bekijk de volledige Emoji-lijst om die codes te krijgen en om de volgorde te achterhalen (tip: de macOS Emoji-kiezer heeft enkele emoji's in een gemengde volgorde, dus reken er niet op).

Unicode-eigenschap ontsnapt

Zoals we hierboven hebben gezien, kunt u in een regelmatig expressiepatroon \ d gebruiken voor elk cijfer, \ s voor elk teken dat geen witruimte is, \ w voor elk alfanumeriek teken, enzovoort.

De eigenschap Unicode ontsnapt is een ES2018-functie die een zeer coole functie introduceert, waarmee dit concept wordt uitgebreid tot alle Unicode-tekens die \ p {} en de ontkenning \ P {} introduceren.

Elk Unicode-teken heeft een set eigenschappen. Script bepaalt bijvoorbeeld de taalfamilie, ASCII is een Booleaanse waarde die geldt voor ASCII-tekens, enzovoort. U kunt deze eigenschap tussen de haakjes van de grafiek plaatsen en de regex zal controleren of dat waar is:

/^\p{ASCII}+$/u.test('abc ') // 
/^\p{ASCII}+$/u.test('ABC@ ') // 
/^\p{ASCII}+$/u.test('ABC ') // 

ASCII_Hex_Digit is een andere booleaanse eigenschap die controleert of de string alleen geldige hexadecimale cijfers bevat:

/^\p{ASCII_Hex_Digit}+$/u.test('0123456789ABCDEF ') //  /^\p{ASCII_Hex_Digit}+$/u.test('h') // 

Er zijn veel andere booleaanse eigenschappen, die u kunt controleren door hun naam in de grafiek haakjes toe te voegen, waaronder hoofdletters, kleine letters, witruimte, alfabetisch, Emoji en meer:

/^\p{Lowercase}$/u.test('h ') // 
/^\p{Uppercase}$/u.test('H ') // 
/^\p{Emoji}+$/u.test('H ') // 
/^\p{Emoji}+$/u.test(' ') // 

Naast deze binaire eigenschappen, kunt u elk van de eigenschappen van het Unicode-teken controleren om overeen te komen met een specifieke waarde. In dit voorbeeld controleer ik of de string in het Griekse of Latijnse alfabet is geschreven:

/^\p{Script=Greek}+$/u.test('ελληνικά ') // 
/^\p{Script=Latin}+$/u.test('hey ') // 

Lees meer over alle eigenschappen die u direct in het voorstel kunt gebruiken.

Voorbeelden

Stel dat een string slechts één nummer heeft dat u moet extraheren, / \ d + / zou dit moeten doen:

'Test 123123329'match (/ \ d + /)
// Array ["123123329"]

Overeenkomen met een e-mailadres

Een simplistische benadering is om niet-spaties te controleren voor en na het @ -teken met behulp van \ S:

/(\S+)@(\S+)\.(\S+)/
/(\S+)@(\S+)\.(\S+)/.exec('copesc@gmail.com ')
// cialis"copesc@gmail.com "," copesc "," gmail "," com "]

Dit is echter een simplistisch voorbeeld, want veel ongeldige e-mails zijn nog steeds tevreden met deze regex.

Tekst vastleggen tussen dubbele aanhalingstekens

Stel dat u een tekenreeks hebt die iets tussen dubbele aanhalingstekens bevat en dat u die inhoud wilt extraheren.

De beste manier om dit te doen is door een opnamegroep te gebruiken, omdat we weten dat de wedstrijd begint en eindigt met ", en we kunnen deze gemakkelijk targeten, maar we willen ook die quotes uit ons resultaat verwijderen.

We zullen vinden wat we nodig hebben in resultaat [1]:

const hello = 'Hallo "mooie bloem"'
const result = /"( cialis^'{*)"/.exec(hello)
// Array ["\" nice flower \ "", "nice flower"]

Plaats de inhoud in een HTML-tag

Neem bijvoorbeeld de inhoud in een span-tag, waarbij een willekeurig aantal argumenten in de tag wordt toegestaan:

/]*>(.*?)<\/span>/
/]*>(.*?)<\/span>/.exec('test ')
// nul
/ ] *> (. *?) <\ / Span> /. Exec ( ' testen )
// [" test ", "test"]
/{*>(.*?)<\/span>/.exec(' test  ')
// [" test ", "test"]
Wilt u JavaScript leren? Ontvang mijn gratis ebook op jshandbook.com