Velkommen til denne komplette guiden til regulære uttrykk i JavaScript! I denne artikkelen skal vi utforske i detalj hva regulære uttrykk er, hvordan de brukes i JavaScript, og hvordan de kan hjelpe deg med å forenkle og optimalisere koden. Fra det grunnleggende til praktiske eksempler, vi dekker alt du trenger å vite for å begynne å få mest mulig ut av vanlige uttrykk i JavaScript-prosjektene dine. Så la oss komme i gang!
Introduksjon til regulære uttrykk
Regulære uttrykk er søkemønstre som brukes til å finne og manipulere tekst i tegnstrenger. De består av en kombinasjon av bokstavelige tegn og metategn, som definerer spesifikke regler for å finne samsvar i tekst. Disse reglene kan inkludere søk etter spesifikke tegn, tegnområder, repetisjoner, alternativer og mye mer.
I JavaScript lages regulære uttrykk ved hjelp av klassen RegExp eller ved å bruke det bokstavelige /patrón/. Mønsteret er selve det regulære uttrykket, som er innelukket mellom skråstreker fremover. La oss se på et enkelt eksempel:
const regex = /hola/;
I dette eksemplet har vi laget et regulært uttrykk som vil søke etter strengen "hei" i en tekst. Nå som vi har en grunnleggende forståelse av hva regulære uttrykk er, la oss utforske noen nøkkelbegreper og avanserte teknikker for å jobbe med dem i JavaScript.
Grunnleggende syntaks for regulære uttrykk
Regulære uttrykk i JavaScript består av flere nøkkelelementer som lar oss definere mer komplekse søkemønstre. Disse elementene inkluderer bokstavelige tegn, metategn, karakterklasser, kvantifiserere, ankere og mer. La oss se på noen eksempler på disse elementene:
Bokstavelige tegn
Bokstavelige tegn er de det søkes etter slik de vises i teksten. For eksempel det regulære uttrykket /hola/ vil søke etter tegnsekvensen "hei" i en tekststreng. Det er viktig å merke seg at vanlige uttrykk skiller mellom store og små bokstaver, så /hola/ vil ikke samsvare med "Hello" eller "HELLO".
Metakarakterer
Metategn er spesialtegn som har spesiell betydning i regulære uttrykk. For eksempel metakarakteren . Den brukes til å representere et hvilket som helst tegn bortsett fra en ny linje. En annen vanlig metakarakter er ^, som brukes til å indikere starten på en tekststreng. For eksempel det regulære uttrykket /^hola/ vil matche enhver tekststreng som begynner med "hei".
Karakterklasser
Karakterklasser brukes til å søke etter et hvilket som helst tegn i et spesifikt sett. For eksempel det regulære uttrykket /[aeiou]/ vil matche enhver vokal i en tekststreng. Det er også mulig å bruke tegnområder i tegnklasser. For eksempel det regulære uttrykket /[a-z]/ vil samsvare med alle små bokstaver.
Kvantifiserere
Kvantifiserere brukes til å spesifisere antall forekomster av et element i et regulært uttrykk. For eksempel kvantifisereren * indikerer at forrige element kan vises null eller flere ganger. Kvantifisereren + indikerer at det foregående elementet skal vises en eller flere ganger. For eksempel det regulære uttrykket /a+/ vil matche en eller flere "a" i en tekststreng.
Ankre
Ankere brukes til å indikere plasseringen av et samsvar i en tekststreng. For eksempel ankeret \b samsvarer med en ordgrense. For eksempel det regulære uttrykket /bholab/ vil bare samsvare med ordet "hei" som en hele ordet, uten å matche lengre ord som inneholder «hei» som en del av dem.
Dette er bare noen få eksempler på den grunnleggende syntaksen for regulære uttrykk i JavaScript. Etter hvert som vi går videre i denne artikkelen , vil vi utforske mer avanserte konsepter og teknikker for å jobbe med regulære uttrykk i JavaScript.
Grunnleggende matchsøk
En av de vanligste operasjonene som utføres med regulære uttrykk, er å søke etter samsvar i en tekststreng. I JavaScript kan vi bruke metoden search() for å finne det første treffet til et regulært uttrykk i en tekststreng. La oss se et eksempel:
const texto = "¡Hola, mundo!"; const regex = /mundo/; const indice = texto.search(regex); console.log(indice); // 7
I dette eksemplet har vi brukt metoden search() for å finne det første treffet til det regulære uttrykket /mundo/ i tekststrengen "Hei, verden!" Metoden search() returnerer indeksen for det første treffet funnet, eller -1 hvis ingen treff blir funnet.
I tillegg til metoden search(), JavaScript gir også andre nyttige metoder for å jobbe med regulære uttrykk, som f.eks match(), replace(), split() y test(). Hver av disse metodene har sitt eget formål og kan brukes i henhold til dine spesifikke behov.
Bruke modifikatorer og flagg
I JavaScript kan regulære uttrykk inneholde modifikatorer og flagg som gir mulighet for mer fleksible og tilpassede søk. Modifikatorer legges til på slutten av et regulært uttrykk og endrer virkemåten. Noen av de vanligste modifikatorene er:
jeg (ufølsom)
Modifikatoren i brukes til å utføre et søk som ikke skiller mellom store og små bokstaver. For eksempel det regulære uttrykket /hola/i vil matche både "hei" og "Hello" eller "HELLO".
g (globalt)
Modifikatoren g Den brukes til å utføre et globalt søk på hele tekststrengen, i stedet for å stoppe ved det første treffet som ble funnet. For eksempel det regulære uttrykket /a+/g vil samsvare med alle forekomster av en eller flere "a"-er i en tekststreng.
m (flerlinje)
Modifikatoren m Den brukes til å utføre et søk på flere linjer i en tekststreng. For eksempel det regulære uttrykket /^hola/m vil matche ordet "hei" på begynnelsen av hver linje i en tekststreng.
I tillegg til modifikatorer tillater JavaScript også bruk av flagg i regulære uttrykk. Flagg legges til etter den andre skråstreken når du oppretter et regulært uttrykk ved hjelp av klassen RegExp. Noen av de vanligste flaggene er:
jeg (ufølsom)
Som modifikatoren i, flagget i utfører et søk som ikke skiller mellom store og små bokstaver. For eksempel det regulære uttrykket new RegExp("hola", "i") vil matche både "hei" og "Hello" eller "HELLO".
g (globalt)
Som modifikatoren g, flagget g utfører et globalt søk på hele tekststrengen. For eksempel det regulære uttrykket new RegExp("a+", "g") vil samsvare med alle forekomster av en eller flere "a"-er i en tekststreng.
m (flerlinje)
Som modifikatoren m, flagget m utfører et søk på flere linjer i en tekststreng. For eksempel det regulære uttrykket new RegExp("^hola", "m") vil matche ordet "hei" på begynnelsen av hver linje i en tekststreng.
Bruk av modifikatorer og flagg i regulære JavaScript-uttrykk kan være svært nyttig for å skreddersy søk til ulike tilfeller og spesifikke krav. Eksperimenter med dem og oppdag hvordan du kan få mest mulig ut av disse funksjonene i koden din.
Metakarakterer og spesialtegn
Metategn og spesialtegn er nøkkelelementer i regulære uttrykk som lar oss utføre kraftigere og fleksible søk. Vi har allerede nevnt noen metakarakterer, som f.eks . y ^, men det er mange flere du kan bruke i dine regulære uttrykk. La oss se på noen av de vanligste metategnene og spesialtegnene:
. (punkt)
Metakarakteren . Den brukes til å representere et hvilket som helst tegn bortsett fra en ny linje. For eksempel det regulære uttrykket /h.t/ vil matche «hat», «hot», «hit» og alle andre ord på tre bokstaver som begynner med «h» og slutter med «t».
\ (omvendt skråstrek)
Omvendt skråstrek brukes til å unnslippe spesialtegn i et regulært uttrykk. For eksempel, hvis du vil søke etter et bokstavelig punktum i en tekststreng, må du unnslippe det ved å bruke omvendt skråstrek. Det regulære uttrykket /www\.google\.com/ vil samsvare med tekststrengen "www.google.com".
\d (siffer)
Metakarakteren \d brukes til å søke etter et hvilket som helst siffer fra 0 til 9. For eksempel det regulære uttrykket /\d+/ vil samsvare med et eller flere sifre i en tekststreng.
\w (alfanumerisk tegn)
Metakarakteren \w brukes til å søke etter alle alfanumeriske tegn (store og små bokstaver, sifre og understrekinger). For eksempel det regulære uttrykket /\w+/ vil matche ethvert ord med ett eller flere alfanumeriske tegn i en tekststreng.
Dette er bare noen få eksempler på metategn og spesialtegn du kan bruke i dine regulære uttrykk. Etter hvert som du blir mer kjent med regulære uttrykk i JavaScript, vil du oppdage en lang rekke alternativer for å avgrense søkene og tekstmanipulasjonene dine.
Karakterklasser og rekkevidder
Tegnklasser er et annet nøkkelelement i regulære uttrykk som lar oss søke etter et hvilket som helst tegn i et spesifikt sett. I JavaScript kan vi bruke parenteser [] for å definere en karakterklasse. La oss se på noen eksempler på karakterklasser og områder:
[aeiou]
Karakterklassen [aeiou] vil matche enhver vokal i en tekststreng. For eksempel det regulære uttrykket /[aeiou]/ vil matche "a", "e", "i", "o" eller "u" i en tekststreng.
[az]
Utvalget av tegn [a-z] vil matche alle små bokstaver i det engelske alfabetet. For eksempel det regulære uttrykket /[a-z]/ vil matche enhver liten bokstav i en tekststreng.
[0-9]
Utvalget av tegn [0-9] vil matche ethvert siffer fra 0 til 9 i en tekststreng. For eksempel det regulære uttrykket /[0-9]/ vil matche ethvert enkeltsifret tall.
[A-Z-z]
Karakterklassen [A-Za-z] vil matche enhver stor eller liten bokstav i det engelske alfabetet. For eksempel det regulære uttrykket /[A-Za-z]/ vil matche enhver bokstav i en tekststreng.
Tegnklasser og områder lar oss definere spesifikke sett med tegn å søke etter i et regulært uttrykk. Bruk dem til å skreddersy søkene dine til dine spesielle behov og begrensninger.
Kvantifiserere og repetisjoner
Kvantifiserere og repetisjoner er nøkkelelementer i regulære uttrykk som lar oss spesifisere antall forekomster av et element i en tekststreng. La oss se på noen av de vanligste kvantifikatorene i JavaScript:
* (stjerne)
Kvantifisereren * indikerer at forrige element kan vises null eller flere ganger. For eksempel det regulære uttrykket /a*/ vil matche null eller flere 'a'er i en tekststreng.
+ (mer)
Kvantifisereren + indikerer at det foregående elementet skal vises en eller flere ganger. For eksempel det regulære uttrykket /a+/ vil matche en eller flere "a" i en tekststreng.
? (spørsmål)
Kvantifisereren ? indikerer at forrige element kan vises null eller én gang. For eksempel det regulære uttrykket /colou?r/ vil matche både "farge" og "farge".
{n} (nøyaktig n ganger)
Kvantifisereren {n} indikerer at forrige element må vises nøyaktig n ganger. For eksempel det regulære uttrykket /a{3}/ vil matche nøyaktig tre "a"-er i en tekststreng.
{n,} (minst n ganger)
Kvantifisereren {n,} indikerer at forrige element må vises minst n ganger. For eksempel det regulære uttrykket /a{2,}/ vil matche to eller flere 'a'er i en tekststreng.
{n,m}
Kvantifisereren {n,m} indikerer at forrige element må vises minst n ganger og maksimalt m ganger. For eksempel det regulære uttrykket /a{2,4}/ vil matche to, tre eller fire "a"-er i en tekststreng.
Dette er bare noen få eksempler på kvantifiserere du kan bruke i dine regulære uttrykk. Kvantifiserere lar oss spesifisere gjentakelsesmønstre i tekstsøk og manipulasjoner, noe som gjør det lettere å trekke ut spesifikk informasjon fra tekststrenger.
Ankere og ordgrenser
Ankere og ordgrenser er elementer som lar oss indikere plasseringen av et samsvar i en tekststreng. Disse elementene er spesielt nyttige når vi vil søke etter hele ord eller sørge for at et samsvar er på begynnelsen eller slutten av en linje. La oss se på noen eksempler på ankere og ordgrenser:
\b (ordgrense)
Ordet grense \b samsvarer med grensen mellom et alfanumerisk tegn og et ikke-alfanumerisk tegn. For eksempel det regulære uttrykket /\bjavascript\b/ vil bare samsvare med ordet "javascript" som et komplett ord, ikke samsvarer med lengre ord som inneholder "javascript" som en del av dem.
^ (start av linjen)
Karakteren ^ Den brukes til å angi begynnelsen av en linje i en tekststreng. For eksempel det regulære uttrykket /^hola/ vil matche ordet "hei" på begynnelsen av hver linje i en tekststreng.
$ (slutt på linjen)
Karakteren $ Den brukes til å angi slutten av en linje i en tekststreng. For eksempel det regulære uttrykket /mundo$/ vil matche ordet "verden" på slutten av hver linje i en tekststreng.
\A (start av tekst)
Karakteren \A Den brukes til å indikere starten på all tekst i en tekststreng, ikke bare starten på en linje. For eksempel det regulære uttrykket /^\AHola/ vil matche ordet "Hei" i begynnelsen av hele teksten.
\Z (slutt på tekst)
Karakteren \Z brukes til å angi slutten av all tekst i en tekststreng, ikke bare slutten av en linje. For eksempel det regulære uttrykket /Mundo\Z/ vil samsvare med ordet "Verden" på slutten av hele teksten.
Ankere og ordgrenser lar oss søke etter treff på bestemte steder i en tekststreng, noe som kan være nyttig i situasjoner der vi ønsker å sikre at en treff er på en bestemt posisjon.
Grupper og fanger
Grupper og fanger er avanserte elementer i regulære uttrykk som lar oss gruppere underuttrykk og fange dem for senere bruk. La oss se hvordan grupper og bilder fungerer:
( ) (parenteser)
Parentesene er De bruker å gruppere seg underuttrykk i et regulært uttrykk. For eksempel det regulære uttrykket /(d{2})-(d{2})-(d{4})/ se brukes til å søke etter en dato i formatet "dd-mm-åååå. Gruppene ( ) De lar oss fange opp dag-, måned- og årsverdier separat.
\1, \2, \3 (gruppereferanser)
Gruppereferanser brukes til å referere til tidligere fangede grupper i et regulært uttrykk. For eksempel det regulære uttrykket /(\w+) \1/ vil matche ethvert ord etterfulgt av det samme ordet gjentatt. For eksempel "hei hei", "verden verden", etc.
?: (ikke-fangst gruppe)
Symbolet ?: Den brukes til å opprette grupper som ikke fanger opp. Disse gruppene brukes når vi ønsker å gruppere underuttrykk, men vi ønsker ikke å fange opp resultatet. For eksempel det regulære uttrykket /https?:\/\/(?:www\.)?google\.com/ vil matche både "http://www.google.com" og "https://google.com", men vil bare fange opp den relevante delen av nettadressen.
Grupperinger og registreringer lar oss strukturere og organisere våre regulære uttrykk på en mer effektiv og lesbar måte. De gir også muligheten til å registrere spesifikke verdier for senere bruk i applikasjonene våre.
Nyttige metoder for å arbeide med regulære uttrykk
JavaScript gir flere nyttige metoder for å jobbe med regulære uttrykk. Disse metodene lar oss utføre vanlige operasjoner som å søke, erstatte og dele tekststrenger ved å bruke regulære uttrykk. La oss se på noen av disse metodene:
kamp()
Metoden match() Den brukes til å finne alle treff til et regulært uttrykk i en tekststreng og returnere en matrise med resultatene. For eksempel:
const texto = "¡Hola, mundo!"; const regex = /o/g; const coincidencias = texto.match(regex); console.log(coincidencias); // ["o", "o"]
I dette eksemplet har vi brukt metoden match() for å finne alle samsvar med det regulære uttrykket /o/g i tekststrengen "Hei, verden!" Metoden match() returnerer en matrise med alle samsvarene som er funnet.
erstatte ()
Metoden replace() brukes til å erstatte treff av et regulært uttrykk i en tekststreng med en ny verdi. For eksempel:
const texto = "¡Hola, mundo!"; const regex = /mundo/; const nuevoTexto = texto.replace(regex, "amigo"); console.log(nuevoTexto); // "¡Hola, amigo!"
I dette eksemplet har vi brukt metoden replace() for å erstatte samsvaret med regulære uttrykk /mundo/ i tekststrengen "Hei, verden!" for ordet "venn". Metoden replace() returnerer en ny tekststreng med erstatningene som er gjort.
dele()
Metoden split() brukes til å dele en tekststreng i en rekke understrenger ved å bruke et regulært uttrykk som skilletegn. For eksempel:
const texto = "Hola,mundo,amigo"; const regex = /,/g; const subcadenas = texto.split(regex); console.log(subcadenas); // ["Hola", "mundo", "amigo"]
I dette eksemplet har vi brukt metoden split() å dele tekststrengen "Hei, verden, venn" i en rekke understrenger ved å bruke det regulære uttrykket /,/g som en separator. Metoden split() returnerer en matrise med de resulterende delstrengene.
test()
Metoden test() Den brukes til å sjekke om et regulært uttrykk har noen treff i en tekststreng. Metoden kommer tilbake true hvis det er match og false noe annet. For eksempel:
const texto = "Hola, mundo!"; const regex = /mundo/; const resultado = regex.test(texto); console.log(resultado); // true
I dette eksemplet har vi brukt metoden test() for å sjekke om det regulære uttrykket /mundo/ har noen treff i tekststrengen "Hallo, verden!". Metoden test() Bring tilbake true fordi det er en tilfeldighet.
Dette er bare noen av de vanligste metodene for å jobbe med regulære uttrykk i JavaScript. Hver av disse metodene har sitt eget formål og kan brukes i henhold til dine spesifikke behov. Eksperimenter med dem og oppdag hvordan de kan gjøre arbeidet ditt med regulære uttrykk enklere og raskere.
Vanlige spørsmål
Hva er regulære uttrykk i JavaScript? Regulære uttrykk i JavaScript er søkemønstre som brukes til å finne og manipulere tekst i tegnstrenger.
Hvordan lage regulære uttrykk i JavaScript? Regulære uttrykk i JavaScript lages ved hjelp av klassen RegExp eller ved å bruke det bokstavelige /patrón/.
Hva er forskjellen mellom modifikatorer og flagg i regulære uttrykk? Modifikatorer legges til på slutten av et regulært uttrykk og endrer virkemåten. Flagg legges til etter den andre skråstreken når du oppretter et regulært uttrykk ved hjelp av klassen RegExp.
Hva er forskjellen mellom metoden match() og metoden test()? Metoden match() Den brukes til å finne alle treff til et regulært uttrykk i en tekststreng og returnerer en matrise med resultatene. Metoden test() Den brukes til å sjekke om et regulært uttrykk har noen treff i en tekststreng og returnerer en boolsk verdi.
Hvordan kan jeg fange opp spesifikke verdier ved å bruke grupper i et regulært uttrykk? Gruppene ( ) i et regulært uttrykk lar deg fange opp spesifikke underuttrykk. Du kan deretter referere til disse gruppene ved å bruke referansene \1, \2Osv
Hvilke metoder kan jeg bruke for å jobbe med regulære uttrykk i JavaScript? Noen nyttige metoder for å jobbe med regulære uttrykk i JavaScript er match(), replace(), split() y test(). Hver av disse metodene har sitt eget formål og kan brukes i henhold til dine spesifikke behov.
Konklusjon
Regulære uttrykk er et kraftig verktøy for å jobbe med tekst i JavaScript. Å forstå det grunnleggende , syntaksen og de avanserte teknikkene for regulære uttrykk vil gjøre det mulig for deg å søke, erstatte og manipulere tekststrenger effektivt og nøyaktig. Fra grunnleggende samsvar til bruk av modifikatorer, grupper og andre nyttige metoder, har du lært hvordan du får mest mulig ut av regulære uttrykk i JavaScript-prosjektene dine.
Husk å øve og eksperimentere med ulike mønstre og bruk case for å styrke din forståelse og kjennskap til regulære uttrykk. Ikke nøl med å bruke regulære uttrykk for å forbedre effektiviteten og kvaliteten på koden din!