Javascript regulære udtryk kontrollerer for et tal. Eksempel: fjernelse af store bogstaver
JavaScript regexp er en objekttype, der bruges til at matche sekvenser af tegn i strenge.
Oprettelse af det første regulære udtryk
Der er to måder at oprette et regulært udtryk på: ved hjælp af et regulært udtryk eller ved hjælp af en regulært udtryksbygger. Hver af dem repræsenterer det samme mønster: symbolet " c", efterfulgt af " -en"og derefter symbolet" t».
// regulært udtryk literal er omgivet af skråstreger (/)
var option1 = /cat/;
// Konstruktor for regulære udtryk
var option2 = new RegExp("kat");
Som en generel regel, hvis det regulære udtryk skal være konstant, hvilket betyder at det ikke ændrer sig, er det bedre at bruge et regulært udtryk bogstaveligt. Hvis det vil ændre sig eller afhænge af andre variabler, er det bedre at bruge en metode med en konstruktør.
RegExp.prototype.test() metode
Kan du huske, da jeg sagde, at regulære udtryk er objekter? Det betyder, at de har en række metoder. Den enkleste metode er JavaScript regexp test som returnerer en boolesk værdi:
Sandt: Strengen indeholder et regulært udtryksmønster.
Falsk: Ingen match fundet.
console.log(/cat/.test(“katten siger miav”));
// højre
console.log(/cat/.test(“hunden siger gø”));
// forkert
Regulært udtryk Basics snydeark
Hemmeligheden ved regulære udtryk er at huske almindelige karakterer og grupper. Jeg anbefaler stærkt at bruge et par timer på skemaet nedenfor og derefter vende tilbage og studere videre.
Symboler
- . – (punktum) matcher ethvert enkelt tegn med undtagelse af linjeskift;
- * – matcher det forrige udtryk, som gentages 0 eller flere gange;
- + – matcher et tidligere udtryk, der gentages 1 eller flere gange;
- ? – det forrige udtryk er valgfrit ( matcher 0 eller 1 gang);
- ^ – svarer til begyndelsen af linjen;
- $ – matcher slutningen af linjen.
Karaktergrupper
- d– matcher ethvert enkelt numerisk tegn.
- w– matcher ethvert tegn (tal, bogstav eller understregning).
- [XYZ]– et sæt tegn. Matcher ethvert enkelt tegn fra sættet angivet i parentes. Du kan også angive tegnintervaller, f.eks. .
- [XYZ]+– matcher et tegn fra et sæt, der gentages en eller flere gange.
- [^A-Z]– inden for et tegnsæt bruges "^" som et negationstegn. I i dette eksempel Mønsteret matcher alt, der ikke er et stort bogstav.
Flag:
Der er fem valgfri flag i JavaScript regexp. De kan bruges hver for sig eller sammen, og placeres efter den afsluttende skråstreg. For eksempel: /[ A-Z]/g. Her vil jeg kun vise to flag.
g– global søgning.
jeg– uafhængig søgning.
Yderligere designs
(x)– indfangning af parenteser. Dette udtryk matcher x og husker det match, så du kan bruge det senere.
(?:x)– ikke-fangende parenteser. Udtrykket matcher x, men husker ikke matchet.
Matcher kun x, hvis det efterfølges af y.
Lad os teste det materiale, vi har studeret
Lad os først teste alt ovenstående. Lad os sige, at vi vil kontrollere en streng for et hvilket som helst tal. For at gøre dette kan du bruge "d"-konstruktionen.
console.log(/d/.test("12-34"));
// højre
Ovenstående kode returnerer sand, hvis der er mindst ét ciffer i strengen. Hvad skal du gøre, hvis du har brug for at kontrollere en streng for overholdelse af formatet? Du kan bruge flere "d"-tegn til at definere formatet:
console.log(/dd-dd/.test("12-34"));
//højre
console.log(/dd-dd/.test("1234"));
//forkert
Hvis du er ligeglad med, hvordan tallene kommer før og efter "-"-tegnet i JavaScript regexp online, kan du bruge "+"-symbolet til at vise, at "d"-mønsteret forekommer en eller flere gange:
console.log(/d+-d+/.test("12-34"));
// højre
console.log(/d+-d+/.test("1-234"));
// højre
console.log(/d+-d+/.test("-34"));
// forkert
For nemheds skyld kan du bruge parenteser til at gruppere udtryk. Lad os sige, at vi har en kat, der miaver, og vi vil tjekke mønsteret " miav"(miav):
console.log(/me+(ow)+w/.test("meeeeowowoww"));
// højre
Lad os nu finde ud af det.
m => match et bogstav 'm';
e + => match bogstavet "e" en eller flere gange;
(ow) + => match bogstaverne "ow" en eller flere gange;
w => matcher bogstavet 'w';
'm' + 'eeee' + 'owowow' + 'w'.
Når operatorer som "+" bruges umiddelbart efter parenteser, påvirker de hele indholdet af parenteserne.
Operatør"? " Det angiver, at det forrige tegn er valgfrit. Som du vil se nedenfor, returnerer begge testtilfælde sand, fordi "s"-tegnene er markeret som valgfrie.
console.log(/cats? siger?/i.test("katten siger miav"));
//højre
console.log(/cats? siger?/i.test("Kattene siger miav"));
//højre
Hvis du vil finde en skråstreg, skal du undslippe den ved at bruge en omvendt skråstreg. Det samme gælder for andre tegn, der har en særlig betydning, såsom spørgsmålstegnet. Her er et JavaScript-regexp-eksempel på, hvordan man leder efter dem:
var slashSearch = ///;
var questionSearch = /?/;
- d er det samme som: hver konstruktion svarer til et digitalt symbol.
- w– dette er det samme som [ A —Za —z 0-9_]: Begge udtryk matcher et enkelt alfanumerisk tegn eller understregning.
Eksempel: tilføjelse af mellemrum til linjer i kamelstil
I dette eksempel er vi virkelig trætte af kamelens skrivestil, og vi har brug for en måde at tilføje mellemrum mellem ordene. Her er et eksempel:
removeCc("camelCase") // => skulle returnere "camel Case"
Der er en simpel løsning ved hjælp af et regulært udtryk. Først skal vi finde alt store bogstaver. Dette kan gøres ved hjælp af et tegnsætopslag og en global modifikator.
Dette matcher tegnet "C" i "camelCase"
Nu, hvordan tilføjer man et mellemrum før "C"?
Vi skal bruge fængslende parenteser! De giver dig mulighed for at finde et match og huske det for at bruge det senere! Brug opfangende parenteser til at huske det store bogstav, du finder:
Du kan få adgang til den registrerede værdi senere på denne måde:
Ovenfor bruger vi $1 for at få adgang til den registrerede værdi. Forresten, hvis vi havde to sæt parenteser, ville vi bruge $1 og $2 til at henvise til de registrerede værdier og tilsvarende for mere fængslende parenteser.
Hvis du har brug for at bruge parenteser, men ikke har brug for at indfange den værdi, kan du bruge ikke-fangende parenteser: (?: x ). I dette tilfælde findes et match til x, men det huskes ikke.
Lad os vende tilbage til den aktuelle opgave. Hvordan implementerer vi indfangningsparenteser? Brug af JavaScript-regexp-erstatningsmetoden! Vi sender "$1" som det andet argument. Det er vigtigt at bruge anførselstegn her.
funktion removeCc(str)(
return str.replace(/()/g, "$1");
}
Lad os se på koden igen. Vi tager fat i det store bogstav og erstatter det med det samme bogstav. Indsæt et mellemrum i anførselstegnene efterfulgt af variablen $1 . Som et resultat får vi et mellemrum efter hvert stort bogstav.
funktion removeCc(str)(
return str.replace(/()/g, " $1");
}
removeCc("camelCase") // "camel Case"
removeCc("helloWorldItIsMe") // "hello World It Is Me"
Eksempel: fjernelse af store bogstaver
Nu har vi en snor med en masse unødvendige store bogstaver. Har du fundet ud af, hvordan du fjerner dem? Først skal vi vælge alle store bogstaver. Derefter søger vi efter et tegnsæt ved hjælp af den globale modifikator:
Vi bruger erstatningsmetoden igen, men hvordan laver vi tegnet med små bogstaver denne gang?
funktion Små bogstaver(str)(
return str.replace(//g, ???);
}
Tip: I metoden replace() kan du angive en funktion som den anden parameter.
Vi vil bruge en pilefunktion for at undgå at fange værdien af det fundne match. Når du bruger en funktion i JavaScript regexp-erstatningsmetoden, kaldes funktionen, efter at der er fundet et match, og resultatet af funktionen bruges som erstatningsstrengen. Endnu bedre, hvis matchningen er global, og der findes flere matches, vil funktionen blive kaldt for hvert match, der findes.
funktion Små bogstaver(str)(
return str.replace(//g, (u) => u.toLowerCase());
}
lowerCase("kameletui") // "kameletui"
lowerCase("hej verden det er mig") // "hej verden det er mig"
Eksempel: konverter det første bogstav til stort
capitalize("kameletui") // => skulle returnere "kameletui"
Lad os bruge funktionen i replace() metoden igen. Denne gang skal vi dog kun lede efter det første tegn i strengen. Husk, at symbolet "^" bruges til dette.
Lad os dvæle ved "^"-symbolet et øjeblik. Husk eksemplet givet tidligere:
console.log(/cat/.test("katten siger miav"));
//højre
Når du tilføjer et "^"-tegn, returnerer funktionen ikke længere sand, fordi ordet "kat" ikke er i begyndelsen af linjen.
Nogle mennesker, når de står over for et problem, tænker: "Åh, jeg vil bruge regulære udtryk." Nu har de to problemer.
Jamie Zawinski
Yuan-Ma sagde: "Det kræver en masse kraft at skære træ på tværs af træets årer. Det kræver meget kode at programmere på tværs af problemstrukturen.
Master Yuan-Ma, "Book of Programming"
Programmeringsværktøjer og -teknikker overlever og spredes på en kaotisk evolutionær måde. Nogle gange er det ikke de smukke og geniale, der overlever, men blot dem, der fungerer godt nok inden for deres felt – for eksempel hvis de integreres i en anden succesfuld teknologi.
I dette kapitel vil vi diskutere et sådant værktøj - regulære udtryk. Dette er en måde at beskrive mønstre i strengdata. De skaber et lille, selvstændigt sprog, der er inkluderet i JavaScript og mange andre sprog og værktøjer.
De almindelige tidsplaner er både meget mærkelige og ekstremt nyttige. Deres syntaks er kryptisk, og deres JavaScript-programmeringsgrænseflade er klodset. Men dette kraftfuldt værktøj til at udforske og behandle strenge. Når du forstår dem, bliver du en mere effektiv programmør.
Oprettelse af et regulært udtryk
Almindelig – objekttype. Det kan oprettes ved at kalde RegExp-konstruktøren eller ved at skrive påkrævet skabelon, omgivet af skråstreger.Var re1 = new RegExp("abc"); var re2 = /abc/;
Begge disse regulære udtryk repræsenterer det samme mønster: tegnet "a" efterfulgt af tegnet "b" efterfulgt af tegnet "c".
Hvis du bruger RegExp-konstruktøren, skrives mønsteret som almindelig streng, så alle regler vedrørende omvendte skråstreg gælder.
Den anden post, hvor mønsteret er mellem skråstreger, håndterer skråstreger anderledes. For det første, da mønsteret ender med en fremad skråstreg, skal vi sætte en baglæns skråstreg før den fremadgående skråstreg, som vi vil inkludere i vores mønster. Derudover omvendt skråstreg, som ikke er en del af specialtegn type \n vil blive bevaret (i stedet for ignoreret, som i strenge), og vil ændre betydningen af mønsteret. Nogle tegn, såsom spørgsmålstegnet eller plus, har en særlig betydning i regulære udtryk, og skal man finde sådan et tegn, skal det også indledes med en omvendt skråstreg.
Var eighteenPlus = /eighteen\+/;
For at vide, hvilke tegn der skal indledes med en skråstreg, skal du lære en liste over alle specialtegn i regulære udtryk. Dette er endnu ikke muligt, så hvis du er i tvivl, skal du blot sætte en skråstreg foran ethvert tegn, der ikke er et bogstav, tal eller mellemrum.
Tjek for kampe
Stamgæster har flere metoder. Den enkleste er test. Hvis du sender den en streng, vil den returnere en boolsk værdi, der angiver, om strengen indeholder en forekomst af det givne mønster.Console.log(/abc/.test("abcde")); // → true console.log(/abc/.test("abxde")); // → falsk
En almindelig sekvens, der kun består af ikke-specielle tegn, er blot en sekvens af disse tegn. Hvis abc er et sted i den linje, vi tester (ikke kun i begyndelsen), vil testen returnere sand.
Leder efter et sæt karakterer
Du kan også finde ud af, om en streng indeholder abc ved at bruge indexOf. Regelmæssige mønstre giver dig mulighed for at gå længere og skabe mere komplekse mønstre.Lad os sige, at vi skal finde et hvilket som helst tal. Når vi sætter et sæt tegn i firkantede parenteser i regulære udtryk, betyder det, at den del af udtrykket matcher ethvert af tegnene i parentes.
Begge udtryk er i linjer, der indeholder et tal.
Console.log(//.test("i 1992")); // → true console.log(//.test("i 1992")); // → sandt
I firkantede parenteser bruges en bindestreg mellem to tegn til at angive en række tegn, hvor rækkefølgen er specificeret af Unicode-kodningen. Tegnene fra 0 til 9 er der bare i en række (koder fra 48 til 57), så det fanger dem alle og matcher et hvilket som helst tal.
Flere tegngrupper har deres egne indbyggede forkortelser.
\d Ethvert tal
\w Alfanumerisk tegn
\s Mellemrumstegn (mellemrum, tabulator, ny linje osv.)
\D ikke et tal
\W er ikke et alfanumerisk tegn
\S er ikke et blanktegn
. ethvert tegn undtagen linjeskift
Således kan du indstille dato- og tidsformatet som 01/30/2003 15:20 med følgende udtryk:
Var dateTime = /\d\d-\d\d-\d\d\d\d \d\d:\d\d/; console.log(dateTime.test("30-01-2003 15:20")); // → true console.log(dateTime.test("30-Jan-2003 15:20")); // → falsk
Ser forfærdeligt ud, gør det ikke? Der er for mange skråstreg, hvilket gør mønsteret svært at forstå. Vi forbedrer det lidt senere.
Omvendt skråstreg kan også bruges i firkantede beslag. For eksempel betyder [\d.] ethvert tal eller punktum. Læg mærke til, at perioden inden for firkantede parenteser mister sin særlige betydning og blot bliver et punktum. Det samme gælder for andre specialtegn, såsom +.
Du kan invertere et sæt tegn - det vil sige, at du skal finde et hvilket som helst tegn undtagen dem, der er i sættet - ved at placere et ^-tegn umiddelbart efter den åbne firkantede parentes.
Var notBinary = /[^01]/; console.log(notBinary.test("1100100010100110")); // → falsk console.log(notBinary.test("1100100010200110")); // → sandt
Gentagende dele af skabelonen
Vi ved, hvordan man finder ét tal. Hvad hvis vi skal finde hele tallet - en sekvens af et eller flere cifre?Hvis du sætter et +-tegn efter noget i den almindelige rækkefølge, vil det betyde, at dette element kan gentages mere end én gang. /\d+/ betyder et eller flere cifre.
Console.log(/"\d+"/.test(""123"")); // → true console.log(/"\d+"/.test("""")); // → falsk console.log(/"\d*"/.test(""123"")); // → true console.log(/"\d*"/.test("""")); // → sandt
Stjernen * har næsten samme betydning, men den tillader, at mønsteret forekommer nul gange. Hvis noget er efterfulgt af en stjerne, så forhindrer det aldrig mønsteret i at være i linjen - det vises bare der nul gange.
Et spørgsmålstegn gør en del af mønsteret valgfrit, hvilket betyder, at det kan forekomme nul eller én gang. I det følgende eksempel kan tegnet u forekomme, men mønsteret matcher, selv når det ikke gør det.
Var nabo = /nabo?r/; console.log(neighbor.test("nabo")); // → true console.log(neighbor.test("nabo")); // → sandt
For at angive det nøjagtige antal gange, et mønster skal forekomme, skal du bruge seler. (4) efter et element betyder, at det skal optræde 4 gange i linjen. Du kan også angive et mellemrum: (2,4) betyder, at elementet skal forekomme mindst 2 og ikke mere end 4 gange.
En anden version af dato- og tidsformatet, hvor dage, måneder og timer på et eller to cifre er tilladt. Og den er også lidt mere læsevenlig.
Var dateTime = /\d(1,2)-\d(1,2)-\d(4) \d(1,2):\d(2)/; console.log(dateTime.test("30-1-2003 8:45")); // → sandt
Du kan bruge åbne mellemrum ved at udelade et af tallene. (,5,) betyder, at mønsteret kan forekomme fra nul til fem gange, og (5,) betyder fra fem eller flere.
Gruppering af underudtryk
For at bruge * eller + operatorerne på flere elementer på én gang, kan du bruge parenteser. Den del af det regulære udtryk, der er omgivet af parenteser, betragtes som et element fra operatørernes synspunkt.Var tegneserieCrying = /boo+(hoo+)+/i; console.log(cartoonCrying.test("Boohoooohoohooo")); // → sandt
Det første og andet plus gælder kun for det andet o'er i bu og ho. Det tredje + refererer til hele gruppen (hoo+), der finder en eller flere sådanne sekvenser.
Bogstavet i i slutningen af udtrykket gør det regulære udtryk ufølsomt for store og små bogstaver - så B matcher b.
Kampe og grupper
Testmetoden er den enkleste metode til at kontrollere regulære udtryk. Den fortæller dig kun, om et match blev fundet eller ej. Stamgæster har også en exec-metode, som returnerer null, hvis intet blev fundet, og ellers returnerer et objekt med information om kampen.Var match = /\d+/.exec("en to 100"); console.log(match); // → ["100"] console.log(match.index); // → 8
Objektet, der returneres af exec, har en index-egenskab, som indeholder nummeret på det tegn, fra hvilket matchet opstod. Generelt ligner objektet et array af strenge, hvor det første element er den streng, der blev tjekket for en match. I vores eksempel vil dette være rækkefølgen af tal, vi ledte efter.
Strenge har en matchmetode, der fungerer på nogenlunde samme måde.
Console.log("en to 100".match(/\d+/)); // → ["100"]
Når et regulært udtryk indeholder underudtryk grupperet i parentes, vises den tekst, der matcher disse grupper, også i arrayet. Det første element er altid et komplet match. Den anden er den del, der matchede den første gruppe (den, hvis parentes opstod først), derefter den anden gruppe, og så videre.
Var quotedText = /"([^"]*)"/; console.log(quotedText.exec("hun sagde "hej"")); // → [""hej"", "hej"]
Når en gruppe slet ikke findes (f.eks. hvis den efterfølges af et spørgsmålstegn), er dens position i arrayet udefineret. Hvis en gruppe matcher flere gange, vil kun den sidste kamp være i arrayet.
Console.log(/bad(ly)?/.exec("bad")); // → ["dårlig", udefineret] console.log(/(\d)+/.exec("123")); // → ["123", "3"]
Grupper er nyttige til at hente dele af strenge. Hvis vi ikke bare vil tjekke, om en streng har en dato, men udtrække den og lave et objekt, der repræsenterer datoen, kan vi sætte talrækkerne i parentes og vælge datoen fra resultatet af exec.
Men først en lille digression, hvor vi lærer den foretrukne måde at gemme dato og klokkeslæt på i JavaScript.
Datotype
JavaScript har standard type objekt for datoer - eller rettere, øjeblikke i tid. Det hedder Dato. Hvis du blot opretter et datoobjekt via ny, får du nuværende dato og tid.Console.log(ny dato()); // → Søn 9. nov. 2014 00:07:57 GMT+0300 (CET)
Du kan også oprette et objekt, der indeholder en given tid
Console.log(ny dato(2015, 9, 21)); // → ons 21. okt 2015 00:00:00 GMT+0300 (CET) console.log(ny dato(2009, 11, 9, 12, 59, 59, 999)); // → ons 09. dec. 2009 12:59:59 GMT+0300 (CET)
JavaScript bruger en konvention, hvor månedstal starter med et nul og dagtal starter med et. Det her er dumt og latterligt. Vær forsigtig.
De sidste fire argumenter (timer, minutter, sekunder og millisekunder) er valgfrie og er sat til nul, hvis de mangler.
Tidsstempler gemmes som antallet af millisekunder, der er gået siden begyndelsen af 1970. For tider før 1970, brug negative tal(dette skyldes Unix-tidskonventionen, der blev skabt omkring det tidspunkt). Datoobjektets getTime-metode returnerer dette tal. Det er naturligt stort.
console.log(ny dato(2013, 11, 19).getTime()); // → 1387407600000 console.log(ny dato(1387407600000)); // → tor 19. dec. 2013 00:00:00 GMT+0100 (CET)
Hvis du giver Dato-konstruktøren ét argument, behandles det som dette antal millisekunder. Du kan få den aktuelle millisekundværdi ved at oprette et Date-objekt og kalde getTime-metoden eller ved at kalde Date.now-funktionen.
Date-objektet har metoderne getFullYear, getMonth, getDate, getHours, getMinutes og getSeconds til at hente dets komponenter. Der er også en getYear-metode, der returnerer en ret ubrugelig tocifret kode som 93 eller 14.
Ved at sætte de relevante dele af skabelonen i parentes, kan vi oprette et datoobjekt direkte fra strengen.
Funktion findDate(string) ( var dateTime = /(\d(1,2))-(\d(1,2))-(\d(4))/; var match = dateTime.exec(string); return new Date(Number(match), Number(match) - 1, Number(match)); ) console.log(findDate("30-1-2003")); // → Tor 30 Jan 2003 00:00:00 GMT+0100 (CET)
Ord- og linjegrænser
Desværre vil findDate lige så gerne udtrække den meningsløse dato 00-1-3000 fra strengen "100-1-30000". Matchen kan forekomme hvor som helst i strengen, så I dette tilfælde det vil simpelthen starte fra det andet tegn og slutte på det næstsidste.Hvis vi skal tvinge matchet til at tage hele strengen, bruger vi ^ og $ tags. ^ matcher begyndelsen af linjen, og $ matcher slutningen. Derfor matcher /^\d+$/ en streng, der kun indeholder et eller flere cifre, /^!/ matcher en streng, der starter med et udråbstegn, og /x^/ matcher ikke nogen streng (der kan ikke være et x).
Hvis vi derimod bare vil sikre os, at datoen starter og slutter på en ordgrænse, bruger vi \b-mærket. En ordgrænse kan være begyndelsen eller slutningen af en linje eller et hvilket som helst sted i en linje, hvor der er et alfanumerisk tegn \w på den ene side og et ikke-alfanumerisk tegn på den anden.
Console.log(/cat/.test("sammenkædning")); // → true console.log(/\bcat\b/.test("sammenkædning")); // → falsk
Bemærk, at grænseetiketten ikke er et symbol. Det er simpelthen en begrænsning, hvilket betyder, at et match kun opstår, hvis en bestemt betingelse er opfyldt.
Skabeloner med valg
Lad os sige, at du skal finde ud af, om teksten ikke kun indeholder et tal, men et tal efterfulgt af gris, ko eller kylling i ental eller flertal.Det ville være muligt at skrive tre regulære udtryk og kontrollere dem et efter et, men der er en bedre måde. Symbol | angiver et valg mellem mønstrene til venstre og til højre for det. Og vi kan sige følgende:
Var animalCount = /\b\d+ (gris|ko|kylling)s?\b/; console.log(animalCount.test("15 grise")); // → true console.log(animalCount.test("15 grisekyllinger")); // → falsk
Parenteser afgrænser den del af mønsteret, som | anvendes på, og mange sådanne operatorer kan placeres efter hinanden for at angive et valg mellem mere end to muligheder.
Søgemaskine
Regulære udtryk kan opfattes som flowcharts. Følgende diagram beskriver et nyligt husdyreksempel.Et udtryk matcher en streng, hvis det er muligt at finde en sti fra venstre side af diagrammet til højre. Vi husker den aktuelle position i linjen, og hver gang vi går gennem rektanglet, tjekker vi, at den del af linjen umiddelbart efter vores position i den passer med indholdet af rektanglet.
Det betyder, at tjek for en match af vores almindelige karakter i strengen "de 3 grise", når du går gennem rutediagrammet, ser sådan ud:
Ved position 4 er der en ordgrænse, og vi passerer det første rektangel
- startende fra 4. position finder vi tallet og går gennem det andet rektangel
- ved position 5 lukker den ene vej tilbage foran det andet rektangel, og den anden går videre til rektanglet med et mellemrum. Vi har et mellemrum, ikke et tal, og vi vælger den anden vej.
- nu er vi på position 6, begyndelsen af "grise", og ved den tredobbelte forgrening af stierne. Der er ingen "ko" eller "kylling" i linjen, men der er "gris", så vi vælger denne vej.
- ved position 9 efter den tredobbelte gaffel omgår den ene sti "s" og går til det sidste ordgrænserektangel, og den anden går gennem "s". Vi har et "s", så vi tager dertil.
- ved position 10 er vi for enden af linjen, og kun ordet grænse kan matche. Enden af linjen betragtes som grænsen, og vi passerer gennem det sidste rektangel. Og nu har vi med succes fundet vores skabelon.
Grundlæggende er den måde, regulære udtryk fungerer på, at algoritmen starter i begyndelsen af strengen og forsøger at finde et match der. I vores tilfælde er der en ordgrænse, så den passerer det første rektangel - men der er intet tal der, så det snubler på det andet rektangel. Så flytter den til det andet tegn i strengen, og forsøger at finde et match der... Og så videre indtil det finder et match eller kommer til slutningen af strengen, i hvilket tilfælde der ikke findes et match.
Tilbageslag
Det regulære udtryk /\b(+b|\d+|[\da-f]h)\b/ matcher enten et binært tal efterfulgt af et b, et decimaltal uden suffiks eller et hexadecimalt tal (tallene 0 til 9 eller symbolerne fra a til h), efterfulgt af h. Relevant diagram:
Når du søger efter et match, kan det ske, at algoritmen tager den øverste vej (binært tal), selvom der ikke er et sådant tal i strengen. Hvis der for eksempel er en linje "103", er det klart, at først efter at have nået tallet 3, vil algoritmen forstå, at den er på den forkerte vej. Generelt matcher linjen den almindelige sekvens, bare ikke i denne tråd.
Så ruller algoritmen tilbage. Ved en forgrening husker den den aktuelle position (i vores tilfælde er dette begyndelsen af linjen, lige efter ordet grænse), så du kan gå tilbage og prøve en anden vej, hvis den valgte ikke virker. For strengen "103", efter at have stødt på en treer, vil den gå tilbage og forsøge at gå gennem decimalstien. Dette vil fungere, så et match vil blive fundet.
Algoritmen stopper, så snart den finder en fuldstændig match. Det betyder, at selvom flere muligheder kan være egnede, bruges kun én af dem (i den rækkefølge, de optræder i den almindelige rækkefølge).
Backtracking forekommer, når du bruger gentagelsesoperatorer som + og *. Hvis du søger efter /^.*x/ i strengen "abcxe", vil regex-delen.* forsøge at forbruge hele strengen. Algoritmen vil så indse, at den også har brug for "x". Da der ikke er noget "x" efter slutningen af strengen, vil algoritmen forsøge at lede efter et match ved at flytte et tegn tilbage. Efter abcx er der heller ikke noget x, så ruller det tilbage igen, denne gang til understrengen abc. Og efter linjen finder den x og rapporterer et vellykket match på position 0 til 4.
Du kan skrive en almindelig rutine, der vil føre til flere tilbagerulninger. Dette problem opstår, når mønsteret kan matche inputdataene flere gange. forskellige veje. For eksempel hvis vi laver en fejl, når vi skriver et regulært udtryk for binære tal, kan vi ved et uheld skrive noget som /(+)+b/.
Hvis algoritmen skulle lede efter et sådant mønster i en lang række af 0'ere og 1'ere, der ikke havde et "b" i slutningen, ville den først gå gennem den indre løkke, indtil den løb tør for cifre. Så vil han bemærke, at der ikke er noget "b" i slutningen, han vil rulle en position tilbage, gå gennem den ydre løkke, give op igen, prøve at rulle tilbage til en anden stilling langs den indre løkke... Og han vil fortsætte at søge på denne måde ved at bruge begge sløjfer. Det vil sige, at mængden af arbejde med hvert tegn på linjen vil fordobles. Selv for flere dusin karakterer vil det tage meget lang tid at finde et match.
erstatte metode
Strings har en erstatningsmetode, der kan erstatte en del af en streng med en anden streng.Console.log("far".replace("p", "m")); // → kort
Det første argument kan også være et regulært udtryk, i hvilket tilfælde den første forekomst af det regulære udtryk i linjen erstattes. Når indstillingen "g" (global) tilføjes til det regulære udtryk, erstattes alle forekomster, ikke kun den første
Console.log("Borobudur".replace(//, "a")); // → Barobudur console.log("Borobudur".replace(//g, "a")); // → Barabadar
Det ville give mening at sende "erstat alle" muligheden gennem et separat argument eller gennem en separat metode som replaceAll. Men desværre overføres muligheden gennem selve det almindelige system.
Den fulde kraft af regulære udtryk afsløres, når vi bruger links til grupper fundet i en streng, specificeret i det regulære udtryk. For eksempel har vi en linje, der indeholder personers navne, et navn pr. linje, i formatet "Efternavn, Fornavn". Hvis vi skal bytte dem og fjerne kommaet for at få "Fornavn Efternavn", skriver vi følgende:
Console.log("Hopper, Grace\nMcCarthy, John\nRitchie, Dennis" .replace(/([\w ]+), ([\w ]+)/g, "$2 $1")); // → Grace Hopper // John McCarthy // Dennis Ritchie
$1 og $2 i erstatningslinjen henviser til grupper af tegn omgivet af parentes. $1 erstattes med den tekst, der matcher den første gruppe, $2 med den anden gruppe, og så videre, op til $9. Hele matchet er indeholdt i variablen $&.
Du kan også sende en funktion som det andet argument. For hver erstatning vil der blive kaldt en funktion, hvis argumenter vil være de fundne grupper (og hele den matchende del af linjen), og dens resultat vil blive indsat i en ny linje.
Simpelt eksempel:
Var s = "cia og fbi"; console.log(s.replace(/\b(fbi|cia)\b/g, function(str) (retur str.toUpperCase(); ))); // → CIA og FBI
Her er en mere interessant:
Var lager = "1 citron, 2 kål og 101 æg"; funktion minusOne(match, mængde, enhed) ( beløb = Antal(beløb) - 1; hvis (beløb == 1) // kun én tilbage, fjern "s" i slutningen unit = unit.slice(0, unit. længde - 1); ellers hvis (beløb == 0) beløb = "nej"; returbeløb + " " + enhed; ) console.log(stock.replace(/(\d+) (\w+)/g, minusOne) ); // → ingen citron, 1 kål og 100 æg
Koden tager en streng, finder alle forekomster af tal efterfulgt af et ord og returnerer en streng med hvert tal reduceret med et.
Gruppen (\d+) går ind i beløbsargumentet, og (\w+) går ind i enhedsargumentet. Funktionen konverterer beløb til et tal - og det virker altid, fordi vores mønster er \d+. Og laver så ændringer i ordet, hvis der kun er 1 genstand tilbage.
Grådighed
Det er nemt at bruge erstat til at skrive en funktion, der fjerner alle kommentarer fra JavaScript-kode. Her er det første forsøg:Funktion stripComments(code) ( return code.replace(/\/\/.*|\/\*[^]*\*\//g, ""); ) console.log(stripComments("1 + /* 2 */3")); // → 1 + 3 console.log(stripComments("x = 10;// ti!")); // → x = 10; console.log(stripComments("1 /* a */+/* b */ 1")); // → 1 1
Delen før "eller"-operatoren matcher to skråstreger efterfulgt af et vilkårligt antal tegn undtagen nye linjer. Den del, der fjerner kommentarer med flere linjer, er mere kompleks. Vi bruger [^], dvs. ethvert tegn, der ikke er tomt, som en måde at finde en karakter på. Vi kan ikke bruge en periode, fordi blokkommentarer fortsætter ny linje, og linjeskifttegnet matcher ikke punktum.
Men outputtet fra det foregående eksempel er forkert. Hvorfor?
[^]* delen vil først forsøge at fange så mange karakterer som muligt. Hvis den næste del af den almindelige sekvens på grund af dette ikke finder en match, vil den rulle et tegn tilbage og prøve igen. I eksemplet forsøger algoritmen at få fat i hele linjen og ruller derefter tilbage. Efter at have rullet 4 tegn tilbage, vil han finde */ i linjen - og det var ikke det, vi ønskede. Vi ville kun have fat i én kommentar og ikke gå til slutningen af linjen og finde den sidste kommentar.
På grund af dette siger vi, at gentagelsesoperatorerne (+, *, ? og ()) er grådige, hvilket betyder, at de først griber så meget, som de kan, og derefter går tilbage. Hvis du stiller et spørgsmål efter en operator som denne (+?, *?, ??, ()?), vil de blive til ikke-grådige og begynde at finde de mindst mulige forekomster.
Og det er det, vi har brug for. Ved at tvinge stjernen til at finde matches med det mindst mulige antal tegn på en linje, bruger vi kun én blok af kommentarer og ikke mere.
Funktion stripComments(code) ( return code.replace(/\/\/.*|\/\*[^]*?\*\//g, ""); ) console.log(stripComments("1 /* a */+/* b */ 1")); // → 1 + 1
Mange fejl opstår, når du bruger grådige operatorer i stedet for ikke-grådige. Når du bruger gentagelsesoperatoren, skal du altid overveje den ikke-grådige operator først.
Dynamisk oprettelse af RegExp-objekter
I nogle tilfælde er det nøjagtige mønster ukendt på det tidspunkt, hvor koden skrives. For eksempel skal du lede efter brugerens navn i teksten og omslutte det i understregninger. Da du først kender navnet efter at have kørt programmet, kan du ikke bruge skråstreg notation.Men du kan konstruere strengen og bruge RegExp-konstruktøren. Her er et eksempel:
Var navn = "harry"; var text = "Og Harry har et ar på panden."; var regexp = new RegExp("\\b(" + navn + ")\\b", "gi"); console.log(text.replace(regexp, "_$1_")); // → Og _Harry_ har et ar i panden.
Når vi opretter ordgrænser, skal vi bruge dobbelte skråstreg, fordi vi skriver dem i en normal linje, og ikke i en regulær rækkefølge med skråstreger. Det andet argument til RegExp indeholder muligheder for regulære udtryk - i vores tilfælde "gi", dvs. globalt og ufølsomt for store og små bogstaver.
Men hvad hvis navnet er "dea+hlrd" (hvis vores bruger er en kulhatzker)? Som et resultat vil vi få et meningsløst regulært udtryk, der ikke finder match i strengen.
Vi kan tilføje omvendte skråstreger før enhver karakter, vi ikke kan lide. Vi kan ikke tilføje omvendte skråstreger før bogstaver, fordi \b eller \n er specialtegn. Men du kan tilføje skråstreger før alle ikke-alfanumeriske tegn uden problemer.
Var navn = "dea+hlrd"; var text = "Denne dea+hlrd irriterer alle."; var escaped = name.replace(/[^\w\s]/g, "\\$&"); var regexp = new RegExp("\\b(" + escaped + ")\\b", "gi"); console.log(text.replace(regexp, "_$1_")); // → Dette _dea+hlrd_ irriterede alle.
søgemetode
Metoden indexOf kan ikke bruges med regulære udtryk. Men der er en søgemetode, der bare forventer regulært udtryk. Ligesom indexOf returnerer det indekset for den første forekomst, eller -1, hvis ingen forekommer.Console.log(" word".search(/\S/)); // → 2 console.log(" ".search(/\S/)); // → -1
Desværre er der ingen måde at fortælle metoden til at lede efter et match, der starter ved en specifik offset (som du kan gøre med indexOf). Det ville være nyttigt.
lastIndex egenskab
Exec-metoden virker heller ikke bekvem måde begynde at søge fra en given position i strengen. Men det giver en ubekvem måde.Et regex-objekt har egenskaber. En af dem er source, som indeholder en streng. En anden er lastIndex, som under visse forhold kontrollerer, hvor den næste søgning efter hændelser vil begynde.
Disse betingelser omfatter, at den globale mulighed g skal være til stede, og at søgningen skal udføres ved hjælp af exec-metoden. En mere rimelig løsning ville være blot at tillade, at et ekstra argument sendes til exec, men rimelighed er ikke et grundlæggende træk ved JavaScript-regex-grænsefladen.
Var-mønster = /y/g; pattern.lastIndex = 3; var match = pattern.exec("xyzzy"); console.log(match.indeks); // → 4 console.log(pattern.lastIndex); // → 5
Hvis søgningen lykkedes, opdaterer exec-kaldet lastIndex-egenskaben til at pege på positionen efter den fundne forekomst. Hvis der ikke var succes, sættes lastIndex til nul - ligesom lastIndex for det nyoprettede objekt.
Når du bruger en global regulær variabel og flere exec-kald, kan disse automatiske lastIndex-opdateringer forårsage problemer. Din almindelige server kan begynde at søge fra positionen til venstre fra det forrige opkald.
Var ciffer = /\d/g; console.log(digit.exec("her er det: 1")); // → ["1"] console.log(digit.exec("og nu: 1")); // → null
En anden interessant effekt af g-indstillingen er, at den ændrer, hvordan matchmetoden fungerer. Når den kaldes med denne mulighed, i stedet for at returnere en matrix, der ligner resultatet af exec, finder den alle forekomster af mønsteret i strengen og returnerer en matrix af de fundne understrenge.
Console.log("Banana".match(/an/g)); // → ["en", "en"]
Så vær forsigtig med globale regulære variabler. De tilfælde, hvor der er brug for dem - erstat opkald eller steder, hvor du specifikt bruger lastIndex - er sandsynligvis alle de tilfælde, hvor de skal bruges.
Forekomst cyklusser
En typisk opgave er at iterere gennem alle forekomster af et mønster i en streng, så det kan få adgang til matchobjektet i løkkens krop ved hjælp af lastIndex og exec.
Var input = "En linje med 3 tal i... 42 og 88."; var nummer = /\b(\d+)\b/g; var match; while (match = number.exec(input)) console.log("Fundet", match, " på ", match.index); // → Fundet 3 gange 14 // Fundet 42 gange 33 // Fundet 88 gange 40
Det udnytter det faktum, at værdien af opgaven er den værdi, der tildeles. Brug af match = re.exec(input) som en betingelse i mens loop, søger vi i begyndelsen af hver iteration, gemmer resultatet i en variabel og afslutter løkken, når alle matches er fundet.
Parsing af INI-filer
For at afslutte kapitlet, lad os se på et problem med regulære udtryk. Forestil dig, at vi skriver et program, der indsamler oplysninger om vores fjender via internettet. automatisk tilstand. (Vi skriver ikke hele programmet, kun den del, der læser indstillingsfilen. Beklager.) Filen ser sådan ud:
Searchengine=http://www.google.com/search?q=$1 spitefulness=9.7 ; et semikolon er placeret før kommentarer; hver sektion refererer til en anden fjende fuldnavn=Larry Doe type=kindergarten bull website=http://www.geocities.com/CapeCanaveral/11451 fullname=Gargamel type=evil wizard outputdir=/home/marijn/enemies/gargamel
Det nøjagtige filformat (som er ret udbredt og normalt kaldes INI) er som følger:
Blanke linjer og linjer, der starter med semikolon, ignoreres
- linjer omgivet af firkantede parenteser begynder et nyt afsnit
- linjer, der indeholder en alfanumerisk identifikator efterfulgt af = tilføje en indstilling i dette afsnit
Alt andet er forkerte data.
Vores opgave er at konvertere en sådan streng til en række objekter, hver med en navnegenskab og en række indstillinger. Et objekt er nødvendigt for hver sektion, og et mere til globale indstillingerøverst i filen.
Da filen skal parses linje for linje, er det en god idé at starte med at opdele filen i linjer. For at gøre dette brugte vi string.split("\n") i kapitel 6. Nogle operativsystemer bruger ikke ét \n tegn til linjeskift, men to - \r\n. Da splitmetoden tager regulære udtryk som et argument, kan vi opdele linjer ved at bruge udtrykket /\r?\n/, hvilket tillader både enkelte \n og \r\n mellem linjer.
Funktionen parseINI(streng) ( // Lad os starte med et objekt, der indeholder indstillinger på øverste niveau var currentSection = (navn: null, felter: ); var categories = ; string.split(/\r?\n/).forEach(function) (line ) ( var match; if (/^\s*(;.*)?$/.test(line)) ( return; ) else if (match = line.match(/^\[(.*)\ ]$ /)) ( currentSection = (navn: match, felter: ); categories.push(currentSection); ) else if (match = line.match(/^(\w+)=(.*)$/)) ( currentSection. fields.push((navn: match, værdi: match)); ) else ( throw new Error("Linjen "" + linje + "" indeholder ugyldige data."); ) )); returner kategorier; )
Koden går gennem alle linjerne og opdaterer det aktuelle sektionsobjekt "aktuel sektion". Først tjekker den, om linjen kan ignoreres ved hjælp af det regulære udtryk /^\s*(;.*)?$/. Kan du forestille dig, hvordan dette fungerer? Delen mellem parenteserne matcher kommentarerne, ikke? gør det således, at det almindelige tegn også vil matche linjer, der kun består af mellemrum.
Hvis linjen ikke er en kommentar, kontrollerer koden, om den starter et nyt afsnit. Hvis ja, opretter den et nyt objekt for den aktuelle sektion, hvortil efterfølgende indstillinger tilføjes.
Den sidste meningsfulde mulighed er, at strengen er en normal indstilling, i hvilket tilfælde den føjes til det aktuelle objekt.
Hvis ingen af mulighederne virker, giver funktionen en fejl.
Bemærk, hvordan den hyppige brug af ^ og $ sikrer, at udtrykket matcher hele strengen i stedet for kun en del af den. Hvis du ikke bruger dem, vil koden generelt virke, men vil nogle gange give mærkelige resultater, og fejlen vil være svær at spore.
If (match = string.match(...))-konstruktionen ligner tricket med at bruge tildeling som en betingelse i en while-løkke. Ofte ved du ikke, at match-kaldet vil lykkes, så du kan kun få adgang til resultatobjektet inde i en if-blok, der tjekker efter det. For ikke at bryde den smukke kæde af if-tjek, tildeler vi søgeresultatet til en variabel og bruger straks denne tildeling som en check.
Internationale symboler
På grund af den oprindeligt enkle implementering af sproget og den efterfølgende fiksering af en sådan implementering "i granit", er JavaScript regulære udtryk dumme med tegn, der ikke findes på det engelske sprog. For eksempel kan "bogstav"-tegnet, set fra JavaScript-regulære udtryks synspunkt, være et af de 26 bogstaver i det engelske alfabet, og af en eller anden grund også en understregning. Bogstaver som é eller β, som tydeligvis er bogstaver, matcher ikke \w (og vil matche \W, som er et ikke-bogstav).I en mærkelig tilfældighed matcher historisk \s (mellemrum) alle tegn, der betragtes som mellemrum i Unicode, inklusive ting som f.eks. ikke-brudsrum eller mongolsk vokalseparator.
Nogle regex-implementeringer på andre sprog har speciel syntaks til at søge efter specielle kategorier af Unicode-tegn, såsom "alle bogstaver", "alle tegnsætning" eller "kontroltegn". Der er planer om at tilføje sådanne kategorier til JavaScript, men de vil sandsynligvis ikke blive implementeret snart.
Bundlinie
Regulære er objekter, der repræsenterer søgemønstre i strenge. De bruger deres egen syntaks til at udtrykke disse mønstre.
/abc/ Tegnsekvens
// Ethvert tegn fra listen
/[^abc]/ Ethvert tegn undtagen tegn fra listen
// Ethvert tegn fra intervallet
/x+/ En eller flere forekomster af mønsteret x
/x+?/ En eller flere forekomster, ikke-grådig
/x*/ Nul eller flere forekomster
/x?/ Nul eller én forekomst
/x(2,4)/ Fra to til fire forekomster
/(abc)/ Gruppe
/a|b|c/ Enhver af flere mønstre
/\d/ Ethvert tal
/\w/ Ethvert alfanumerisk tegn ("bogstav")
/\s/ Ethvert mellemrumstegn
/./ Ethvert tegn undtagen nye linjer
/\b/ Ordgrænse
/^/ Start af linje
/$/ End of line
Regex har en testmetode til at kontrollere, om mønsteret er i strengen. Der er en exec-metode, der returnerer et array, der indeholder alle de fundne grupper. Arrayet har en indeksegenskab, som indeholder nummeret på det tegn, hvorfra matchningen opstod.
Strenge har en matchmetode til at matche mønstre og en søgemetode, der kun returnerer startpositionen for forekomsten. Erstatningsmetoden kan erstatte forekomster af et mønster med en anden streng. Derudover kan du videregive en funktion til erstatning, der vil bygge en erstatningslinje baseret på skabelonen og fundne grupper.
Almindelige tegn har indstillinger, der er skrevet efter den afsluttende skråstreg. Muligheden i gør det regulære udtryk ufølsomt mellem store og små bogstaver, og indstillingen g gør det globalt, hvilket blandt andet får erstatningsmetoden til at erstatte alle fundne forekomster, ikke kun den første.
RegExp-konstruktøren kan bruges til at skabe regulære udtryk fra strenge.
Regulatorer er et skarpt instrument med et ubehageligt håndtag. De forenkler i høj grad nogle opgaver og kan blive uoverskuelige, når man løser andre komplekse problemer. En del af at lære at bruge regexes er at være i stand til at modstå fristelsen til at fylde dem med en opgave, som de ikke er beregnet til.
Øvelser
Når du løser problemer, vil du uundgåeligt støde på uforståelige tilfælde, og du kan nogle gange fortvivle, når du ser nogle regulære udtryks uforudsigelige adfærd. Nogle gange hjælper det at studere adfærden af en almindelig motor gennem en onlinetjeneste som debuggex.com, hvor du kan se dens visualisering og sammenligne den med den ønskede effekt.Almindelig golf
"Golf" i kode er et spil, hvor du skal udtrykke dig givet program minimum antal tegn. Almindelig golf er en praktisk øvelse i at skrive de mindst mulige stamgæster for at finde et givet mønster, og kun det.For hver af underlinjerne skal du skrive et regulært udtryk for at kontrollere deres placering i linjen. Den almindelige motor bør kun finde disse specificerede understrenge. Du skal ikke bekymre dig om ordgrænser, medmindre det er specifikt nævnt. Når du har et fungerende almindeligt mønster, så prøv at reducere det.
Bil og kat
- pop og rekvisit
- ilder, færge og ferrari
- Ethvert ord, der ender på ious
- Et mellemrum efterfulgt af et punktum, komma, kolon eller semikolon.
- Et ord længere end seks bogstaver
- Ord uden bogstaver e
// Indtast dine regulære udtryk verify(/.../, ["min bil", "dårlige katte"], ["camper", "high art"]); verify(/.../, ["popkultur", "gale rekvisitter"], ["plop"]); verify(/.../, ["ilder", "færge", "ferrari"], ["ferrum", "overfør A"]); verify(/.../, ["hvor lækkert", "rummeligt værelse"], ["ødelæggende", "bevidsthed"]); verify(/.../, ["dårlig tegnsætning ."], ["escape the dot"]); verify(/.../, ["hottenottententen"], ["no", "hottentottententen"]); verify(/.../, ["rødt næbdyr", "slingrende rede"], ["jordbed", "lærende abe"]); function verify(regexp, yes, no) ( // Ignorer ufærdige øvelser if (regexp.source == "...") return; yes.forEach(function(s) (if (!regexp.test(s)) console .log("Ikke fundet "" + s + """); )); no.forEach(funktion(er) (if (regexp.test(s)) console.log("Uventet forekomst af "" + s + " ""); )); )
Citater i tekst
Lad os sige, at du skrev en historie og brugte enkelte citater hele vejen igennem for at indikere dialog. Nu vil du erstatte dialogcitaterne med dobbelte anførselstegn og lade de enkelte anførselstegn stå i forkortelser for ord som ikke er det.Kom med et mønster, der skelner mellem disse to anvendelser af citater, og skriv et kald til den erstatningsmetode, der foretager udskiftningen.
Tal igen
Sekvenser af tal kan findes med et simpelt regulært udtryk /\d+/.Skriv et udtryk, der kun finder tal skrevet i JavaScript-stil. Det skal understøtte et muligt minus eller plus før tallet, et decimaltegn og videnskabelig notation 5e-3 eller 1E10 - igen med muligt plus eller minus. Bemærk også, at der ikke nødvendigvis er tal før eller efter prikken, men tallet kan ikke bestå af en enkelt prik. Det vil sige, .5 eller 5. er gyldige tal, men en prik i sig selv er det ikke.
// Indtast den almindelige rækkefølge her. var nummer = /^...$/; // Tester: ["1", "-1", "+15", "1.55", ".5", "5.", "1.3e2", "1E-4", "1e+12"] .forEach(function(s) ( if (!number.test(s)) console.log("Fundet ikke "" + s + """); )); ["1a", "+-1", "1.2.3", "1+1", "1e4.5", ".5.", "1f5", "."].forHver(funktion(er) ( if (number.test(s)) console.log("Forkert accepteret "" + s + """); ));
Regex eller regulære udtryk er skræmmende for begyndere, men afgørende for enhver programmør. Lad os forstå regulære udtryk ved hjælp af 5 enkle eksempler med JavaScript.
Hvis du har et problem, og du vil løse det med regulære udtryk, har du nu to problemer. Der er et ordsprog. Regelmæssige udtryk, der findes i kode, forårsager nogle gange frygt og had hos mennesker, der ikke er fortrolige med dem.
Men faktisk er ethvert regex blot et skabelonudtryk, der kan løse problemet med en hel funktion på én linje. Men for at opbygge et regulært udtryk skal du tage højde for et sæt strenge regler, som en nybegynder kan blive forvirret og lave fejl i.
Matchende karakterer
De mest basale regulære udtryk er dem, der matcher enkelte tegn. Her er deres regler:
1. Et punktum (.) matcher ethvert tegn. Hvis du har brug for at søge efter et bestemt punkt, skal du undslippe det ved at bruge tegnet "\" (\.).
2. Et spørgsmålstegn (?) angiver, at det forrige tegn er valgfrit. For at søge efter selve spørgsmålstegnet i en streng, skal det også escapes med "\" (\?).
var text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit lest. Donec convallis dignissim ligula, et rutrum est elat vistibulum eu."; // Både "elit" og "elat" duer. Prikken betyder, at et hvilket som helst symbol gør det. var regex = /el.t/g; console.log(tekst.match(regex)); // "est" og "lest" vil fungere lige godt. Spørgsmålstegnet gør "l" valgfrit. var regex2 = /l?est/g; console.log(tekst.match(regex2));
var tekst = "Lorem ipsum dolor sit amet, consectetur adipiscing elit lest. Donec convallis dignissim ligula, et rutrum est elat vistibulum eu."; // Både "elit" og "elat" duer. Prikken betyder, at et hvilket som helst symbol gør det. var regex = /el.t/g ; konsol. log(tekst. match(regex)); // "est" og "lest" vil fungere lige godt. Spørgsmålstegnet gør "l" valgfrit. var regex2 = /l?est/g ; konsol. log(tekst. match(regex2)); |
Match flere tegn
Et sæt er et eller flere tegn indesluttet i parentes, for eksempel . Dette udtryk leder kun efter det sæt af tegn i en streng – i dette eksempel kun a, b eller c. Tværtimod kan du søge efter forekomster af alle symboler undtagen ved at bruge "^"-symbolet. [^abc] vil matche ethvert tegn, der ikke er a, b eller c. Du kan også angive en række tegn eller tal, f.eks.
Der er indbygget tegnsæt, der gør det nemmere at skrive regulære udtryk. De kaldes forkortelser eller stenografi. For eksempel kan du skrive \D i stedet for. Der er forkortelser for andre tegn (inklusive tal og understregninger) - \w og \W, samt for mellemrum - \s og \S.
// Kun "kat" og "kan" vil fungere, ikke "bil". var text = "kattebil kan"; console.log(text.match(/ca/g)); // Alt vil passere undtagen kat og kan (der er et ^-symbol) console.log(text.match(/ca[^tn]/g)); // Et andet eksempel, hvor kun tal vil passere tekst = "Jeg vil gerne have 8 kopper kaffe, tak."; console.log("Hvor mange kopper: " + text.match(//g)); // Nemmere måde at bruge genvejen \d console.log("Hvor mange kopper: " + text.match(/\d/g)); // Sender alt undtagen tal console.log(text.match(/\D/g));
// Kun "kat" og "kan" vil fungere, ikke "bil". var text = "kattebil kan" ; konsol. log(tekst. match(/ca/g)); // Passerer alt undtagen kat og kan (der er et ^-symbol) konsol. log (tekst . match (/ca[^tn]/g) ); // Endnu et eksempel, hvor kun tal vil passere tekst = "Jeg vil gerne have 8 kopper kaffe, tak."; konsol. log ("Hvor mange kopper: " + tekst . match (//g) ); // Nemmere måde at bruge genvej \d konsol. log("Hvor mange kopper: " + tekst . match (/\d/g) ); // Alt vil passere undtagen tal konsol. log(tekst. match(/\D/g)); |
Matchende ord
I de fleste tilfælde skal du søge efter hele ord, ikke individuelle tegn. Dette gøres ved hjælp af modifikatorer (+) og (-), som gentager et tegn eller et sæt af tegn.
Tilføjelse af (X) angiver det nøjagtige antal gentagelser, (x, y) – området (x og y er tal).
Derudover er der et særligt mønster \b, der matcher grænser i enderne af ord.
var text = "Hej folk fra 1974. Jeg kommer fra fremtiden. I 2014 har vi laserpistoler, svævebrætter og bor på månen!"; // Vil finde år. \d+ vil matche et eller flere tegn var yearRegex = /\d+/g; console.log("År: ", text.match(yearRegex)); // Finder alle sætninger. Vores sætninger begynder med stort bogstav og slutter med punktum eller udråbstegn. var sætningRegex = /.+?(\.|!)/g; console.log("Sætninger: ", text.match(sætningRegex)); // Finder alle ord, der begynder med "h". Både store og små bogstaver er velegnede til os, så vi bruger i // \b-modifikatoren til at definere ordet grænse. var hWords = /\bh\w+/ig; console.log("H Words: ", text.match(hWords)); // Finder alle ord fra 4 til 6 tegn var findWords = /\b\w(4,6)\b/g; console.log("Ord mellem 4 og 6 tegn: ", text.match(findWords)); // Find ord længere end 5 tegn console.log("Ord 5 tegn eller længere: ", text.match(/\b\w(5,)\b/g)); // Finder ord nøjagtigt 6 tegn lange console.log("Ord nøjagtigt 6 tegn lange: ", text.match(/\b\w(6)\b/g));
var tekst = "Hej folk fra 1974. Jeg kommer fra fremtiden. I 2014 har vi laserpistoler, svævebrætter og bor på månen!"; // Vil finde år. \d+ matcher et eller flere tegn var yearRegex = /\d+/g ; konsol. log ("År: ", tekst . match (yearRegex) ); // Finder alle sætninger. Vores sætninger begynder med stort bogstav og slutter med punktum eller udråbstegn. var sætningRegex = /.+?(\.|!)/g ; konsol. log("Sætninger: ", tekst. match(sætningRegex)); // Finder alle ord, der begynder med "h". Både store og små bogstaver passer til os, så vi bruger i modifier // \b for at bestemme ordgrænser. var hWords = /\bh\w+/i g ; konsol. log ("H Words: ", tekst . match (hWords) ); // Finder alle ord fra 4 til 6 tegn var findWords = /\b\w(4,6)\b/g ; konsol. log( "Ord mellem 4 og 6 tegn: ", tekst. match(findWords)); // Find ord længere end 5 tegn konsol. log ("Ord 5 tegn eller længere: " , tekst . matcher (/\b\w(5,)\b/g ) ); // Find ord på nøjagtig 6 tegn konsol. log( "Ord nøjagtigt 6 tegn lange:", tekst. match (/\b\w(6)\b/g) ); |
Hel strengvalidering
I JavaScript kan sådanne udtryk bruges til at validere brugerinput fra tekstfelter. For at validere strenge bruges et regulært regulært udtryk, bundet til begyndelsen og slutningen af et tekstfragment, ved at bruge udtrykkene ^ (begyndelsen af linjen) og $ (slutningen af linjen) til dette formål. Disse symboler sikrer, at det mønster, du skriver, spænder over hele tekstens længde og ikke kun matcher en del af den.
Derudover bruger vi i dette tilfælde test()-metoden for regex-objektet, som returnerer sand eller falsk, når vi tester, om det regulære udtryk matcher strengen.
// Vi har en række strenge, lad os finde links..com/", "123461", "https://site/?s=google", "http://ikke en gyldig url", "abc http: / /invalid.url/" ]; var regex = /^https?:\/\/[\w\/?.&-=]+$/; var urls = ; for(var i = 0; i< strings.length; i++){ if(regex.test(strings[i])){ // Валидная ссылка urls.push(strings[i]); } } console.log("Valid URLs: ", urls);
// Vi har en række strenge, lad os finde linkene. var strenge = [ "https://site/", "dette er ikke en URL" , "https://google.com/", "123461" , "https://site/?s=google" , "http://ikke en gyldig url" , "abc http://ugyldig.url/" var regex = / ^ https ? : \ / \ / [ \ w \ / ? . & -= ] + $ / ; var urls = ; for (var i = 0 ; i< strings . length ; i ++ ) { if (regex . test (strenge [i] ) ) ( webadresser. push(strenge[i]); konsol. log("Gyldige URL'er:", urls); |
Søg og erstat
En anden fælles opgave, som er lettet ved brug af regulære udtryk, er at søge og erstatte tekst.
Regelmæssige udtryk
Almindelig udtryk er et objekt, der beskriver et karaktermønster. RegExp-klassen i JavaScript repræsenterer regulære udtryk, og String- og RegExp-klasseobjekterne definerer metoder, der bruger regulære udtryk til at udføre mønstermatchning og tekstsøgning og -erstatningsoperationer. Regulære udtryk grammatik i JavaScript indeholder en ret komplet delmængde af regulære udtrykssyntaks, der bruges i Perl 5, så hvis du har erfaring med Perl-sproget, kan du nemt beskrive mønstre i JavaScript-programmer.
Funktioner i Perl regulære udtryk, der ikke understøttes i ECMAScript, inkluderer flagene s (enkeltlinjetilstand) og x (udvidet syntaks); escape-sekvenser \a, \e, \l, \u, \L, \U, \E, \Q, \A, \Z, \z og \G og andre udvidede konstruktioner, der starter med (?.
Definition af regulære udtryk
I JavaScript almindelig udtryk er repræsenteret af objekter RegExp. RegExp-objekter kan oprettes ved hjælp af RegExp()-konstruktøren, men oftere oprettes de ved hjælp af en speciel bogstavelig syntaks. Ligesom strengliteraler er angivet som tegn omgivet af anførselstegn, angives literaler i regulære udtryk som tegn omgivet af et par skråstregtegn (/). Så din JavaScript-kode kan indeholde linjer som denne:
Var mønster = /s$/;
Denne linje opretter et nyt RegExp-objekt og tildeler det til mønstervariablen. Dette objekt RegExp leder efter strenge, der ender med et "s". Det samme regulære udtryk kan defineres ved hjælp af RegExp()-konstruktøren:
Var mønster = nyt RegExp("s$");
En mønsterspecifikation for regulære udtryk består af en sekvens af tegn. De fleste tegn, inklusive alle alfanumeriske, beskriver bogstaveligt talt de tegn, der skal være til stede. Det vil sige, at det regulære udtryk /java/ matcher alle linjer, der indeholder understrengen "java".
Andre tegn i regulære udtryk er ikke beregnet til at blive brugt til at finde deres nøjagtige ækvivalenter, men har snarere særlige betydninger. For eksempel indeholder det regulære udtryk /s$/ to tegn. Det første tegn s angiver en søgning efter et bogstaveligt tegn. For det andet er $ et særligt metategn, der markerer slutningen af en linje. Så dette regulære udtryk matcher enhver streng, der ender med tegnet s.
De følgende afsnit beskriver de forskellige tegn og metategn, der bruges i regulære udtryk i JavaScript.
Bogstavelige tegn
Som tidligere nævnt matcher alle alfabetiske tegn og tal i regulære udtryk sig selv. Syntaks for regulære udtryk i JavaScript understøtter også muligheden for at specificere visse ikke-alfabetiske tegn ved hjælp af escape-sekvenser, der starter med et omvendt skråstreg (\). For eksempel matcher rækkefølgen \n tegnet for linjeskift. Disse symboler er angivet i tabellen nedenfor:
Nogle tegnsætningstegn har særlige betydninger i regulære udtryk:
^ $ . * + ? = ! : | \ / () { } -
Betydningen af disse symboler er forklaret i de følgende afsnit. Nogle af dem har kun særlig betydning i visse regulære udtrykssammenhænge, mens de i andre sammenhænge fortolkes bogstaveligt. Men generelt, for bogstaveligt at inkludere nogen af disse tegn i et regulært udtryk, skal du indlede det med et omvendt skråstreg. Andre tegn, såsom anførselstegn og @, har ingen speciel betydning og matcher simpelthen sig selv i regulære udtryk.
Hvis du ikke kan huske præcis, hvilke tegn der skal indledes med et \, kan du roligt sætte en omvendt skråstreg foran enhver af tegnene. Husk dog på, at mange bogstaver og tal bliver særlig betydning, så de bogstaver og tal, du leder efter, skal bogstaveligt talt ikke stå foran et \-tegn. For at inkludere selve skråstreg-tegnet i et regulært udtryk, skal du naturligvis foran det med et andet skråstreg-tegn. For eksempel matcher følgende regulære udtryk enhver streng, der indeholder et omvendt skråstreg: /\\/.
Karakter klasser
Individuelle bogstavelige tegn kan kombineres til karakterklasser ved at omslutte dem i firkantede parenteser. En karakterklasse matcher ethvert tegn indeholdt i den pågældende klasse. Derfor matcher det regulære udtryk // et af tegnene a, b eller c.
Negative tegnklasser kan også defineres til at matche ethvert tegn undtagen dem, der er angivet i parentes. Negationstegnklassen er specificeret af tegnet ^ som det første tegn efter venstre parentes. Det regulære udtryk /[^abc]/ matcher alle andre tegn end a, b eller c. I tegnklasser kan en række tegn angives ved hjælp af en bindestreg. Alle små latinske tegn findes ved hjælp af //-udtrykket, og ethvert bogstav eller tal fra det latinske tegnsæt kan findes ved hjælp af //-udtrykket.
Visse karakterklasser er særligt almindelige, så regulære udtrykssyntaks i JavaScript inkluderer specialtegn og escape-sekvenser til at repræsentere dem. Således matcher \s mellemrum, tabulator og alle Unicode-mellemrumstegn, og \S matcher alle ikke-Unicode-mellemrumstegn.
Tabellen nedenfor giver en liste over disse specialtegn og syntaksen for tegnklasserne. (Bemærk, at nogle af tegnklassens escape-sekvenser kun matcher ASCII-tegn og er ikke udvidet til at arbejde med Unicode-tegn. Du kan udtrykkeligt definere dine egne Unicode-tegnklasser, f.eks. /[\u0400-\u04FF]/ matcher et hvilket som helst kyrillisk alfabet .)
| Symbol | Korrespondance |
|---|---|
| [...] | Ethvert af tegnene vist i parentes |
| [^...] | Ethvert af tegnene, der ikke er angivet i parentes |
| . | Ethvert andet tegn end en ny linje eller anden Unicode-linjeafgrænser |
| \w | Ethvert ASCII-teksttegn. Tilsvarende |
| \W | Ethvert tegn, der ikke er et ASCII-teksttegn. Svarende til [^a-zA-Z0-9_] |
| \s | Ethvert blanktegn fra Unicode-sættet |
| \S | Ethvert ikke-mellemrumstegn fra Unicode-sættet. Bemærk venligst, at tegnene \w og \S ikke er det samme |
| \d | Alle ASCII-numre. Tilsvarende |
| \D | Ethvert andet tegn end ASCII-numre. Svarende til [^0-9] |
| [\b] | Backspace tegn bogstaveligt |
Bemærk, at escape-sekvenser for klassespecialtegn kan omsluttes af firkantede parenteser. \s matcher ethvert mellemrumstegn og \d matcher ethvert ciffer, derfor matcher /[\s\d]/ ethvert mellemrumstegn eller ciffer.
Gentagelse
I betragtning af den viden om regulære udtrykssyntaks, der er opnået hidtil, kan vi beskrive et tocifret tal som /\d\d/ eller et firecifret tal som /\d\d\d\d/, men vi kan f.eks. , beskriv et tal bestående af et vilkårligt antal cifre eller en streng på tre bogstaver efterfulgt af et valgfrit ciffer. Disse mere komplekse mønstre bruger regulære udtrykssyntaks, som specificerer, hvor mange gange et givet regulært udtrykselement kan gentages.
Gentagelsessymboler følger altid det mønster, de er påført på. Nogle typer gentagelser bruges ret ofte, og specielle symboler er tilgængelige for at angive disse tilfælde. For eksempel matcher + en eller flere forekomster af det forrige mønster. Følgende tabel giver en oversigt over gentagelsessyntaksen:
Følgende linjer viser flere eksempler:
Var mønster = /\d(2,4)/; // Matcher et tal med to til fire cifre mønster = /\w(3)\d?/; // Match nøjagtigt tre ordtegn og et valgfrit ciffermønster = /\s+java\s+/; // Matcher ordet "java" med et eller flere mellemrum // før og efter det mønster = /[^(]*/; // Matcher nul eller flere tegn ud over den indledende parentes
Vær forsigtig, når du bruger gentagelsestegn * og ?. De kan matche fraværet af et mønster angivet før dem og derfor fraværet af tegn. For eksempel matcher det regulære udtryk /a*/ strengen "bbbb", fordi det ikke indeholder tegnet a.
De gentagelsestegn, der er angivet i tabellen, repræsenterer det maksimalt mulige antal gentagelser, der gør det muligt at matche efterfølgende dele af det regulære udtryk. Vi siger, at dette er grådig gentagelse. Det er også muligt at implementere gentagelse udført på en ikke-grådig måde. Det er nok at angive efter symbolet (eller symbolerne) gentagelsen spørgsmålstegn: ??, +?, *? eller endda (1,5)?.
For eksempel matcher det regulære udtryk /a+/ en eller flere forekomster af bogstavet a. Anvendt på strengen "aaa", matcher den alle tre bogstaver. På den anden side matcher udtrykket /a+?/ en eller flere forekomster af bogstavet a og vælger det mindst mulige antal tegn. Påført den samme streng matcher dette mønster kun det første bogstav a.
"Grådløs" gentagelse giver ikke altid det forventede resultat. Overvej mønsteret /a+b/, som matcher et eller flere a'er efterfulgt af et b'er. Når den anvendes på strengen "aaab", svarer den til hele strengen.
Lad os nu tjekke den "ikke-grådige" version af /a+?b/. Man kunne tro, at det ville matche et b foran kun et a. Hvis anvendt på den samme streng, forventes "aaab" at matche det enkelte tegn a og sidste tegn b. Dette mønster matcher dog faktisk hele strengen, ligesom den grådige version. Faktum er, at en regulært udtryksmønstersøgning udføres ved at finde den første position i strengen, hvorfra et match bliver muligt. Da et match er muligt fra det første tegn i strengen, tages der ikke engang hensyn til kortere match, der starter fra efterfølgende tegn.
Alternativer, gruppering og links
Regulære udtryksgrammatik inkluderer specialtegn til at definere alternativer, gruppere underudtryk og referencer til tidligere underudtryk. Rørsymbol | tjener til at adskille alternativer. For eksempel matcher /ab|cd|ef/ enten strengen "ab", eller strengen "cd", eller strengen "ef", og mønsteret /\d(3)|(4)/ matcher enten tre cifre eller fire små bogstaver.
Bemærk, at alternativer behandles fra venstre mod højre, indtil der findes et match. Hvis der findes et match med det venstre alternativ, ignoreres det højre, selvom et "bedre" match kan opnås. Derfor, når mønsteret /a|ab/ anvendes på strengen "ab", vil det kun matche det første tegn.
Parenteser har flere betydninger i regulære udtryk. En af dem er at gruppere individuelle elementer i ét underudtryk, så elementerne ved brug af specialtegnene |, *, +, ? og andre betragtes som én helhed. For eksempel matcher mønsteret /java(script)?/ ordet "java" efterfulgt af det valgfrie ord "script", og /(ab|cd)+|ef)/ matcher enten strengen "ef" eller en eller flere gentagelser af en fra strengene "ab" eller "cd".
En anden brug af parenteser i regulære udtryk er at definere undermønstre i et mønster. Når der findes et regulært udtryksmatch i målstrengen, kan den del af målstrengen, der matcher et specifikt undermønster omgivet af parentes, udtrækkes.
Antag, at du vil finde et eller flere små bogstaver efterfulgt af et eller flere tal. For at gøre dette kan du bruge skabelonen /+\d+/. Men lad os også antage, at vi kun vil have tallene i slutningen af hver kamp. Hvis vi sætter denne del af mønsteret i parentes (/+(\d+)/), kan vi udtrække tal fra enhver match, vi finder. Hvordan dette gøres vil blive beskrevet nedenfor.
En relateret brug af parentetiske underudtryk er at henvise til underudtryk fra en tidligere del af det samme regulære udtryk. Dette opnås ved at angive et eller flere cifre efter \-tegnet. Tallene refererer til positionen af underudtrykket i parentes i det regulære udtryk. For eksempel refererer \1 til det første underudtryk, og \3 refererer til det tredje. Bemærk, at underudtryk kan indlejres inden i hinanden, så positionen af venstre parentes bruges ved optælling. For eksempel, i det følgende regulære udtryk vil en indlejret underudtryk (skript)-reference se ud som \2:
/(ava(cript)?)\sis\s(sjov\w*)/
En reference til et tidligere underudtryk peger ikke på det pågældende underudtryks mønster, men på den fundne tekst, der matcher det mønster. Derfor kan referencer bruges til at indføre en begrænsning, der udvælger dele af en streng, der indeholder nøjagtig de samme tegn. For eksempel matcher det følgende regulære udtryk nul eller flere tegn inden for enkelte eller dobbelte anførselstegn. Det kræver dog ikke, at indledende og afsluttende citater matcher hinanden (det vil sige, at begge citater er enkelt eller dobbelt):
/[""][^""]*[""]/
Vi kan kræve anførselstegn for at matche ved at bruge en reference som denne:
Her matcher \1 det første underudtryk. I dette eksempel pålægger linket en begrænsning, der kræver, at det afsluttende anførselstegn matcher det indledende anførselstegn. Dette regulære udtryk tillader ikke enkelte anførselstegn inden for dobbelte anførselstegn og omvendt.
Det er også muligt at gruppere elementer i et regulært udtryk uden at oprette en nummereret reference til disse elementer. I stedet for blot at gruppere elementer mellem ( og ), skal du starte gruppen med symboler (?: og afslutte den med et symbol). Overvej for eksempel følgende mønster:
/(ava(?:cript)?)\sis\s(sjov\w*)/
Her behøves underudtrykket (?:script) kun til gruppering, så gentagelsestegnet ? kan anvendes på gruppen. Disse ændrede parenteser skaber ikke et link, så i dette regulære udtryk refererer \2 til tekst, der matcher mønsteret (sjov\w*).
Følgende tabel viser udvælgelses-, grupperings- og referenceoperatorerne i regulære udtryk:
| Symbol | Betyder |
|---|---|
| | | Alternativ. Matcher enten underudtrykket til venstre eller underudtrykket til højre. |
| (...) | Gruppering. Grupperer elementer i en enkelt enhed, der kan bruges med tegnene *, +, ?, | og så videre. Husker også tegn, der matcher denne gruppe, til brug i efterfølgende referencer. |
| (?:...) | Kun gruppering. Grupperer elementer i en enkelt enhed, men husker ikke de tegn, der svarer til denne gruppe. |
| \nummer | Matcher de samme tegn, som blev fundet ved matchende gruppenummernummer. Grupper er underudtryk inden for (muligvis indlejrede) parenteser. Gruppenumre tildeles ved at tælle venstre parentes fra venstre mod højre. Grupper dannet ved hjælp af symbolerne (?:) er ikke nummererede. |
Angivelse af en matchposition
Som beskrevet tidligere matcher mange elementer i et regulært udtryk et enkelt tegn i en streng. For eksempel matcher \s et enkelt mellemrumstegn. Andre regulære udtrykselementer matcher positionerne mellem tegn i stedet for selve tegnene. For eksempel matcher \b en ordgrænse – grænsen mellem \w (et ASCII-teksttegn) og \W (et ikke-teksttegn), eller grænsen mellem et ASCII-teksttegn og begyndelsen eller slutningen af en linje.
Elementer som \b angiver ikke nogen tegn, der skal være til stede i den matchede streng, men de angiver gyldige positioner til matchning. Disse elementer kaldes nogle gange regulære udtryks ankerelementer, fordi de forankrer mønsteret til en bestemt position i strengen. De mest almindeligt anvendte ankerelementer er ^ og $, som forbinder mønstre til henholdsvis begyndelsen og slutningen af en linje.
For eksempel kan ordet "JavaScript" på sin egen linje findes ved at bruge det regulære udtryk /^JavaScript$/. At finde separat ord"Java" (i stedet for et præfiks, f.eks. i ordet "JavaScript"), kan du prøve at bruge mønsteret /\sJava\s/, som kræver et mellemrum før og efter ordet.
Men en sådan løsning rejser to problemer. For det første vil det kun finde ordet "Java", hvis det er omgivet af mellemrum på begge sider, og vil ikke være i stand til at finde det i begyndelsen eller slutningen af linjen. For det andet, når dette mønster stemmer overens, vil den streng, den returnerer, indeholde førende og efterfølgende mellemrum, hvilket ikke lige er det, vi ønsker. Så i stedet for at bruge et mønster, der matcher mellemrumstegn \s, bruger vi et mønster (eller anker), der matcher ordgrænser \b. Resultatet bliver følgende udtryk: /\bJava\b/.
Ankerelementet \B matcher en position, der ikke er en ordgrænse. Det vil sige, at mønsteret /\Bcript/ vil matche ordene "JavaScript" og "efterskrift" og vil ikke matche ordene "script" eller "Scripting".
Vilkårlige regulære udtryk kan også tjene som ankerbetingelser. Hvis du placerer et udtryk mellem tegnene (?= og), bliver det en fremadrettet matchtest mod efterfølgende tegn, hvilket kræver, at disse tegn matcher det angivne mønster, men ikke inkluderes i matchstrengen.
For at matche navnet på et almindeligt programmeringssprog efterfulgt af et kolon kan du f.eks. bruge udtrykket /ava(cript)?(?=\:)/. Dette mønster matcher ordet "JavaScript" i strengen "JavaScript: The Definitive Guide", men det vil ikke matche ordet "Java" i strengen "Java i en nøddeskal", fordi det ikke efterfølges af et kolon.
Hvis du indtaster betingelsen (?!), vil dette være en negativ fremadrettet kontrol for efterfølgende tegn, hvilket kræver, at følgende tegn ikke matcher det angivne mønster. For eksempel mønsteret /Java(?!Script)(\w* )/ matcher understrengen "Java", efterfulgt af et stort bogstav og et vilkårligt tal tekst ASCII-tegn forudsat at understrengen "Java" ikke efterfølges af understrengen "Script". Det vil matche strengen "JavaBeans", men ikke strengen "Javanese", og det vil matche strengen "JavaScrip", men ikke strengene "JavaScript" eller "JavaScripter".
Tabellen nedenfor giver en liste over regulære udtryks ankertegn:
| Symbol | Betyder |
|---|---|
| ^ | Matcher begyndelsen af et strengudtryk eller begyndelsen af en linje i en flerliniesøgning. |
| $ | Matcher slutningen af et strengudtryk eller slutningen af en linje i en søgning med flere linjer. |
| \b | Matcher en ordgrænse, dvs. matcher positionen mellem et \w-tegn og et \W-tegn, eller mellem et \w-tegn og begyndelsen eller slutningen af en linje. (Bemærk dog, at [\b] matcher backspace-tegnet.) |
| \B | Matcher en position, der ikke er en ordgrænse. |
| (?=p) | Positivt lookahead-tjek for efterfølgende karakterer. Kræver efterfølgende tegn for at matche mønsteret p, men inkluderer ikke disse tegn i den matchede streng. |
| (?!p) | Negativ fremadrettet kontrol for efterfølgende tegn. Kræver, at følgende tegn ikke passer til mønsteret s. |
Flag
Og en mere, sidste element regulære udtryks grammatikker. Flag for regulære udtryk angiver mønstermatchningsregler på højt niveau. I modsætning til resten af grammatikken i regulære udtryk, angives flag ikke mellem skråtegnene, men efter det andet. JavaScript understøtter tre flag.
Flag i specificerer, at mønstermatching skal være ufølsom mellem store og små bogstaver, og flag g- at søgningen skal være global, dvs. alle matches i strengen skal findes. Flag m udfører en mønstersøgning i multi-line mode. Hvis strengudtrykket, der søges efter, indeholder nye linjer, så matcher ankertegnene ^ og $ i denne tilstand, ud over at matche begyndelsen og slutningen af hele strengudtrykket, også begyndelsen og slutningen af hver tekststreng. For eksempel matcher mønsteret /java$/im både "java" og "Java\nis sjovt".
Disse flag kan kombineres i enhver kombination. For f.eks. at søge efter den første forekomst af ordet "java" (eller "Java", "JAVA" osv.) på en måde, hvor der ikke er store og små bogstaver, kan du bruge det regulære udtryk /\bjava\b/. jeg. Og for at finde alle forekomster af dette ord i en streng, kan du tilføje g-flaget: /\bjava\b/gi.
Metoder i String-klassen til søgning efter mønster
Indtil dette punkt har vi diskuteret grammatikken for genererede regulære udtryk, men vi har ikke set på, hvordan disse regulære udtryk faktisk kan bruges i JavaScript-scripts. I dette afsnit vil vi diskutere metoder String objekt, hvor regulære udtryk bruges til mønstermatchning og søgning med erstatning. Og så fortsætter vi vores samtale om mønstermatchning med regulære udtryk ved at se på RegExp-objektet og dets metoder og egenskaber.
Strings understøtter fire metoder, der bruger regulære udtryk. Den enkleste af dem er metoden Søg(). Det tager et regulært udtryk som et argument og returnerer enten positionen for det første tegn i den matchede understreng eller -1, hvis der ikke findes noget match. For eksempel vil følgende opkald returnere 4:
Var result = "JavaScript".search(/script/i); // 4
Hvis argumentet til metoden search() ikke er et regulært udtryk, konverteres det først ved at sende det til RegExp-konstruktøren. Search()-metoden understøtter ikke global søgning og ignorerer g-flaget i argumentet.
Metode erstatte() udfører en søge- og udskiftningsoperation. Det tager et regulært udtryk som sit første argument og en erstatningsstreng som sit andet. Metoden søger på den linje, den kaldes på, for at finde et match til det angivne mønster.
Hvis det regulære udtryk indeholder g-flaget, erstatter metoden replace() alle matches fundet med erstatningsstrengen. Ellers erstatter den kun det første fundne match. Hvis erstatte()-metodens første argument er en streng i stedet for et regulært udtryk, udfører metoden en bogstavelig søgning efter strengen i stedet for at konvertere den til et regulært udtryk ved hjælp af RegExp()-konstruktøren, som search()-metoden gør.
Som et eksempel kan vi bruge metoden replace() til at skrive ordet "JavaScript" konsekvent på tværs af en hel tekstlinje:
// Uanset bogstavernes store og små bogstaver, erstatter vi dem med et ord i det nødvendige tilfælde var result = "javascript".replace(/JavaScript/ig, "JavaScript");
metoden replace() er mere kraftfuld end dette eksempel antyder. Lad mig minde dig om, at underudtrykkene i parentes i et regulært udtryk er nummereret fra venstre mod højre, og at det regulære udtryk husker den tekst, der svarer til hvert af underudtrykkene. Hvis erstatningsstrengen indeholder et $-tegn efterfulgt af et tal, erstatter metoden replace() disse to tegn med den tekst, der matcher det angivne underudtryk. Dette er en meget nyttig funktion. Vi kan for eksempel bruge det til at erstatte lige anførselstegn i en streng med typografiske anførselstegn, som simuleres af ASCII-tegn:
// Et citat er et citat efterfulgt af et vilkårligt antal tegn // bortset fra citater (som vi husker), efterfulgt af et andet citat // var quote = /"([^"]*)"/g; // Erstat lige citater med typografiske og lad "$1" være uændret // indholdet af citatet gemt i $1 var text = ""JavaScript" er et fortolket programmeringssprog."; var result = text.replace(quote, ""$1"" ) ; // "JavaScript" er et fortolket programmeringssprog.
En vigtig ting at bemærke er, at det andet argument til replace() kan være en funktion, der dynamisk beregner erstatningsstrengen.
Metode match() er den mest generelle af String-klassens metoder, der bruger regulære udtryk. Det tager et regulært udtryk som dets eneste argument (eller konverterer dets argument til et regulært udtryk ved at sende det til RegExp()-konstruktøren) og returnerer et array, der indeholder søgeresultaterne. Hvis g-flaget er sat i det regulære udtryk, returnerer metoden en matrix af alle matches, der findes i strengen. For eksempel:
// returnerer ["1", "2", "3"] var result = "1 plus 2 er lig med 3".match(/\d+/g);
Hvis det regulære udtryk ikke indeholder g-flaget, udfører match()-metoden ikke en global søgning; det ser bare efter den første kamp. Match() returnerer dog et array, selv når metoden ikke udfører en global søgning. I dette tilfælde er det første element i arrayet den fundne understreng, og alle resterende elementer er underudtryk af det regulære udtryk. Derfor, hvis match() returnerer en array arr, så vil arr indeholde hele den fundne streng, arr den understreng, der svarer til det første underudtryk, osv. Ved at drage en parallel med replace()-metoden kan vi sige, at indholdet af $n er indtastet i arr[n].
Tag for eksempel et kig på følgende kode, der analyserer en URL:
Var url = /(\w+):\/\/([\w.]+)\/(\S*)/; var text = "Besøg vores hjemmeside http://www..php"; var resultat = text.match(url); if (result != null) ( var fullurl = resultat; // Indeholder "http://www..php" var protokol = resultat; // Indeholder "http" var host = resultat; // Indeholder "www..php ")
Det skal bemærkes, at for et regulært udtryk, der ikke har det globale søgeflag g indstillet, returnerer match()-metoden den samme værdi som det regulære udtryks exec()-metode: det returnerede array har indeks- og inputegenskaberne, som beskrevet i diskussionen af exec( ) nedenfor.
Den sidste af String-objektmetoderne, der bruger regulære udtryk, er dele(). Denne metode opdeler strengen, som den kaldes på, i et array af understrenge ved at bruge argumentet som afgrænsning. For eksempel:
"123.456.789". split(","); // Returner ["123","456","789"]
Split()-metoden kan også tage et regulært udtryk som et argument. Dette gør metoden mere kraftfuld. For eksempel kan du angive en afgrænsning, der tillader et vilkårligt antal mellemrumstegn på begge sider:
"1, 2, 3 , 4 , 5". split(/\s*,\s*/); // Returner ["1","2","3","4","5"]
RegExp objekt
Som nævnt er regulære udtryk repræsenteret som RegExp-objekter. Ud over RegExp()-konstruktøren understøtter RegExp-objekter tre metoder og flere egenskaber.
RegExp()-konstruktøren tager et eller to strengargumenter og opretter et nyt RegExp-objekt. Det første argument til konstruktøren er en streng, der indeholder kroppen af det regulære udtryk, dvs. tekst, der skal vises mellem skråstreg i et regulært udtryk. Bemærk, at strengliteraler og regulære udtryk bruger tegnet \ til at repræsentere escape-sekvenser, så når du sender det regulære udtryk som en streng literal til RegExp()-konstruktøren, skal du erstatte hvert \-tegn med et par \\-tegn.
Det andet argument til RegExp() mangler muligvis. Hvis det er angivet, definerer det regulære udtryksflag. Det skal være et af tegnene g, i, m eller en kombination af disse tegn. For eksempel:
// Finder alle femcifrede tal i en streng. Bemærk // brugen af symboler i dette eksempel \\ var zipcode = new RegExp("\\d(5)", "g");
RegExp()-konstruktøren er nyttig, når det regulære udtryk er genereret dynamisk og derfor ikke kan repræsenteres ved hjælp af regulært udtryks literal syntaks. For at finde en streng indtastet af brugeren, skal du for eksempel oprette et regulært udtryk ved kørsel ved hjælp af RegExp().
RegExp-egenskaber
Hvert RegExp-objekt har fem egenskaber. Ejendom kilde- en skrivebeskyttet streng, der indeholder teksten i det regulære udtryk. Ejendom global er en skrivebeskyttet boolesk værdi, der angiver, om g-flaget er til stede i det regulære udtryk. Ejendom ignoreCase er en skrivebeskyttet boolesk værdi, der bestemmer, om flaget i er til stede i det regulære udtryk. Ejendom multiline er en skrivebeskyttet boolesk værdi, der bestemmer, om flaget m er til stede i det regulære udtryk. Og den sidste ejendom sidste indeks er et heltal, der kan læses og skrives. For mønstre med g-flaget indeholder denne egenskab positionsnummeret på linjen, hvor den næste søgning skal begynde. Som beskrevet nedenfor bruges det af metoderne exec() og test().
RegExp-metoder
RegExp-objekter definerer to metoder, der udfører mønstermatchning; de opfører sig på samme måde som String-klassemetoderne beskrevet ovenfor. Hovedmetoden for RegExp-klassen, der bruges til mønstermatchning, er exec(). Det ligner den tidligere nævnte match()-metode for String-klassen, bortset fra at det er en RegExp-klassemetode, der tager en streng som et argument, snarere end en String-klassemetode, der tager et RegExp-argument.
Exec()-metoden udfører det regulære udtryk for den angivne streng, dvs. leder efter et match i en snor. Hvis der ikke findes noget match, returnerer metoden null. Men hvis der findes et match, returnerer det det samme array som det array, der returneres af match()-metoden til søgning uden g-flaget. Nulelementet i arrayet indeholder den streng, der matcher det regulære udtryk, og alle efterfølgende elementer indeholder understrenge, der matcher alle underudtryk. Hertil kommer ejendommen indeks indeholder positionsnummeret på det tegn, som det tilsvarende fragment begynder med, og egenskaben input henviser til den linje, der blev søgt efter.
I modsætning til match() returnerer exec()-metoden et array, hvis struktur ikke afhænger af tilstedeværelsen af g-flaget i det regulære udtryk. Lad mig minde dig om, at når du sender et globalt regulært udtryk, returnerer match()-metoden en række fundne matches. Og exec() returnerer altid et match, men giver information om det fuld information. Når exec() kaldes på et regulært udtryk, der indeholder g-flaget, sætter metoden lastIndex-egenskaben for det regulære udtryksobjekt til positionsnummeret for tegnet umiddelbart efter den fundne understreng.
Når exec() kaldes en anden gang på det samme regulære udtryk, begynder den søgningen på det tegn, hvis position er angivet i lastIndex-egenskaben. Hvis exec() ikke finder et match, sættes egenskaben lastIndex til 0. (Du kan også sætte lastIndex til nul til enhver tid, hvilket skal gøres i alle tilfælde, hvor søgningen slutter før det sidste match i en enkelt række er fundet, og søgningen begynder på en anden linje med det samme RegExp-objekt.) Denne specielle adfærd gør det muligt at kalde exec() gentagne gange for at iterere over alle matches af det regulære udtryk i linjen. For eksempel:
Var mønster = /Java/g; var text = "JavaScript er sjovere end Java!"; var resultat; while((result = pattern.exec(text)) != null) ( console.log("Fundet "" + resultat + """ + " ved position " + result.index + "; næste søgning starter ved " + mønster .lastIndex); )
En anden metode til RegExp-objektet er prøve(), hvilket er meget enklere metode exec(). Det tager en streng og returnerer sand, hvis strengen matcher det regulære udtryk:
Var mønster = /java/i; pattern.test("JavaScript"); // Returner sand
At kalde test() svarer til at kalde exec(), som returnerer sand, hvis exec() returnerer noget andet end null. Af denne grund opfører test()-metoden sig på samme måde som exec()-metoden, når den kaldes på et globalt regulært udtryk: den begynder at søge efter den angivne streng på den position, der er angivet af lastIndex-egenskaben, og hvis den finder et match , sætter egenskaben lastIndex til tegnpositionsnummeret direkte ved siden af det fundne match. Derfor kan du ved at bruge test()-metoden oprette en linjegennemløbsløkke på samme måde som ved at bruge exec()-metoden.
I JavaScript er regulære udtryk repræsenteret af RegExp-objekter. RegExp-objekter kan oprettes ved hjælp af RegExp()-konstruktøren, men oftere oprettes de ved hjælp af en speciel bogstavelig syntaks. Ligesom strengliteraler er angivet som tegn omgivet af anførselstegn, angives literaler i regulære udtryk som tegn omsluttet af et skråstregpar / .
/pattern/flags new RegExp("mønster"[, søgemuligheder])
mønster- et regulært udtryk til søgning (mere om udskiftning senere) og flag - en streng med en hvilken som helst kombination af tegn g (global søgning), i (case og store bogstaver er ikke vigtig) og m (multi-line search). Den første metode bruges ofte, den anden - nogle gange. For eksempel er to sådanne opkald ækvivalente.
Søgemuligheder
Når vi opretter et regulært udtryk, kan vi angive yderligere søgemuligheder
Tegn i regulære JavaScript-udtryk
| Symbol | Korrespondance |
|---|---|
| Alfanumeriske tegn | Svare til dem selv |
| \0 | NUL-tegn (\u0000) |
| \t | Fane (\u0009) |
| \n | Linjefeed (\u000A) |
| \v | Lodret fane (\u000B) |
| \f | Sideoversættelse (\u000C) |
| \r | Returvogn (\u000D) |
| \xnn | Et tegn fra det latinske sæt, angivet med det hexadecimale tal nn; f.eks. er \x0A det samme som \n |
| \uxxxx | Unicode-tegn angivet med hexadecimalt tal xxxx; f.eks. er \u0009 det samme som \t |
| \cX | Kontroltegnet "X", f.eks. rækkefølgen \cJ svarer til nylinjetegnet \n |
| \ | For almindelige karakterer - gør dem specielle. For eksempel leder udtrykket /s/ blot efter tegnet "s". Og hvis du sætter \ før s, så angiver /\s/ allerede et mellemrumstegn. Og omvendt, hvis tegnet er specielt, for eksempel *, vil \ gøre det til et almindeligt "stjernetegn". For eksempel søger /a*/ efter 0 eller flere på hinanden følgende "a"-tegn. For at finde a med en stjerne "a*" - sæt \ foran specialen. symbol: /a\*/ . |
| ^ | Angiver begyndelsen af inputdata. Hvis flerlinjesøgningsflaget ("m") er sat, vil det også udløses ved starten af en ny linje. For eksempel vil /^A/ ikke finde "A" i "et A", men vil finde det første "A" i "En A." |
| $ | Angiver slutningen af inputdata. Hvis flerlinjesøgningsflaget er sat, vil det også virke i slutningen af linjen. For eksempel vil /t$/ ikke finde "t" i "eater", men det vil finde det i "eat". |
| * | Angiver gentagelse 0 eller flere gange. F.eks. vil /bo*/ finde "boooo" i "A spøgelse booooed" og "b" i "A bird warbled", men vil ikke finde noget i "En ged gryntede". |
| + | Angiver gentagelse 1 eller flere gange. Svarende til (1,). For eksempel vil /a+/ matche "a" i "slik" og alle "a" i "caaaaaaandy". |
| ? | Indikerer, at elementet kan være til stede eller ikke. For eksempel vil /e?le?/ matche "el" i "angel" og "le" i "vinkel." Hvis det bruges umiddelbart efter en af kvantificatorerne * , + , ? , eller () , angiver derefter en "ikke-grådig" søgning (gentager det mindst mulige antal gange, til det nærmeste næste mønsterelement), i modsætning til standardtilstanden "grådig", som maksimerer antallet af gentagelser, selvom det næste mønsterelement matcher også. Derudover ? brugt i forhåndsvisningen, som er beskrevet i tabellen under (?=), (?!) og (?:) . |
| . | (Decimaltegn) repræsenterer et hvilket som helst andet tegn end en ny linje: \n \r \u2028 eller \u2029. (du kan bruge [\s\S] til at søge efter et hvilket som helst tegn, inklusive nylinjer). For eksempel vil /.n/ matche "an" og "on" i "nej, et æble er på træet", men ikke "nej". |
| (x) | Finder x og husker. Dette kaldes "hukommelsesbeslag". For eksempel vil /(foo)/ finde og huske "foo" i "foo bar." Den fundne understreng gemmes i søgeresultatarrayet eller i de foruddefinerede egenskaber for RegExp-objektet: $1, ..., $9. Derudover kombinerer parenteserne, hvad der er indeholdt i dem, til et enkelt mønsterelement. For eksempel (abc)* - gentag abc 0 eller flere gange. |
| (?:x) | Finder x, men husker ikke, hvad den finder. Dette kaldes "hukommelsesparenteser". Den fundne understreng gemmes ikke i egenskaberne for resultatarrayet og RegExp. Som alle parenteser kombinerer de, hvad der er i dem, i et enkelt undermønster. |
| x(?=y) | Finder kun x, hvis x efterfølges af y. For eksempel vil /Jack(?=Sprat)/ kun matche "Jack", hvis den efterfølges af "Sprat". /Jack(?=Sprat|Frost)/ vil kun matche "Jack", hvis den efterfølges af "Sprat" eller "Frost". Hverken "Sprat" eller "Frost" vises dog i søgeresultatet. |
| x(?!y) | Finder kun x, hvis x ikke er efterfulgt af y. For eksempel vil /\d+(?!\.)/ kun matche et tal, hvis det ikke efterfølges af et decimaltegn. /\d+(?!\.)/.exec("3.141") vil finde 141, men ikke 3.141. |
| x|y | Finder x eller y. For eksempel vil /grøn|rød/ matche "grøn" i "grønt æble" og "rød" i "rødt æble". |
| (n) | Hvor n er et positivt heltal. Finder nøjagtigt n gentagelser af det foregående element. For eksempel vil /a(2)/ ikke finde "a" i "slik", men vil finde både a'er i "caandy" og de to første a'er i "caaandy". |
| (n,) | Hvor n er et positivt heltal. Finder n eller flere gentagelser af et element. For eksempel vil /a(2,) ikke finde "a" i "slik", men vil finde alle "a" i "caandy" og i "caaaaaaandy." |
| (n,m) | Hvor n og m er positive heltal. Find fra n til m gentagelser af elementet. |
| Karaktersæt. Finder alle de angivne tegn. Du kan angive mellemrum ved at bruge en bindestreg. For eksempel - det samme som . Matcher "b" i "brisket" og "a" og "c" i "pine". | |
| [^xyz] | Ethvert andet tegn end dem, der er angivet i sættet. Du kan også angive et span. For eksempel er [^abc] det samme som [^a-c] . Finder "r" i "brisket" og "h" i "chop". |
| [\b] | Finder backspace-tegnet. (Ikke at forveksle med \b .) |
| \b | Finder en (latinsk) ordgrænse, såsom et mellemrum. (Ikke at forveksle med [\b]). For eksempel vil /\bn\w/ matche "nej" i "middag"; /\wy\b/ vil finde "ly" i "muligvis i går." |
| \B | Det angiver ikke en ordgrænse. For eksempel vil /\w\Bn/ matche "på" i "middag", og /y\B\w/ vil matche "jer" i "muligvis i går." |
| \cX | Hvor X er et bogstav fra A til Z. Angiver et kontroltegn i en streng. For eksempel repræsenterer /\cM/ tegnet Ctrl-M. |
| \d | finder et tal fra ethvert alfabet (vores er Unicode). Brug kun til at finde almindelige tal. For eksempel vil /\d/ eller // matche "2" i "B2 er suitenummeret." |
| \D | Finder et ikke-numerisk tegn (alle alfabeter). [^0-9] svarer til almindelige tal. For eksempel vil /\D/ eller /[^0-9]/ matche "B" i "B2 er suitenummeret." |
| \s | Finder ethvert mellemrumstegn, inklusive mellemrum, tabulator, ny linje og andre Unicode-mellemrumstegn. For eksempel vil /\s\w*/ matche "bar" i "foo bar." |
| \S | Finder ethvert tegn undtagen mellemrum. For eksempel vil /\S\w*/ matche "foo" i "foo bar." |
| \v | Lodret tabulatortegn. |
| \w | Finder ethvert ord (latinsk alfabet), inklusive bogstaver, tal og understregninger. Tilsvarende. For eksempel vil /\w/ matche "a" i "æble", "5" i "$5,28" og "3" i "3D." |
| \W | Finder enhver ikke-(latinsk) verbal karakter. Svarer til [^A-Za-z0-9_] . For eksempel vil /\W/ og /[^$A-Za-z0-9_]/ matche "%" i "50%." |
Arbejde med regulære udtryk i Javascript
Arbejde med regulære udtryk i Javascript er implementeret ved metoder i String-klassen
exec(regexp) - finder alle matches (indgange i det almindelige mønster) i en streng. Returnerer et array (hvis der er et match) og opdaterer regexp-egenskaben eller null, hvis der ikke findes noget. Med g-modifikatoren - hver gang denne funktion kaldes, vil den returnere det næste match efter den forrige fundet - dette implementeres ved at opretholde et offset-indeks for den sidste søgning.
match(regexp) - find en del af en streng ved hjælp af et mønster. Hvis g-modifikatoren er angivet, returnerer match() en matrix med alle matches eller null (i stedet for en tom matrix). Uden g-modifikatoren fungerer denne funktion som exec();
test(regexp) - funktionen kontrollerer en streng for at matche et mønster. Returnerer sand, hvis der er et match, og falsk hvis der ikke er match.
split(regexp) - Opdeler den streng, den kaldes på, i et array af understrenge, ved at bruge argumentet som afgrænsning.
replace(regexp, mix) - metoden returnerer en modificeret streng i overensstemmelse med skabelonen (regulært udtryk). Den første parameter til regexp kan også være en streng i stedet for et regulært udtryk. Uden g-modifikatoren erstatter metoden i linjen kun den første forekomst; med modifikationen g - sker der en global udskiftning, dvs. alle forekomster i en given linje ændres. mix - erstatningsskabelon, kan acceptere værdierne af en streng, erstatningsskabelon, funktion (funktionsnavn).
Specialtegn i erstatningsstrengen
Udskiftning via funktion
Hvis du angiver en funktion som den anden parameter, udføres den for hvert match. En funktion kan dynamisk generere og returnere en substitutionsstreng. Funktionens første parameter er den fundne understreng. Hvis det første argument, der skal erstattes, er et RegExp-objekt, så indeholder de næste n parametre indlejrede parenteser. De sidste to parametre er positionen i linjen, hvor matchen fandt sted, og selve linjen.