Javascript reguljära uttryck antal tecken. Vanliga uttryck i JavaScript
JavaScript regexp Är en objekttyp som används för att matcha en sekvens av tecken i strängar.
Skapa ditt första regelbundna uttryck
Det finns två sätt att skapa ett regelbundet uttryck: med hjälp av ett ordentligt uttryck bokstavligt eller med en vanlig uttryckskonstruktör. Var och en av dem representerar samma mönster: " c"Följd av" en"Och sedan symbolen" t».
// regex literal är inneslutet i snedstreck (/)
var option1 \u003d / cat /;
// Regelbunden uttryckskonstruktör
var option2 \u003d new RegExp ("cat");
I allmänhet, om regexet förblir konstant, det vill säga inte kommer att förändras, är det bättre att använda regex literal. Om det kommer att förändras eller bero på andra variabler är det bättre att använda en metod med en konstruktör.
RegExp.prototype.test () -metod
Kommer du ihåg när jag sa att vanliga uttryck är föremål? Det betyder att de har ett antal metoder. Den enklaste metoden är JavaScript regexp testvilket returnerar en booleska:
Sant: Strängen innehåller ett vanligt uttrycksmönster.
Falskt: Ingen matchning hittad.
console.log (/cat/.test (“katten säger meow”));
// rätt
console.log (/cat/.test (“hunden säger bark”));
// fel
Grundläggande uttryck Basics Cheat Sheet
Normala uttrycks hemlighet är att memorera typiska karaktärer och grupper. Jag rekommenderar starkt att spendera några timmar på att titta på tabellen nedan och sedan gå tillbaka och lära sig mer.
symboler
- ... - (period) matchar varje enskilt tecken utom linjeskift;
- * - matchar det föregående uttrycket, som upprepas 0 eller flera gånger;
- + - matchar det föregående uttrycket, som upprepas 1 eller flera gånger;
- ? - det föregående uttrycket är valfritt ( matchar 0 eller 1 gånger);
- ^ - matchar början av raden;
- $ - matchar slutet av raden.
Teckengrupper
- d - matchar alla digitala tecken.
- w - matchar alla tecken (siffror, bokstäver eller understreck).
- [XYZ]- en uppsättning tecken. Matchar varje enskilt tecken i parentesuppsättningen. Du kan också ange teckenintervall, till exempel, .
- [XYZ] +- matchar ett tecken från uppsättningen, upprepad en eller flera gånger.
- [^A —Z]- inom en teckenuppsättning "^" används som ett negationstecken. I detta exempel mönstret matchar allt som inte är versaler.
Flags:
Det finns fem valfria flaggor i JavaScript regexp. De kan användas separat eller tillsammans och placeras efter stängningsstrecket. Till exempel: /[ A —Z] / g... Här ger jag bara två flaggor.
g - global sökning.
jag - okänslig sökning i fall.
Ytterligare konstruktioner
(x)- fånga parenteser. Detta uttryck matchar x och kommer ihåg matchningen, så du kan använda det senare.
(?:x)- parenteser som inte fångar in. Uttrycket matchar x, men kommer inte ihåg matchningen.
Matchar bara x om det följs av y.
Vi testar det studerade materialet
Låt oss först testa alla ovanstående. Låt oss säga att vi vill kontrollera en sträng för alla siffror. För detta kan du använda konstruktionen "d".
console.log (/d/.test ("12-34"));
// rätt
Ovanstående kod kommer att gälla om det finns minst en siffra i strängen. Vad händer om du behöver validera en sträng mot formatet? Flera d-tecken kan användas för att definiera formatet:
console.log (/dd-dd/.test ("12-34"));
//rätt
console.log (/dd-dd/.test ("1234"));
//fel
Om det inte spelar någon roll hur siffrorna före och efter "-" -tecknet visas i JavaScript regexp online, kan du använda "+" -tecknet för att indikera att "d" -mönstret inträffar en eller flera gånger:
console.log (/ d + -d + /. test ("12-34"));
// rätt
console.log (/ d + -d + /. test ("1-234"));
// rätt
console.log (/ d + -d + /. test ("- 34"));
// fel
För enkelhetens skull kan du använda parenteser för att gruppera uttryck. Låt oss säga att vi har en kattmåga, och vi vill kontrollera mönstret " mjau"(Mjau):
console.log (/ me + (ow) + w / .test ("meeeeowowoww)));
// rätt
Låt oss ta reda på det.
m \u003d\u003e matcha en bokstav 'm';
e + \u003d\u003e matcha bokstaven "e" en eller flera gånger;
(ow) + \u003d\u003e matchar bokstäverna "ow" en eller flera gånger;
w \u003d\u003e matcha bokstaven 'w';
'M' + 'eeee' + 'owowow' + 'w'.
När operatörer som "+" används direkt efter parenteser påverkar de hela innehållet i parenteserna.
Operatören "? ". Det indikerar att föregående tecken är valfritt. Som ni ser nedan återgår båda testfallen eftersom "s" -tecknen är markerade som valfria.
console.log (/ katter? säger? /i.test ("katten säger meow"));
//rätt
console.log (/ katter? säger? /i.test ("Katterna säger meow"));
//rätt
Om du vill hitta ett backslash-tecken måste du screena det med ett backslash. Detsamma gäller för andra karaktärer som har särskild betydelse, till exempel frågetecknet. Här är ett JavaScriptexempel på hur du hittar dem:
var slashSearch \u003d ///;
var fråga Sök \u003d /? /;
- d Är samma som: varje konstruktion motsvarar en digital symbol.
- w Är det samma som [ A —Za —z 0-9_]: Båda uttrycken matchar varje enskilt alfanumeriskt tecken eller understrukning.
Exempel: lägga till mellanslag i strängar i kamelstil
I det här exemplet är vi väldigt trötta på skrivstilen i kamelen och vi behöver ett sätt att lägga till mellanrum mellan ord. Här är ett exempel:
removeCc ("camelCase") // \u003d\u003e ska returnera "camel Case"
Det finns en enkel lösning med regex. Först måste vi hitta alla stora bokstäver. Detta kan göras med en teckenuppsättning och en global modifierare.
Detta matchar "C" i camelCase
Hur lägger du till ett utrymme före "C"?
Vi måste använda fånga parenteser! De låter dig hitta en match och kom ihåg att den ska användas senare! Använd fånga parenteser för att komma ihåg det stora bokstaven du hittar:
Du kan senare komma åt det fångade värdet så här:
Ovanför använder vi $ 1 för att komma åt det fångade värdet. Förresten, om vi hade två uppsättningar av fånga parenteser, skulle vi använda $ 1 och $ 2 för att hänvisa till de fångade värdena och på liknande sätt för mer fånga parenteser.
Om du behöver använda parenteser men inte behöver fånga det värdet kan du använda parenteser som inte fångar: (?: X). I det här fallet hittas en matchning x, men den kommer inte ihåg.
Låt oss gå tillbaka till den aktuella uppgiften. Hur implementerar vi fånga parenteser? Med JavaScript's regexp byt ut! Vi passerar "$ 1" som det andra argumentet. Det är viktigt att använda citattecken här.
funktion removeCc (str) (
return str.replace (/ () / g, "$ 1");
}
Låt oss titta på koden igen. Vi tar tag i versalerna och ersätter sedan den med samma bokstav. Sätt in ett utrymme i citaten, följt av variabeln $ 1. Som ett resultat får vi ett utrymme efter varje versal.
funktion removeCc (str) (
return str.replace (/ () / g, "$ 1");
}
removeCc ("camelCase") // "camel Case"
removeCc ("helloWorldItIsMe") // "hello World It Is Me"
Exempel: ta bort stora bokstäver
Vi har nu en sträng med ett gäng onödiga versaler. Har du gissat hur du tar bort dem? Först måste vi välja alla versaler. Sedan använder vi en teckenuppsättning med den globala modifieraren:
Vi kommer att använda ersättningsmetoden igen, men hur gör vi en liten bokstav den här gången?
funktion lägre fall (str) (
return str.replace (// g, ???);
}
Tips: i metoden ersätt () kan du ange en funktion som den andra parametern.
Vi kommer att använda en pilfunktion för att undvika att fånga värdet på den hittade matchningen. När du använder funktionen i javaScript-metod regexp ersätt denna funktion kommer att kallas efter att ha hittat en matchning och resultatet av funktionen används som ersättningssträng. Ännu bättre, om matchen är global och flera matchningar hittas, kommer funktionen att kallas för varje matchning som hittas.
funktion lägre fall (str) (
return str.replace (// g, (u) \u003d\u003e u.toLowerCase ());
}
lowCase ("kamelväska") // "kamelkasse"
lowCase ("hej världen är jag") // "hej värld det är jag"
Exempel: konvertera den första bokstaven till versaler
kapitalisera ("camel case") // \u003d\u003e ska returnera "Camel case"
Låt oss använda funktionen i metoden ersätt () igen. Men den här gången behöver vi bara söka efter det första tecknet i strängen. Kom ihåg att symbolen "^" används för detta.
Låt oss stanna vid "^" -symbolen för en sekund. Kom ihåg exemplet som givits tidigare:
console.log (/cat/.test ("katten säger meow"));
//rätt
När du lägger till tecknet "^" returnerar funktionen inte längre sant eftersom ordet "katt" inte är i början av raden.
RegExp-klassen i JavaScript är ett vanligt uttryck - ett objekt som beskriver ett teckenmönster. RegExp-objekt skapas vanligtvis med hjälp av den speciella bokstavssyntaxen nedan, men de kan också skapas med RegExp () -konstruktorn.
Syntax
// med speciell bokstavlig syntax var regex \u003d / mönster / flaggor; // med konstruktören var regex \u003d new RegExp ("mönster", "flaggor"); var regex \u003d new RegExp (/ mönster /, "flaggor");Parametervärden:
Vanliga uttrycksflaggor
| Flagga | Beskrivning |
|---|---|
| g | Låter dig hitta alla matcher snarare än att stoppa efter den första matchen ( global matchflagga). |
| jag | Tillåter match-okänslig matchning ( ignorera fall flagga). |
| m | Matchningen görs över flera rader. Start- och sluttecken (^ och $) bearbetas på flera rader, det vill säga matchning sker i början eller slutet av varje rad (\\ n eller \\ r avgränsare), och inte bara i början eller slutet av hela raden ( multiline flagga). |
| u | Mönstret tolkas som en sekvens av Unicode-kodpunkter ( unicode flagga). |
| y | Matchen utförs av det index som pekas av den senaste Index-egenskapen i detta reguljära uttryck, medan matchen inte utförs vid ett senare eller tidigare index ( klibbig flagga). |
Teckenuppsättningar
metatecken
| Symbol | Beskrivning |
|---|---|
| . | Hitta en annan karaktär än en karaktär ny linje, eller ett slutkaraktärstecken (\\ n, \\ r, \\ u2028 eller \\ u2029). |
| \\ d | Hitta ett siffratecken i det grundläggande latinska alfabetet. Motsvarande med att använda en teckenuppsättning. |
| \\ D | Hitta alla tecken som inte är en siffra i det grundläggande latinska alfabetet. Motsvarande med teckenuppsättningen [^ 0-9]. |
| \\ s | Finns en enda vitrumstecken. Whitespace betyder utrymme, flik, sidflöde, radflöde och andra. vitrumstecken Unicode. Stämmer med teckenuppsättningen [\\ f \\ n \\ r \\ t \\ v \\ u00a0 \\ u1680 \\ u180e \\ u2000 \\ u2001 \\ u2002 \\ u2003 \\ u2004 \\ u2005 \\ u2006 \\ u2007 \\ u2008 \\ u2009 \\ u200a \\ u2028 \\ u2029 \\ u202f \\ u205f \\ u3000]. |
| \\ S | Hitta en enda karaktär som inte är mellanrum. Whitespace refererar till mellanslag, flik, sidflöde, radflöde och andra Unicode-blankstegstecken. Motsvarar [^ \\ f \\ n \\ r \\ t \\ v \\ u00a0 \\ u1680 \\ u180e \\ u2000 \\ u2001 \\ u2002 \\ u2003 \\ u2004 \\ u2005 \\ u2006 \\ u2007 \\ u2008 \\ u2009 \\ u200a \\ U2028 \\ u2029 \\ u202f \\ u205f \\ u3000]. |
| [\\ b] | Hitta backspace-karaktären (specialtecken \\ b, U + 0008). |
| \0 | Hitta tecknet 0 (noll). |
| \\ n | Hitta nylinjekaraktären. |
| \\ f | Hitta sidflödeskaraktären. |
| r | Finns en karaktär med returvagn. |
| \\ t | Hitta ett horisontellt flikkaraktär. |
| \\ v | Hitta ett vertikalt flikkaraktär. |
| \\ w | Hitta alla alfanumeriska tecken i det grundläggande latinska alfabetet, inklusive understreck. Likvärdigt med en teckenuppsättning. |
| \\ W | Hitta alla tecken som inte är ett grundläggande latinska alfabetstecken. Likvärdigt med teckenuppsättningen [^ a-Za-z0-9_]. |
| \\ cX | Hitta ett kontrolltecken i en sträng. Där X är ett brev från A till Z. Till exempel står / \\ cM / för Ctrl-M. |
| \\ xhh | Låter dig hitta ett tecken med hexadecimalt värde (hh är ett tvåsiffrigt hexadecimalt värde). |
| \\ uhhhh | Hitta ett tecken med UTF-16-kodning (hhhh är ett fyrsiffrigt hexadecimalt värde). |
| \\ u (hhhh) eller \\ u (hhhhh) | Hitta ett tecken med ett Unicode-värde U + hhhh eller U + hhhhh (hexadecimalt värde). Endast när u-flaggan är inställd. |
| \ | Indikerar att nästa tecken är speciellt och inte bör tolkas bokstavligen. För tecken som vanligtvis tolkas på ett speciellt sätt, indikerar att nästa tecken inte är speciellt och bör tolkas bokstavligen. |
begränsningar
Kvantifierare
| Symbol | Beskrivning |
|---|---|
| n * | Matchning sker på alla strängar som innehåller noll eller fler förekomster av ett tecken n. |
| n + | Matchning sker med alla strängar som innehåller minst ett tecken n. |
| n? | Matchning sker på valfri linje före elementet n noll eller en gång. |
| n (x) | Matchar alla strängar som innehåller en sekvens med tecken n ett visst antal gånger x. X |
| n (x,) | x förekomster av föregående element n. X måste vara ett positivt heltal. |
| n (x, y) | Matchar vilken rad som innehåller minst xmen inte mer än med y förekomster av föregående element n. X och y måste vara positiva heltal. |
| n *? n +? n ?? n (x)? n (x,)? n (x, y)? | Matchning sker analogt med kvantifierare *, + ,? och (...) emellertid sökningen går den minsta möjliga matchen. Standard är "girigt" -läge ,? i slutet av kvantifieraren kan du ange ett "icke-girigt" -läge där matchningen upprepas så få gånger som möjligt. |
| x (? \u003d y) | Låter matcha x, bara om x skall y. |
| x (?! y) | Låter matcha x, bara om x gör det inte y. |
| x | y | Jämförelsen sker med något av de angivna alternativen. |
Gruppering och bakåtlänkar
| Symbol | Beskrivning |
|---|---|
| (X) | Hitta en symbol x och kom ihåg resultatet av matchen ("fånga parentes"). Den matchade substringen kan kallas från elementen i den resulterande matrisen ..., [n] eller från egenskaperna hos det fördefinierade RegExp $ 1 ..., $ 9-objektet. |
| (?: x) | Hitta en symbol x, men kommer inte ihåg resultatet av matchen ("icke-fånga parenteser"). Den matchade substrängen kan inte kallas från elementen i den resulterande matrisen ..., [n] eller från egenskaperna för det fördefinierade RegExp $ 1 ..., $ 9-objektet. |
| \\ n | En bakre referens till den sista substrängen som matchar den n: e substringen i parentes i det reguljära uttrycket (parentes är numrerade från vänster till höger). n måste vara ett positivt heltal. |
Vanliga uttryck är ett språk som beskriver strängmönster baserat på metatecken. En metatecken är ett tecken i ett regelbundet uttryck som beskriver någon teckenklass i en sträng, indikerar positionen för en substring, indikerar antalet upprepningar eller grupperar tecken i en substring. Exempelvis beskriver \\ d metakarakter siffror och $ anger slutet på en sträng. Vanliga uttryck kan också innehålla vanliga tecken som beskriver sig själva. Uppsättningen och betydelsen av metatecken i vanliga uttryck beskrivs av PCRE-standarden, varav de flesta stöds i JS.
Omfattningen av reguljära uttryck
Vanliga uttryck används vanligtvis för följande uppgifter:
- Jämförelse... Målet med denna uppgift är att ta reda på om en viss text matchar ett givet regelbundet uttryck.
- Sök... Med hjälp av reguljära uttryck är det bekvämt att hitta motsvarande underlag och extrahera dem från texten.
- Ersättning... Regelbundna uttryck hjälper ofta inte bara att hitta, utan ersätter också en substring i en text som matchar ett vanligt uttryck.
I slutändan kan du använda vanliga uttryck, till exempel:
- Kontrollera korrektheten för att fylla i användardata i formuläret.
- Hitta en länk till en bild i den text som användaren har matat in för den efterföljande automatiska bifogningen till meddelandet.
- Ta bort HTML-taggar från texten.
- Kontrollera koden före sammanställning för enkla syntaxfel.
Funktioner i reguljära uttryck i JS. Ordinarie uttryckslitteratur
Huvuddraget med reguljära uttryck i JS är att det finns en separat typ av bokstäver för dem. Precis som strängbokstäver är inneslutna i citat, är ordentliga uttryckslitteraler inneslutna i snitt (/). Således kan JS-kod innehålla uttryck för formen:
console.log (typeof / tcoder /); // objekt
Faktum är att det reguljära uttrycket som definieras i strängen
var mönster \u003d ny RegExp ("tcoder");
Denna skapningsmetod används vanligtvis när du behöver använda variabler i ett reguljärt uttryck eller skapa ett regelbundet uttryck dynamiskt. I alla andra fall används regelbundna uttryckslitteraler på grund av den kortare syntaxen och bristen på behovet av att dessutom undkomma vissa tecken.
Vanliga uttryckstecken
Alla alfanumeriska tecken i vanliga uttryck är icke-metatecken och beskriver sig själva. Detta betyder att det vanliga uttrycket / tcoder / matchar tringkodens substring. I vanliga uttryck kan du också ange icke-alfabetiska tecken, till exempel: radmatning (\\ n), flik (\\ t) och så vidare. Alla dessa symboler motsvarar också sig själva. Att föregå ett alfabetiskt tecken med ett motstreck (\\) gör det till en metatecken, om någon. Till exempel blir det alfabetiska tecknet "d" ett metatecken som beskriver siffror när det föregås av en snedstreck (\\ d).
Karaktär klasser
Enstaka tecken i vanliga uttryck kan grupperas i klasser med fyrkantiga parenteser. En klass som skapats på detta sätt matchar alla symboler som ingår i den. Till exempel det vanliga uttrycket // kommer att matcha bokstäverna "t", "c", "o", "d", "e", "r".
Klasser kan också ange en rad tecken med bindestreck. Till exempel motsvarar klass klass. Observera att några av metatecken för reguljära uttryck redan beskriver teckenklasser. Till exempel är \\ d metakaraktäret lika med klass. Observera att metatecken som beskriver teckenklasser också kan inkluderas i klasser. Exempelvis motsvarar klassen [\\ da-f] siffror och bokstäver "a", "b", "d", "e", "f", det vill säga vilken som helst hexadecimal karaktär.
Det är också möjligt att beskriva en karaktärsklass genom att ange tecken som inte ska inkluderas i den. Detta görs med ^ metacharacter. Till exempel kommer klass [^ \\ d] att matcha alla tecken utom en siffra.
upprepningar
Nu kan vi beskriva, säga, ett decimaltal med valfri längd, helt enkelt genom att skriva så många \\ d metatecken i rad som det finns siffror i detta nummer. Håller med om att detta tillvägagångssätt inte är särskilt bekvämt. Dessutom kan vi inte beskriva intervallet för det nödvändiga antalet repetitioner. Vi kan till exempel inte beskriva ett nummer med en eller två siffror. Lyckligtvis är det i regelbundna uttryck möjligt att beskriva repetitionsintervall med metatecken. För att göra detta, efter tecknet, behöver du bara ange repetitionsområdet lockiga hängslen... Till exempel det vanliga uttrycket / tco (1, 3) der / kommer att matcha strängarna "tcoder", "tcooder" och "tcooder". Om vi \u200b\u200butelämnar maxbelopp repetitioner, lämnar ett komma och det minsta antalet repetitioner, då kan du ange antalet repetitioner större än det angivna. Till exempel det vanliga uttrycket / bo (2,) bs / kommer att matcha strängarna "boobs", "booobs", "boooobs" och så vidare med valfritt antal bokstäver "o" minst två.
Om du utelämnar komma i lockiga hängslen, anger du bara ett nummer, kommer det att ange det exakta antalet repetitioner. Till exempel det vanliga uttrycket / \\ d (5) / motsvarar femsiffriga siffror.
Vissa repetitionsintervall används ganska ofta och har sina egna metatecken.
Giriga upprepningar
Ovanstående syntax beskriver det maximala antalet repetitioner, det vill säga av alla möjliga antal repetitioner, vars antal ligger inom det angivna intervallet, det maximala väljs. Sådana upprepningar kallas giriga. Detta betyder att det reguljära uttrycket / \\ d + / i strängen ja !! 111 kommer att matcha substrängen "111", inte "11" eller "1", även om metakarakter "+" beskriver en eller flera upprepningar.
Om du vill implementera icke-girig repetition, det vill säga välja det minsta möjliga antalet repetitioner från det angivna intervallet, lägg bara "?" efter en rad upprepningar. Till exempel det vanliga uttrycket / \\ d +? / strängen "ja !! 111" kommer att matcha substrängen "1" och det reguljära uttrycket / \\ d (2,) / substansen "11" matchar på samma linje.
Det är värt att notera ett viktigt inslag i icke-giriga upprepningar. Tänk på ett regelbundet uttryck / bo (2,)? bs /... I raden "jag gillar stora boooobs" kommer den att matcha, som i fallet med giriga upprepningar, substringboooobs, inte boobs, som man kanske tror. Faktum är att ett vanligt uttryck inte kan matcha flera underlag som finns på olika platser i strängen i en matchning. Det vill säga, vårt regelbundna uttryck kan inte matcha underlagen "boo" och "bs" limmade i en rad.
alternativ
I vanliga uttryck kan du också använda alternativ - beskriv en uppsättning strängar som matchar antingen en eller annan del av det reguljära uttrycket. Sådana delar kallas alternativ och separeras med en vertikal stapel. Till exempel det vanliga uttrycket / två | två gånger | \\ 2 / kan matcha antingen substring "två" eller substring "två gånger" eller substring "2". Alternativkedjan behandlas från vänster till höger tills den första matchen och endast en substring som beskriver endast ett alternativ kan matcha. Till exempel det vanliga uttrycket / java | script / i strängen "Jag gillar javascript" kommer bara substansen "java" att matcha.
grupperingar
Om du vill behandla flera tecken som en helhet när du använder repetitionsintervall, teckenklasser och mer, ska du helt enkelt bifoga dem i parenteser. Till exempel det vanliga uttrycket / true (kodare)? / kommer att matcha strängarna "truecoder" och "true".
länkar
Utöver det faktum att parenteser kombinerar tecken i ett regelbundet uttryck i en enda helhet, kan hänvisas till motsvarande substring genom att helt enkelt ange antalet vänstra parenteser efter snedstrecket från paret inom parentes som omger det. Parenteserna är numrerade från vänster till höger, börjar på en. Till exempel i ett vanligt uttryck / (ett två tre Fyra) / \\ 1 hänvisar till en, \\ 2 hänvisar till "två", \\ 3 hänvisar till "tre", \\ 4 avser "fyra". Som ett exempel på att använda sådana länkar, låt oss ge ett regelbundet uttryck / (\\ d) \\ 1 /, vilket motsvarar tvåsiffriga siffror med samma siffror. Viktig begränsning av användningen bakåtlänkar är omöjligt att använda dem i klasser, det vill säga för att beskriva ett tvåsiffrigt nummer med olika siffror med ett regelbundet uttryck / (\\ d) [^ \\ 1] / det är omöjligt.
Parenteser som inte är minne
Det är ofta nödvändigt att helt enkelt gruppera symboler, men inte skapa en länk. I det här fallet kan du skriva ?: Rätt efter den vänstra gruppens parentes. Till exempel i ett vanligt uttryck / (ett två tre) / \\ 2 pekar på "tre".
Sådana konsoler kallas ibland icke minnesvärd. De har en annan viktig funktion, som vi kommer att prata om i nästa lektion.
Position indikering
I vanliga uttryck finns det också metatecken som indikerar en position i en sträng. De vanligaste tecknen som används är ^, $ som indikerar början och slutet på en rad. Till exempel det vanliga uttrycket /\..+$/ matchar tillägg i filnamn och det vanliga uttrycket / ^ \\ d / den första siffran i raden, om någon.
Positiva och negativa lookahead-kontroller
Vanliga uttryck kan också användas för att beskriva en substring följt eller inte av en substring som beskrivs med ett annat mönster. Till exempel behöver vi bara hitta ordet java om det följs av "skript". Denna uppgift kan lösas med ett vanligt uttryck / java (? \u003d script) /... Om vi \u200b\u200bbehöver beskriva substrängen "java" som inte följs av skriptet, kan vi använda det vanliga uttrycket / java (?! skript) /.
Låt oss samla allt vi talade om ovan på en platta.
| Symbol | Värde |
|---|---|
| a | b | Matchar antingen a eller u. |
| (…) | Gruppering av konsoler. Du kan också hänvisa till en substring som matchar mönstret inom parenteser. |
| (?:…) | Endast gruppering, ingen länk. |
| \\ n | Hänvisning till en substring som matchar det nionde mönstret. |
| ^ | Början av inmatningsdata eller början av raden. |
| $ | Slut på inmatningen eller slutet på raden. |
| a (? \u003d b) | Matchar den substring som beskrivs med mönster a endast om den följs av den substring som beskrivs med mönster b. |
| a (?! b) | Matchar den substring som mönstret a beskriver endast om det följs av inte följt av en substring som beskrivs med mönster b. |
flaggor
Och slutligen det sista elementet i syntaxen för reguljärt uttryck. Flaggor anger matchningsregler som gäller hela reguljära uttrycket. Till skillnad från alla andra element skrivs syntax med reguljärt uttryck omedelbart efter det ordinarie uttrycket bokstavligt, eller överförs i en sträng som den andra parametern till objektkonstruktören RegExp.
Det finns bara tre vanliga uttrycksflaggor i JavaScript:
jag - När du specificerar denna flagga beaktas inte fall, det är till exempel ett regelbundet uttryck \\ javascript \\ i kommer att matcha strängarna "javascript", "JavaScript", "JAVASCRIPT", "jAvAScript", etc.
m - denna flagga möjliggör flersökningssökning. Detta betyder att om texten innehåller radmatningstecken och denna flagga är inställd, kommer ^ och $ -tecknen, utöver början och slutet på hela texten, också att motsvara början och slutet på varje rad i texten. Till exempel det vanliga uttrycket / linje $ / m matchar substrängen "rad", både i strängen "första raden" och i strängen "en \\ n andra rad \\ ntwo".
g - aktiverar global sökning, det vill säga det vanliga uttrycket, om denna flagga är aktiverad, kommer att matcha alla underlag som matchar den, och inte bara den första, som i fallet om denna flagga saknas.
Flaggor kan kombineras med varandra i valfri ordning, det vill säga \\ tcoder \\ mig, \\ tcоder \\ gim, \\ tocder \\ gmi och så vidare, de är samma sak. Flaggens ordning spelar inte heller någon roll om du skickar dem i en sträng som det andra argumentet till objektets konstruktör RegExp, dvs ny RegExp ("tcoder", "im") och ny RegExp ("tcoder", "im") samma sak.
ZY
Regelbundna uttryck är mycket kraftfulla och praktiskt verktyg för att arbeta med strängar, vilket gör att du kan minska hundratals kodrader till ett enda uttryck. Tyvärr är deras syntax ibland för komplicerad och svår att läsa, och till och med den mest erfarna utvecklaren kan glömma vilket ganska komplicerat regelbundet uttryck som han skrev för ett par dagar sedan, om han inte kommenterade det. Av dessa skäl är det ibland värt att dikta regelbundna uttryck till förmån för regelbundna metoder för att arbeta med strängar.
Vanliga uttryck
Vanligt uttryck är ett objekt som beskriver ett teckenmönster. RegExp-klassen i JavaScript representerar reguljära uttryck, och String- och RegExp-klassobjekten definierar metoder som använder reguljära uttryck för att utföra mönstermatchning och textbytta sökningar. Grammatiken för det vanliga uttrycket i JavaScript innehåller en ganska komplett delmängd av syntaxen för det vanliga uttrycket som används i Perl 5, så om du har erfarenhet av Perl-språket kan du enkelt beskriva mönster i JavaScript-program.
Bland funktionerna i reguljära uttryck perl-språksom inte stöds i ECMAScript inkluderar flaggorna s (enkelrad) och x (utvidgad syntax); flygsekvenser \\ a, \\ e, \\ l, \\ u, \\ L, \\ U, \\ E, \\ Q, \\ A, \\ Z, \\ z och \\ G och andra utökade konstruktioner som börjar med (?.
Definiera vanliga uttryck
I JavaScript vanligt uttryck representeras av objekt RegExp... RegExp-objekt kan skapas med RegExp () -konstruktören, men oftare skapas de med speciell bokstavlig syntax. Precis som strängbokstäver anges som tecken som är bifogade i citattecken, anges ordinarie uttryckslitteratur som tecken som är inneslutna i ett snedstreck (/) -par. Således kan JavaScript-kod innehålla strängar som denna:
Var mönster \u003d / s $ /;
Den här raden skapar ett nytt RegExp-objekt och tilldelar det till mönster. Detta objekt RegExp söker efter alla rader som slutar med tecknet "s". Samma regelbundna uttryck kan definieras med RegExp () -konstruktorn:
Varmönster \u003d new RegExp ("s $");
En regex-mönsterspecifikation består av en sekvens av tecken. De flesta tecken, inklusive alla alfanumeriska tecken, beskriver bokstavligen de tecken som måste vara närvarande. Det vill säga det reguljära uttrycket / java / matchar alla strängar som innehåller substrängen "java".
De andra karaktärerna i reguljära uttryck är inte avsedda att användas för att hitta deras exakta ekvivalenter, utan har snarare särskild betydelse. Till exempel innehåller det vanliga uttrycket / s $ / två tecken. De första s indikerar en sökning efter en bokstavlig karaktär. För det andra är $ en speciell metatecken som anger slutet på en rad. Således matchar detta regex alla sträng som slutar med s.
Följande avsnitt beskriver de olika tecken och metatecken som används i vanliga uttryck i JavaScript.
Bokstavliga karaktärer
Som noterats tidigare matchar alla alfabetiska tecken och siffror i regelbundna uttryck. Den vanliga uttryckssyntaxen i JavaScript stöder också möjligheten att ange vissa tecken som inte är alfabetiska med hjälp av flyktningssekvenser som börjar med ett backslashtecken (\\) Till exempel matchar \\ n en radmatningstecken. Dessa symboler listas i tabellen nedan:
Vissa skiljetecken har speciella betydelser i vanliga uttryck:
^ $ . * + ? = ! : | \ / () { } -
Betydelsen av dessa symboler förklaras i följande avsnitt. Vissa av dem har speciell betydelse endast i vissa regex-sammanhang, medan de i andra sammanhang tas bokstavligen. För att inkludera någon av dessa karaktärer bokstavligen i ett vanligt uttryck måste du emellertid bero på det med ett motsnitt. Andra karaktärer, som citat och @, har ingen speciell betydelse och matchar helt enkelt sig själva i vanliga uttryck.
Om du inte kommer ihåg exakt vilket tecken som ska föregås av ett \\, kan du säkert sätta ett bakslag innan någon av tecknen. Tänk emellertid på att många bokstäver och siffror, tillsammans med snedstreckens karaktär, förvärvar speciell betydelseså bokstäverna och siffrorna du letar efter bokstavligen får inte föregås av ett \\. För att inkludera själva backslash-karaktären i regexp måste du självklart lägga ett annat backslash-karaktär framför det. Följande reguljära uttryck matchar till exempel alla strängar som innehåller ett backslashtecken: / \\\\ /.
Karaktär klasser
Individuella bokstavliga karaktärer kan kombineras till karaktärsklasser genom att lägga in dem i fyrkantiga parenteser. En karaktärsklass matchar alla karaktärer som ingår i den här klassen. Därför matchar det reguljära uttrycket // ett av tecknen a, b eller c.
Negerade teckenklasser kan också definieras för att matcha alla andra tecken än de som anges i parenteser. En negativt teckenklass specificeras av ^ som det första tecknet som följer den vänstra parentesen. Det reguljära uttrycket / [^ abc] / matchar alla andra tecken än a, b eller c. I teckenklasser kan en rad tecken specificeras med bindestreck. Alla små bokstäver i det latinska alfabetet söks efter med uttrycket //, och alla bokstäver eller siffror från det latinska teckenuppsättningen kan hittas med uttrycket //.
Vissa teckenklasser används särskilt ofta, varför Javas JavaScript-syntax med regelbundna uttryck innehåller specialtecken och flykt-sekvenser för att beteckna dem. Till exempel matchar \\ whitespace, tabs och eventuella Unicode-whitespace-tecken och \\ S matchar alla whitespace-tecken som inte är Unicode.
Tabellen nedan visar dessa specialtecken och syntaxen för teckenklasserna. (Observera att en del av karaktärsklassen-flygsekvenser bara matchar ASCII-tecken och inte utvidgas till att fungera med Unicode-tecken. Du kan uttryckligen definiera dina egna Unicode-teckenklasser, till exempel, / [\\ u0400- \\ u04FF] / matchar alla tecken cyrillic.)
| Symbol | Överensstämmelse |
|---|---|
| [...] | Någon av karaktärerna inom parentes |
| [^...] | Alla tecken som inte finns inom parentes |
| . | Alla andra tecken än en ny linje eller annan Unicode-strängavgränsare |
| \\ w | Alla ASCII-texttecken. Ekvivalent med |
| \\ W | Alla tecken som inte är ett ASCII-texttecken. Motsvarande med [^ a-zA-Z0-9_] |
| \\ s | Alla Unicode-blankstegstecken |
| \\ S | Alla tecken som inte är whitespace från Unicode-uppsättningen. Observera att \\ w och \\ S inte är desamma |
| \\ d | Alla ASCII-siffror. Ekvivalent med |
| \\ D | Alla andra tecken än ASCII-siffror. Motsvarande med [^ 0-9] |
| [\\ b] | Bokstavstecken bokstavligen |
Observera att flygsekvenser speciella karaktärer klasser kan vara i fyrkantiga parenteser. \\ s matchar valfritt tecken, och \\ d matchar vilken siffra som helst, därför / [\\ s \\ d] / matchar alla whitespace-tecken eller siffror.
Upprepande
Med vår kunskap om syntaxen för reguljära uttryck hittills kan vi beskriva ett tvåsiffrigt nummer som / \\ d \\ d / eller fyrsiffriga siffror som / \\ d \\ d \\ d \\ d /, men vi kan till exempel inte beskriva ett nummer, valfritt antal siffror eller en sträng med tre bokstäver följt av en valfri siffra. Dessa mer komplexa mönster använder regex-syntax för att indikera hur många gånger som kan upprepas givet element vanligt uttryck.
Upprepningssymboler följer alltid det mönster som de gäller. Vissa typer av upprepningar används ganska ofta, och det finns speciella symboler för att indikera dessa fall. Till exempel matchar + ett eller flera instanser av föregående mönster. Följande tabell ger en sammanfattning av repetitionssyntaxen:
Följande rader visar några exempel:
Varmönster \u003d / \\ d (2,4) /; // Matchar ett två- till fyrsiffrigt talmönster \u003d / \\ w (3) \\ d? /; // Matchar exakt tre ordtecken och ett valfritt siffermönster \u003d / \\ s + java \\ s + /; // Matchar ordet "java" med ett eller flera mellanslag // före och efter det mönster \u003d / [^ (] * /; // Matchar noll eller flera andra tecken än den öppna parentesen
Var försiktig när du använder repetitionstecken * och?. De kan motsvara frånvaron av det mönster som anges före dem och därför frånvaron av symboler. Till exempel matchar det reguljära uttrycket / a * / strängen "bbbb" eftersom det inte innehåller ett tecken.
Repetitionstecken som anges i tabellen motsvarar det maximala antalet repetitioner som kan användas för att söka efter efterföljande delar av det reguljära uttrycket. Vi säger att detta är "giriga" upprepningar. Det är också möjligt att genomföra repetitioner på ett icke-girigt sätt. Det räcker med att ange efter symbolen (eller symbolerna) för repetitionen frågetecken: ??, +?, *? eller till och med (1,5)?.
Till exempel matchar det reguljära uttrycket / a + / ett eller flera instanser av bokstaven a. Tillämpas på strängen "aaa", det matchar alla tre bokstäver. Å andra sidan, / a +? / Matchar en eller flera instanser av bokstaven a och väljer minst möjliga antal tecken. Tillämpad på samma rad matchar detta mönster endast den första bokstaven a.
En "osäker" upprepning ger inte alltid det förväntade resultatet. Tänk på mönstret / a + b /, som matchar ett eller flera, följt av ett b. När den används på strängen "aaab" matchar den hela strängen.
Låt oss nu kolla den "icke-giriga" versionen av / a +? B /. Man skulle tro att det borde matcha tecknet b, föregått av endast ett tecken a. Om den tillämpas på samma sträng förväntas "aaab" matcha singeln a och den sista b. Men i själva verket matchar hela strängen detta mönster, som i fallet med den "giriga" versionen. Poängen är att en regelbunden uttryckssökning utförs genom att hitta den första positionen i strängen från vilken en matchning blir möjlig. Eftersom en matchning är möjlig från strängets första tecken övervägs inte ens kortare matchningar som börjar med efterföljande tecken.
Alternativ, gruppering och länkar
Den ordinarie uttrycksgrammatiken innehåller specialtecken för att definiera alternativ, gruppera subexpressions och referenser till tidigare subexpressions. Rörsymbol | tjänar till att separera alternativ. Till exempel matchar / ab | cd | ef / antingen strängen "ab", eller strängen "cd", eller strängen "ef", och mönstret / \\ d (3) | (4) / matchar antingen tre siffror eller fyra små bokstäver ...
Observera att alternativ behandlas från vänster till höger tills en matchning hittas. Om en matchning hittas med det vänstra alternativet ignoreras det högra, även om en "bättre" matchning kan uppnås. Därför, när mönstret / a | ab / tillämpas på strängen "ab", kommer det bara att matcha det första tecknet.
Parenteser har flera betydelser i vanliga uttryck. En av dem är gruppering enskilda element till en subexpression, så att elementen när du använder specialtecknen |, *, + ,? och andra behandlas som en helhet. Till exempel, / java (skript)? / Matchar ordet "java" följt av valfritt ord "skript", och / (ab | cd) + | ef) / matchar antingen strängen "ef" eller en eller flera upprepningar av samma från strängarna "ab" eller "cd".
En annan användning av parenteser i reguljära uttryck är att definiera undermönster i ett mönster. När en regelbunden uttrycksmatchning hittas i målsträngen kan du extrahera den del av målsträngen som matchar en specifik parentesformad delmönster.
Anta att du vill söka efter en eller flera små bokstäver följt av ett eller flera siffror. För att göra detta kan du använda mönstret / + \\ d + /. Men antar också att vi bara vill ha siffrorna i slutet av varje match. Om du lägger denna del av mönstret inom parenteser (/ + (\\ d +) /), kan du extrahera siffror från alla matchningar vi hittar. Hur detta görs kommer att beskrivas nedan.
Relaterat till detta är en annan användning av parenteserade subexpressions, så att du kan hänvisa till subexpressions från föregående del av samma regelbundna uttryck. Detta uppnås genom att ange en eller flera siffror efter \\. Siffrorna hänvisar till positionen för den parenteserade subexpressionen inom det reguljära uttrycket. Exempelvis hänvisar \\ 1 till den första subexpressionen och \\ 3 hänvisar till den tredje. Observera att subexpressions kan häckas i varandra, så att den vänstra parentespositionen används i räkningen. I följande regelbundna uttryck kommer till exempel en kapslad subexpression-referens (cript) att se ut som \\ 2:
/ (ava (cript)?) \\ sis \\ s (kul \\ w *) /
En hänvisning till en tidigare subexpression pekar inte på mönstret för den subexpressionen, utan till den hittade texten som matchar det mönstret. Därför kan länkar användas för att införa en begränsning som väljer delar av en sträng som innehåller exakt samma tecken. Till exempel matchar följande regex noll eller fler tecken inom enstaka eller dubbla citat... Det kräver emellertid inte öppnings- och stängningskurser för att matcha varandra (dvs att båda citaten är enkla eller dubbla):
/[""][^""]*[""]/
Vi kan kräva citattecken för att matcha med följande länk:
Här \\ 1 matchar den första subexpressionen. I det här exemplet sätter länken begränsningen att det slutande citattecknet matchar öppningscitationstecknet. Denna regex tillåter inte enstaka citat i dubbla citat, och vice versa.
Det är också möjligt att gruppera element i ett reguljärt uttryck utan att skapa en numrerad referens till dessa element. Istället för att helt enkelt gruppera element mellan (och) börjar du gruppen med (?: Och avsluta den med). Tänk till exempel på följande mönster:
/ (ava (?: cript)?) \\ sis \\ s (kul \\ w *) /
Här behövs subexpression (?: Cript) endast för gruppering, så att repetitionstecken kan tillämpas på gruppen. Dessa modifierade parenteser skapar inte en länk, så i detta regex hänvisar \\ 2 till text som matchar mönstret (fun \\ w *).
Följande tabell visar alternativ, gruppering och referensoperatörer i regelbundna uttryck:
| Symbol | Värde |
|---|---|
| | | Alternativ. Matchar antingen subexpression till vänster eller subexpression till höger. |
| (...) | Gruppering. Grupperar element i en enda enhet som kan användas med tecknen *, +,?, | etc. Kommer också ihåg symboler som motsvarar denna grupp för användning i efterföljande länkar. |
| (?:...) | Endast gruppering. Grupperar element i en enda helhet, men kommer inte ihåg symbolerna som motsvarar denna grupp. |
| \\ siffra | Matchar samma tecken som hittades när du matchade gruppen med nummernummer. Grupper är subexpressions inom (eventuellt kapslade) parenteser. Gruppnummer tilldelas genom att räkna vänsterparenteser från vänster till höger. Grupper bildade med symboler (?: Är inte numrerade. |
Ange matchpositionen
Som beskrivits tidigare matchar många regexp-element ett tecken per sträng. Till exempel matchar \\ ett blankstegstecken. Andra regelbundna uttryckselement matchar positionerna mellan tecken, inte själva tecknen. Till exempel matchar \\ b en ordgräns - gränsen mellan \\ w (ASCII-texttecken) och \\ W (icke-texttecken), eller gränsen mellan ett ASCII-texttecken och början eller slutet av en rad.
Element som \\ b definierar inga tecken som måste finnas i den hittade strängen, men de definierar giltiga positioner för matchning. Dessa element kallas ibland regexförankringselement eftersom de förankrar mönstret till en specifik position i strängen. De vanligaste ankarelementen som används är ^ och $, som förankrar mönster till början och slutet av en linje.
Till exempel kan ordet "JavaScript" på sin egen rad hittas med det vanliga uttrycket / ^ JavaScript $ /. Att hitta separat ord "Java" (och inte ett prefix, till exempel i ordet "JavaScript"), kan du försöka använda mönstret / \\ sJava \\ s /, som kräver ett mellanrum före och efter ordet.
Men denna lösning ger två problem. Först kommer det bara att hitta ordet "Java" om det är omgivet av utrymmen på båda sidor, och det kan inte hitta det i början eller slutet av raden. För det andra, när detta mönster inte matchar, kommer strängen som den returnerar att innehålla ledande och efterföljande utrymmen, vilket inte är precis vad vi vill ha. Så istället för ett mönster som matchar blanksteg, använder vi ett mönster (eller ankare) som matchar ordgränserna \\ b. Följande uttryck kommer att visa sig: / \\ bJava \\ b /.
Förankringselementet \\ B matchar en position som inte är en ordgräns. Det vill säga mönstret / \\ Bcript / kommer att matcha orden "JavaScript" och "postscript" och kommer inte att matcha orden "script" eller "Scripting".
Godtyckliga reguljära uttryck kan också användas som förankringsvillkor. Om du sätter ett uttryck mellan tecknen (? \u003d Och) förvandlas det till en lookahead-matchning mot efterföljande tecken, vilket kräver att dessa tecken matchar det angivna mönstret, men inte inkluderas i matchsträngen.
För att matcha namnet på ett vanligt programmeringsspråk följt av en kolon kan du till exempel använda uttrycket / ava (cript)? (? \u003d \\ :) /. Detta mönster matchar ordet "JavaScript" i raden "JavaScript: The Definitive Guide", men det kommer inte att matcha ordet "Java" i raden "Java i ett nötskal" eftersom det inte följs av en kolon.
Om du anger villkoret (?!, Kommer det att vara en negativ lookahead för efterföljande tecken, vilket kräver att följande tecken inte matchar det angivna mönstret. Till exempel är mönstret / Java (?! Script) (\\ w *) / matchande substansen "Java", följd av stor bokstav och valfritt antal aSCII-texttecken förutsatt att substrängen "Java" inte följs av substrängen "Skript". Det kommer att matcha strängen "JavaBeans" men inte strängen "Javanese", den kommer att matcha strängen "JavaScrip" men inte strängarna "JavaScript" eller "JavaScripter".
Tabellen nedan visar de vanliga uttryckets ankartecken:
| Symbol | Värde |
|---|---|
| ^ | Matchar början av ett stränguttryck eller början på en sträng i en flersträngssökning. |
| $ | Matchar slutet av ett stränguttryck eller slutet på en sträng i en sökning på flera linjer. |
| \\ b | Matchar en ordgräns, dvs. matchar positionen mellan \\ w-tecknet och \\ W-tecknet, eller mellan \\ w-tecknet och början eller slutet av en sträng. (Observera dock att [\\ b] matchar backspace-karaktären.) |
| \\ B | Matchar en position som inte är en ordgräns. |
| (? \u003d p) | Ett positivt lookahead-test för efterföljande karaktärer. Kräver efterföljande tecken för att matcha p, men inkluderar inte de tecknen i den hittade strängen. |
| (?! p) | Negativ lookahead-kontroll för efterföljande tecken. Kräver att följande tecken inte matchar p. |
flaggor
Och ytterligare ett sista element i grammatiken för det vanliga uttrycket. Regelbundna uttrycksflaggor anger regler för matchning av mönster på hög nivå. Till skillnad från resten av den vanliga uttrycksgrammatiken specificeras flaggor inte mellan snedstreckstecken, utan efter den andra. Det finns tre flaggor som stöds i JavaScript.
Flagga i anger att mönstersökningen ska vara känslig för versaler och flagga g - att sökningen ska vara global, dvs. alla matchningar i strängen måste hittas. Flagga m söker efter ett mönster i multiline-läge. Om stränguttrycket som söks innehåller radmatningstecken passar i detta läge ankarstecken ^ och $, förutom att matcha början och slutet på hela stränguttrycket, också början och slutet på varje textsträng. Till exempel matchar / java $ / im både "java" och "Java \\ nis fun".
Dessa flaggor kan kombineras i valfri kombination. Till exempel, för att söka efter den första förekomsten av ordet "java" (eller "Java", "JAVA", etc.) på ett fall-okänsligt sätt, kan du använda fallet okänsligt regelbundet uttryck / \\ bjava \\ b / i. Och för att hitta alla förekomster av detta ord i en sträng kan du lägga till flaggan g: / \\ bjava \\ b / gi.
Strängklassmetoder för mönstermatchning
Fram till denna punkt har vi diskuterat grammatiken för det genererade regexp, men har inte tittat på hur regexp faktiskt kan användas i JavaScript. I det här avsnittet kommer vi att diskutera metoder strängobjektdär reguljära uttryck används för mönstermatchning och för ersättningssökning. Sedan fortsätter vi vår diskussion om mönstermatchning med vanliga uttryck genom att titta på RegExp-objektet och dess metoder och egenskaper.
Strängar stöder fyra metoder med vanliga uttryck. Den enklaste av dessa är metoden sök ()... Det tar ett regelbundet uttryck som ett argument och returnerar antingen positionen för det första tecknet i den hittade substrängen, eller -1 om ingen matchning hittades. Till exempel kommer följande samtal att returnera 4:
Var resultat \u003d "JavaScript" .sökning (/ script / i); // 4
Om argumentet till sökmetoden () inte är ett vanligt uttryck konverteras det först genom att skicka det till RegExp-konstruktören. Sökmetoden stöder inte globala sökningar och ignorerar g-flaggan i dess argument.
Metod byta ut () utför en sök- och ersättningsoperation. Det tar ett regelbundet uttryck som sitt första argument och en ersättningssträng som sitt andra. Metoden matchar det angivna mönstret i den rad som den kallas för.
Om det vanliga uttrycket innehåller g-flaggan ersätter metoden ersätt () alla matchningar som den hittar med ersättningssträngen. Annars ersätter den bara den första matchen som den hittar. Om det första argumentet för att ersätta () är en sträng snarare än ett vanligt uttryck, söker metoden bokstavligen efter strängen, snarare än att konvertera den till ett regelbundet uttryck med hjälp av RegExp () -konstruktören, som sökmetoden () gör.
Som exempel kan vi använda metoden ersätt () för att konsekvent använda ordet "JavaScript" för en hel textrad:
// Oavsett fall med tecken, byt ut med ett ord i det nödvändiga fallet var result \u003d "javascript" .replace (/ JavaScript / ig, "JavaScript");
Metoden ersätt () är mer kraftfullt verktygän man skulle gissa från detta exempel. Som en påminnelse är parenteserade subexpressions inuti ett reguljärt uttryck numrerade från vänster till höger, och att det reguljära uttrycket kommer ihåg den text som matchar var och en av subexpressions. Om ersättningssträngen innehåller en $ följt av en siffra, ersätter metoden ersätta de två tecknen med texten som matchar den angivna subexpressionen. Detta är väldigt användbar möjlighet... Vi kan till exempel använda den för att ersätta raka citattecken i en sträng med typografiska citattecken, som efterliknas av ASCII-tecken:
// En offert är ett offert, följt av valfritt antal icke-offertecken (vi kommer ihåg dem), // dessa tecken följs av en annan citat var quote \u003d / "([^"] *) "/ g; // Byt ut de raka citaten med typografiska och lämna "$ 1" oförändrat // innehållet i offerten lagrat i $ 1 var text \u003d "" JavaScript "är ett tolkat programmeringsspråk."; Var result \u003d text.replace (offert, "" $ 1 "") ; // "JavaScript" är ett tolkat programmeringsspråk.
En viktig punkt att notera är att det andra argumentet som ska ersättas () kan vara en funktion som dynamiskt beräknar ersättningssträngen.
Metod match () är den vanligaste metoden i String-klassen som använder regelbundna uttryck. Det accepterar ett regelbundet uttryck som dess enda argument (eller konverterar sitt argument till ett regelbundet uttryck genom att skicka det till RegExp () -konstruktören) och returnerar en matris som innehåller sökresultaten. Om g-flaggan är inställd i det vanliga uttrycket, returnerar metoden en matris med alla matchningar i strängen. Till exempel:
// kommer att returnera ["1", "2", "3"] var result \u003d "1 plus 2 är lika med 3" .match (/ \\ d + / g);
Om det reguljära uttrycket inte innehåller g-flaggan utför matchen () -metoden inte en global sökning; det letar bara efter den första matchen. Match () returnerar dock en matris även om metoden inte utför en global sökning. I det här fallet är det första elementet i matrisen den hittade substrängen, och alla återstående element är underuttryck av det reguljära uttrycket. Därför, om matchning () returnerar en matris arr, kommer arr att innehålla hela den hittade strängen, arr kommer att innehålla den substring som matchar den första subexpressionen, och så vidare. Genom att dra en parallell med metoden ersätt () kan vi säga att arr [n] är fylld med innehållet i $ n.
Ta exempelvis en titt på följande programkodanalysera url:
Var url \u003d /(\\w+):\\/\\/((\\w.tory+)\\/(\\S*)/; var text \u003d "Besök vår webbplats http: //www..php"; var resultat \u003d text.match (url); if (result! \u003d null) (var fullurl \u003d result; // Innehåller "http: //www..php" var protocol \u003d result; // Innehåller "http" var host \u003d result; // Innehåller "www..php" ")
Det bör noteras att för ett regelbundet uttryck som inte har g global sökning, matchar () -metoden samma värde som exec () -metoden för det reguljära uttrycket: den returnerade matrisen har index- och ingångsegenskaper, som beskrivs i diskussionen om exec () -metoden nedan.
Den sista av metoderna i String-objektet som använder reguljära uttryck är dela ()... Denna metod delar upp strängen för vilken den kallas in i en mängd underlag med argumentet som en avgränsare. Till exempel:
"123,456,789" .split (","); // Returnerar ["123", "456", "789"]
Metoden split () kan också ta ett regelbundet uttryck som ett argument. Detta gör metoden mer kraftfull. Till exempel kan du ange en avgränsare som tillåter godtyckligt antal vitrumstecken på båda sidor:
"1, 2, 3, 4, 5". Split (/ \\ s *, \\ s * /); // Returnerar ["1", "2", "3", "4", "5"]
RegExp-objekt
Som nämnts representeras vanliga uttryck som RegExp-objekt. Förutom RegExp () -konstruktören, stöder RegExp-objekt tre metoder och flera egenskaper.
RegExp () -konstruktören tar ett eller två strängargument och skapar ett nytt RegExp-objekt. Det första argumentet till konstruktören är en sträng som innehåller kroppen för det reguljära uttrycket, d.v.s. texten som måste visas mellan snedstreckstecken i det ordinarie uttrycket bokstavliga. Observera att strängbokstäver och reguljära uttryck använder tecknet \\ för att beteckna flykt-sekvenser, så när du överför det reguljära uttrycket till RegExp () -konstruktören som en strängbokstav måste du ersätta varje \\ med ett par \\\\ tecken.
Det andra argumentet till RegExp () kan saknas. Om det anges definierar det flaggorna för det reguljära uttrycket. Det måste vara en av tecknen g, i, m eller en kombination av dessa tecken. Till exempel:
// Hitta alla 5-siffriga siffror i en sträng. Notera // användningen av \\\\ var postnummer \u003d ny RegExp ("\\\\ d (5)", "g");
RegExp () -konstruktorn är användbar när det reguljära uttrycket genereras dynamiskt och därför inte kan representeras med det ordaliga uttrycket bokstavliga syntax. För att till exempel hitta en sträng som anges av användaren skapar du ett regelbundet uttryck vid körning med RegExp ().
RegExp-egenskaper
Varje RegExp-objekt har fem egenskaper. Fast egendom källa - en skrivskyddad sträng som innehåller texten till det vanliga uttrycket. Fast egendom global - ett läsbart booleskt värde som bestämmer närvaron av g-flaggan i det reguljära uttrycket. Fast egendom ignorera fall är ett läsbart booleskt värde som avgör om i-flaggan finns i det reguljära uttrycket. Fast egendom multiline är ett läsbart booleskt värde som anger närvaron av m-flaggan i det reguljära uttrycket. Och den sista egenskapen lastindex är ett läs / skriv-heltal. För mönster med g-flaggan innehåller den här egenskapen positionsnumret i strängen där nästa sökning börjar. Som beskrivs nedan används det med exec () och test () metoder.
RegExp-metoder
RegExp-objekt definierar två metoder som utför mönstermatchning; de uppför sig på samma sätt som metoderna i String-klassen som beskrivs ovan. Den huvudsakliga metoden i klassen RegExp som används för mönstermatchning är exec ()... Det liknar den tidigare nämnda matchningsmetoden () för strängklassen, förutom att det är en metod i klassen RegExp som tar en sträng som ett argument, och inte en metod i strängklassen som tar ett RegExp-argument.
Metoden exec () kör ett regelbundet uttryck för den angivna strängen, d.v.s. söker efter en matchning i en sträng. Om ingen matchning hittas returnerar metoden noll. Men om en matchning hittas returnerar den samma matris som matrisen som returneras av matchen () -metoden för sökning utan g-flaggan. Nollelementet i arrayen innehåller strängen som matchar det reguljära uttrycket och allt efterföljande element - Underlag som matchar alla subexpressions. Dessutom fastigheten index innehåller positionsnumret för det tecken som motsvarande fragment börjar med och egenskapen inmatning hänvisar till strängen som sökts.
Till skillnad från match () returnerar exec () en matris vars struktur är oberoende av g-flaggan i det reguljära uttrycket. Låt mig påminna dig om att när du passerar ett globalt reguljärt uttryck, matchar metoden () metoden en matris som hittats. Och exec () returnerar alltid en match, men ger om det fullständig information... När exec () kallas på ett reguljärt uttryck som innehåller g-flaggan, sätter metoden den sistaIndex-egenskapen för det reguljära uttrycksobjektet till positionsnumret för tecknet omedelbart efter den hittade substrängen.
När exec () -metoden kallas en andra gång för samma regelbundna uttryck, startar den sökningen på det tecken vars position är specificerad i den egna lastIndex. Om exec () inte hittar en matchning är egenskapen lastIndex inställd på 0. (Du kan också ställa lastIndex till noll när som helst, vilket bör göras i alla fall där sökningen slutförs innan den sista matchen på samma rad hittas, och startar en sökning på en annan sträng med samma RegExp-objekt.) Detta speciella beteende gör att exec () kan upprepas upprepade gånger för att iterera över alla reguljära uttrycksmatchningar i strängen. Till exempel:
Var mönster \u003d / Java / g; var text \u003d "JavaScript är roligare än Java!"; var resultat; medan ((result \u003d pattern.exec (text))! \u003d null) (console.log ("Found" "+ result +" "" + "på position" + result.index + "; nästa sökning börjar med" + pattern " .lastIndex);)
En annan metod för RegExp-objekt - test ()vilket är mycket enklare metod exec (). Det tar en sträng och returnerar sant om strängen matchar ett vanligt uttryck:
Var mönster \u003d / java / i; pattern.test ("JavaScript"); // Returnerar sant
Samtalstest () motsvarar samtal exec (), returnerar sant om exec () returnerar icke-null. Av denna anledning uppträder metoden test () på samma sätt som exec () -metoden när den krävs för ett globalt reguljärt uttryck: det börjar leta efter den angivna strängen från den position som ges av den egenskapen lastIndex, och om den hittar en matchning ställer egenskapen lastIndex till teckenpositionsnumret, direkt bredvid den hittade matchen. Med testmetoden kan du därför också skapa en slinga för att korsa en linje som med exec () -metoden.
I JavaScript representeras vanliga uttryck av RegExp-objekt. RegExp-objekt kan skapas med RegExp () -konstruktören, men oftare skapas de med speciell bokstavlig syntax. Precis som strängbokstäver anges som citerade tecken, anges regelbundna uttryckslitteratur som tecken som är inneslutna i en snedstreck / par.
/ mönster / flaggar nya RegExp ("mönster" [, sökalternativ])
mönster - regelbundet uttryck för sökning (om utbyte - senare) och flaggor - en sträng av valfri kombination av tecken g (global sökning), i (fall är inte viktigt) och m (sökning i flera rader). Den första metoden används ofta, den andra ibland. Till exempel är två sådana samtal likvärdiga.
sökmöjligheter
När vi skapar ett vanligt uttryck kan vi ange ytterligare alternativ Sök
Regelbundna uttryckstecken för JavaScript
| Symbol | Överensstämmelse |
|---|---|
| Alfanumeriska tecken | Passa på sig själva |
| \0 | NUL-tecken (\\ u0000) |
| \\ t | Fliken (\\ u0009) |
| \\ n | Radflöde (\\ u000A) |
| \\ v | Vertikal flik (\\ u000B) |
| \\ f | Sidöversättning (\\ u000C) |
| r | Vagnretur (\\ u000D) |
| \\ xnn | Det latinska tecknet som anges av hexadecimalt antal nn; t.ex. \\ x0A är samma som \\ n |
| \\ uxxxx | Unicode-tecken, specificerat av det hexadecimala numret xxxx; t.ex. \\ u0009 är samma som \\ t |
| \\ cX | Escape-karaktär "X", till exempel, \\ cJ motsvarar radmatning \\ n |
| \ | För vanliga karaktärer gör dem speciella. Till exempel letar uttrycket / s / bara efter tecknet "s". Och om du lägger \\ före s, betecknar / \\ s / redan ett vitrumstecken. Omvänt, om tecknet är speciellt, till exempel *, kommer \\ att det bara att vara en vanlig asterisk karaktär. Till exempel, / a * / söker efter 0 eller fler "a" -tecken i följd. För att hitta en med en asterisk "a *" - sätt \\ framför specialen. karaktär: / a \\ * /. |
| ^ | Anger början på ingången. Om den flerliniga sökflaggen ("m") är inställd, kommer den också att triggas när en ny rad startar. Till exempel, / ^ A / kommer inte att hitta "A" i "ett A", utan kommer att hitta den första "A" i "En A." |
| $ | Indikerar ingångens slut. Om den flerliniga sökflaggan är inställd fungerar den också i slutet av raden, till exempel / t $ / hittar inte "t" i "eater", men hittar den i "eat". |
| * | Indikerar upprepning av 0 eller fler gånger. Till exempel, / bo * / hittar "boooo" i "A ghost booooed" och "b" i "A bird warbled", men ingenting i "A get gunted". |
| + | Indikerar upprepning av 1 eller flera gånger. Likvärdigt med (1,). Till exempel matchar / a + / "a" i "godis" och alla "a" i "caaaaaaandy". |
| ? | Indikerar att ett element kan vara närvarande eller frånvarande. Till exempel / e? Le? / Matchar "el" i "ängel" och "le" i "vinkel." Om den används omedelbart efter en av kvantifierarna *, + ,? , eller (), specificerar sedan en "icke-girig" sökning (upprepar det minsta möjliga antalet gånger, upp till nästa nästa element i mönstret), i motsats till standard-"giriga" -läget, där antalet repetitioner är maximalt, även om nästa element i mönstret också är lämpligt. ,? används i förhandsgranskningen, som beskrivs i tabellen under (? \u003d), (?!) och (? :). |
| . | (Decimalpunkt) anger något annat tecken än en ny linje: \\ n \\ r \\ u2028 eller \\ u2029. (du kan använda [\\ s \\ S] för att söka efter valfritt tecken, inklusive nya linjer). Till exempel matchar /.n/ "ett" och "på" i "nej, ett äpple är på trädet", men inte "nej". |
| (X) | Hitta x och kommer ihåg. Detta kallas "minnehäftningar". Till exempel kommer / (foo) / att hitta och komma ihåg "foo" i "foo bar." Den hittade understrängen lagras i sökresultatfältet eller i de fördefinierade egenskaperna för RegExp-objektet: $ 1, ..., $ 9. Dessutom kombinerar parenteserna vad som finns i dem till ett enda mönsterelement. Till exempel (abc) * - upprepa abc 0 eller flera gånger. |
| (?: x) | Hittar x, men kommer inte ihåg vad den hittade. Detta kallas "parenteser som inte kommer ihåg". Den hittade substrängen lagras inte i resultatuppsättningen och i RegExp-egenskaperna. Liksom alla parenteser kombineras de till en enda delmönster. |
| x (? \u003d y) | Hitta x endast om x följs av y. Till exempel / Jack (? \u003d Sprat) / matchar "Jack" endast om det följs av "Sprat". / Jack (? \u003d Sprat | Frost) / matchar "Jack" endast om det följs av "Sprat" eller "Frost". Varken "Sprat" eller "Frost" kommer dock att visas i sökresultatet. |
| x (?! y) | Hitta x endast om x inte följs av y. Till exempel matchar /\\d+(?!\\.)/ endast ett nummer om det inte följs av en decimal. /\\d+(?!\\.)/.exec("3.141 ") hittar 141, men inte 3.141. |
| x | y | Hitta x eller y. Till exempel hittar / grönt | rött / "grönt" i "grönt äpple" och "rött" i "rött äpple." |
| (N) | Där n är ett positivt heltal. Hitta exakt n upprepningar av föregående element. Till exempel, / a (2) / hittar inte "a" i "godis", men kommer att hitta både a i "caandy" och de första två a i "caaandy." |
| (N,) | Där n är ett positivt heltal. Hitta n eller flera upprepningar av ett objekt. Till exempel, / a (2,) hittar inte "a" i "godis", utan kommer att hitta alla "a" i "caandy" och i "caaaaaaandy." |
| (n, m) | Där n och m är positiva heltal. Hitta n till m-upprepningar av elementet. |
| Teckenuppsättning. Hitta någon av följande tecken. Du kan ange ett gap med ett bindestreck. Till exempel - samma som. Matchar "b" i "brisket" och "a" och "c" i "värk". | |
| [^ xyz] | Alla andra tecken än de som anges i uppsättningen. Du kan också ange ett gap. Till exempel är [^ abc] densamma som [^ a-c]. Matchar "r" i "brisket" och "h" i "chop". |
| [\\ b] | Hitta backspace-karaktären. (Förväxlas inte med \\ b.) |
| \\ b | Hitta en ordgräns (latin), till exempel ett mellanslag. (Förväxlas inte med [\\ b]). Till exempel matchar / \\ bn \\ w / matchar "nej" i "noonday"; / \\ wy \\ b / matchar "ly" i "möjligen igår." |
| \\ B | Betecknar inte en ordgräns. Till exempel / \\ w \\ Bn / matchar "på" i "noonday" och / y \\ B \\ w / matchar "ye" i "möjligen igår." |
| \\ cX | Där X är en bokstav från A till Z. Anger ett kontrolltecken i en sträng. Till exempel står / \\ cM / för Ctrl-M. |
| \\ d | hittar en siffra från vilket alfabet som helst (vi har Unicode). Använd endast för att hitta vanliga nummer. Till exempel matchar / \\ d / eller // "2" i "B2 svitnumret." |
| \\ D | Hitta ett icke-siffrigt tecken (alla alfabet). [^ 0-9] motsvarar vanliga siffror. Till exempel är / \\ D / eller / [^ 0-9] / matchar "B" i "B2 svitnumret." |
| \\ s | Kommer att matcha alla whitespace-karaktärer, inklusive mellanslag, flikar, radflöden och andra unicode-blankstegstecken. Till exempel matchar / \\ s \\ w * / "bar" i "foo bar." |
| \\ S | Kommer att matcha valfri karaktär utom vitrum. Till exempel / \\ S \\ w * / matchar "foo" i "foo bar." |
| \\ v | Vertikalt flikkaraktär. |
| \\ w | Finns alla verbala (latinska alfabetet) tecken, inklusive bokstäver, siffror och understrukna. Likvärdig. Till exempel matchar / \\ w / "a" i "apple", "5" i "$ 5,28" och "3" i "3D." |
| \\ W | Matchar alla icke-(lat.) Word-tecken. Motsvarande med [^ A-Za-z0-9_]. Till exempel kommer / \\ W / och / [^ $ A-Za-z0-9 _] / att matcha lika med "%" i "50%." |
Arbeta med regelbundna uttryck i Javascript
Arbeta med regelbundna uttryck i Javascript implementeras med metoder i String-klassen
exec (regexp) - Hitta alla matchningar (förekomster av ett "vanligt" mönster) i en sträng. Returnerar en matris (om den matchas) och uppdaterar egenskapen regexp, eller null om ingenting hittades. Med g-modifieraren - varje gång denna funktion anropas kommer den att returnera nästa match efter den tidigare hittade - detta implementeras genom att upprätthålla offsetindexet för den senaste sökningen.
matchning (regexp) - hitta en del av en sträng efter mönster. Om g-modifieraren anges returnerar matchningsfunktionen () en matris med alla matchningar eller null (snarare än tom matris). Utan g-modifieraren fungerar den här funktionen som exec ();
test (regexp) - funktionen kontrollerar strängen mot ett mönster. Returnerar sant om det finns en matchning, och falskt om det inte finns någon matchning.
split (regexp) - Delar strängen för vilken den kallas in i en rad underlag med argumentet som avgränsare.
byt ut (regexp, mix) - metoden returnerar den modifierade strängen i enlighet med mönstret (reguljärt uttryck). Den första regexp-parametern kan också innehålla en sträng snarare än ett vanligt uttryck. Utan g-modifieraren - metoden i raden ersätter endast den första händelsen; med g-modifieraren - en global ersättning sker, d.v.s. alla händelser i den givna raden ändras. mix - ersättningsmönster, kan acceptera värden för en sträng, ersättningsmönster, funktion (funktionsnamn).
Specialtecken i ersättningssträngen
Ersättning via funktion
Om du anger en funktion som den andra parametern, körs den på varje matchning. I en funktion kan du dynamiskt generera och returnera en substitutionssträng. Den första parametern för funktionen är den hittade substrängen. Om det första argumentet som ska ersättas är ett RegExp-objekt, innehåller nästa n-parametrar kapslade parenteser. De två sista parametrarna är positionen i strängen där matchen inträffade och själva strängen.