Regulære uttrykk js erstatte. En guide til regulære uttrykk i JavaScript

Denne artikkelen dekker det grunnleggende om bruk av regulære uttrykk i Javascript.

Innledning Hva er et regulært uttrykk?

Et JS regulært uttrykk er en sekvens av tegn som danner en søkeregel. Denne regelen kan deretter brukes til å søke gjennom tekst samt erstatte den. I praksis kan et regulært uttrykk til og med bestå av et enkelt tegn, men mer komplekse søkemønstre er mer vanlig.

I Javascript er regulære uttrykk også objekter. Dette er mønstre som brukes til å matche sekvenser av tegn i strenger. De brukes i metodene exec() og test() til RegExp-objektet, og i metodene match(), replace(), search og split() til String-objektet.

Eksempel

var mønster = /eksempel/i

/eksempel/i er et regulært uttrykk. eksempel er en mal (som vil bli brukt i søket). i er en modifikator som indikerer sensitivitet for store og små bokstaver.

Forberede et regulært uttrykk

JS regulære uttrykk består av et mønster og en modifikator. Syntaksen vil være noe slikt:

/mønster/modifikatorer;

Malen spesifiserer søkeregelen. Den består av enkle tegn som /abc/ eller en kombinasjon av enkle og spesialtegn: /abc/ eller /Chapter (d+).d/ .

Modifikatorer for mønstertabeller lar deg gjøre søk skille mellom store og små bokstaver, globale og så videre. De brukes til å utføre store og små bokstaver så vel som globale søk. Modifikatortabell Nå er vi klare til å bruke JS regulære uttrykk. Det er to hovedmåter å gjøre dette på: å bruke et regulært uttrykksobjekt eller et regulært uttrykk på en streng. Bruke et regulært uttrykksobjekt Opprette et regulært uttrykksobjekt

Dette objektet beskriver et tegnmønster. Den brukes til mønstermatching. Det er to måter å konstruere et regulært uttrykksobjekt på.

Metode 1: Bruke et regulært uttrykk som består av et mønster omsluttet av skråstreker, for eksempel:

var reg = /ab+c/;

Regulære uttrykksliteraler utløser forhåndskompilering av det regulære uttrykket når skriptet analyseres. Hvis det regulære uttrykket er konstant, bruk det til å forbedre ytelsen.

Metode 2: Kalle konstruktørfunksjonen til RegExp-objektet, for eksempel:

var reg = new RegExp("ab+c");

Ved å bruke en konstruktør kan JS regulære uttrykk kompileres mens skriptet kjører. Bruk denne metoden hvis det regulære uttrykket vil endre seg eller du ikke kjenner mønsteret på forhånd. For eksempel hvis du mottar informasjon fra en bruker som skriver inn et søk.

Regulære uttrykksobjektmetoder

La oss ta en titt på noen vanlige metoder for regulære uttrykksobjekter:

compile() (avviklet i versjon 1.5) – kompilerer et regulært uttrykk;
exec() - Utfører en strengmatch. Returnerer den første kampen;
test() - utfører en match på en streng. Returnerer sant eller usant;
toString() – returnerer strengverdien til det regulære uttrykket.

Eksempler ved bruk av test()

Test()-metoden er et regulært uttrykk for RegExp-objektet. Den søker etter en mønsterstreng og returnerer sant eller usant avhengig av resultatet. Følgende JS regulære uttrykkseksempel viser hvordan en streng søkes etter tegnet "e":

var patt = /e/; patt.test("De beste tingene i verden er gratis!");

Siden det er en "e" i strengen her, vil resultatet av denne koden være sant.

Regulære uttrykk trenger ikke å plasseres i en variabel. Den samme spørringen kan gjøres på én linje:

/e/.test("De beste tingene i verden er gratis!");

Bruker exec()

Den søker i en streng ved å bruke en gitt søkeregel og returnerer teksten som er funnet. Hvis ingen treff ble funnet, vil resultatet være null .

La oss se på metoden i aksjon, ved å bruke det samme symbolet "e" som eksempel:

/e/.exec("De beste tingene i verden er gratis!");

Siden det er en "e" i strengen, vil resultatet av denne koden være .e .

Bruke et regulært uttrykk på en streng

I Javascript kan disse uttrykkene også brukes med to metoder for String-objektet: search() og replace(). De er nødvendige for å utføre søk og erstatt i tekst.

search()-metoden - bruker et uttrykk for å søke etter et treff, og returnerer informasjon om plasseringen av treffet;
Replace()-metoden returnerer en modifisert streng med et erstattet mønster.

Eksempler

Bruk av et regulært JS-uttrykk for å utføre et søk som skiller mellom store og små bokstaver etter uttrykket "w3schools" i strengen:

var str = "Besøk W3Schools"; var n = str.search(/w3skoler/i);

Resultatet i n blir 6.

Søkemetoden tar også en streng som argument. Stringargumentet vil bli konvertert til et regulært uttrykk:

Bruke streng for å søke etter uttrykket "W3schools" i en streng.

I JavaScript er regulære uttrykk representert av RegExp-objekter. RegExp-objekter kan opprettes ved å bruke RegExp()-konstruktøren, men oftere lages de ved hjelp av en spesiell bokstavlig syntaks. Akkurat som strengliteraler er spesifisert som tegn omsluttet av anførselstegn, spesifiseres literaler for regulære uttrykk som tegn omsluttet av et skråstrekpar / .

/pattern/flags new RegExp("mønster"[, søkealternativer])

mønster er et regulært uttrykk for søk (mer om erstatning senere), og flagg er en streng av en hvilken som helst kombinasjon av tegn g (globalt søk), i (case er ikke viktig) og m (flerlinjesøk). Den første metoden brukes ofte, den andre - noen ganger. For eksempel er to slike samtaler likeverdige.

Søkealternativer

Når vi oppretter et regulært uttrykk, kan vi angi flere søkealternativer

Tegn i regulære JavaScript-uttrykk Symbolkorrespondanse

Alfanumeriske tegn	Tilsvarer seg selv
\0	NUL-tegn (\u0000)
\t	Fane (\u0009)
\n	Linjefeed (\u000A)
\v	Vertikal fane (\u000B)
\f	Sideoversettelse (\u000C)
\r	Returtur (\u000D)
\xnn	Et tegn fra det latinske settet, spesifisert av det heksadesimale tallet nn; for eksempel er \x0A det samme som \n
\uxxxx	Unicode-tegn spesifisert med heksadesimalt nummer xxxx; for eksempel er \u0009 det samme som \t
\cX	Kontrolltegnet "X", for eksempel, sekvensen \cJ tilsvarer nylinjetegnet \n
\	For vanlige karakterer - gjør dem spesielle. For eksempel ser uttrykket /s/ ganske enkelt etter tegnet "s". Og hvis du setter \ foran s, betyr /\s/ allerede et mellomromstegn. Og omvendt, hvis tegnet er spesielt, for eksempel , vil \ gjøre det bare til et vanlig "stjerne". For eksempel søker /a/ etter 0 eller flere påfølgende "a"-tegn. For å finne a med en stjerne "a" - sett \ foran spesialen. symbol: /a\/ .
^	Indikerer begynnelsen av inndataene. Hvis flerlinjes søkeflagget ("m") er satt, vil det også utløses ved starten av en ny linje. For eksempel vil ikke /^A/ finne "A" i "en A", men vil finne den første "A" i "En A."
$	Indikerer slutten på inndataene. Hvis flerlinjers søkeflagget er satt, vil det også fungere på slutten av linjen. For eksempel vil ikke /t$/ finne "t" i "eater", men det vil finne det i "eat".
*	Indikerer repetisjon 0 eller flere ganger. For eksempel vil /bo*/ finne "boooo" i "A spøkelse booooed" og "b" i "A bird warbled", men vil ikke finne noe i "En geit gryntet".
+	Indikerer repetisjon 1 eller flere ganger. Tilsvarer (1,). For eksempel vil /a+/ samsvare med "a" i "godteri" og alle "a" i "caaaaaaandy".
?	Indikerer at elementet kan være til stede eller ikke. For eksempel vil /e?le?/ samsvare med "el" i "angel" og "le" i "angle" hvis den brukes umiddelbart etter en av kvantifikatorene * , + , ? , eller () , spesifiserer deretter et "ikke-grådig" søk (som gjentar minimum antall ganger mulig, til nærmeste neste mønsterelement), i motsetning til standard "grådig"-modus, der antallet repetisjoner er maksimalt, selv om det neste mønsterelementet også stemmer overens. brukt i forhåndsvisningen, som er beskrevet i tabellen under (?=), (?!) og (?:) .
.	(desimaltegnet) representerer et hvilket som helst annet tegn enn en ny linje: \n \r \u2028 eller \u2029. (du kan bruke [\s\S] for å søke etter et hvilket som helst tegn, inkludert nylinjer). For eksempel vil /.n/ matche "an" og "on" i "nei, et eple er på treet", men ikke "nei".
(x)	Finner x og husker. Dette kalles "minneparenteser". For eksempel vil /(foo)/ finne og huske "foo" i "foo bar." Den funnet understrengen lagres i søkeresultatmatrisen eller i de forhåndsdefinerte egenskapene til RegExp-objektet: $1, ..., $9. I tillegg kombinerer parentesene det som finnes i dem til et enkelt mønsterelement. For eksempel (abc)* - gjenta abc 0 eller flere ganger.
(?:x)	Finner x, men husker ikke hva den finner. Dette kalles "minneparenteser". Den funnet understrengen lagres ikke i egenskapene til resultatmatrisen og RegExp. Som alle parenteser, kombinerer de det som er i dem til et enkelt undermønster.
x(?=y)	Finner x bare hvis x etterfølges av y. For eksempel vil /Jack(?=Sprat)/ bare matche "Jack" hvis den blir fulgt av "Sprat". /Jack(?=Sprat\|Frost)/ vil bare matche "Jack" hvis den blir fulgt av "Sprat" eller "Frost". Imidlertid vil verken "Sprat" eller "Frost" vises i søkeresultatet.
x(?!y)	Finner x bare hvis x ikke er etterfulgt av y. For eksempel vil /\d+(?!\.)/ bare samsvare med et tall hvis det ikke etterfølges av et desimaltegn. /\d+(?!\.)/.exec("3.141") vil finne 141, men ikke 3.141.
x\|y	Finner x eller y. For eksempel vil /grønn\|rød/ samsvare med "grønt" i "grønt eple" og "rødt" i "rødt eple".
(n)	Hvor n er et positivt heltall. Finner nøyaktig n repetisjoner av det foregående elementet. For eksempel vil ikke /a(2)/ finne "a" i "godteri", men vil finne både a-er i "caandy" og de to første a-ene i "caaandy".
(n,)	Hvor n er et positivt heltall. Finner n eller flere repetisjoner av et element. For eksempel vil ikke /a(2,) finne "a" i "godteri", men vil finne alle "a" i "caandy" og i "caaaaaaandy."
(n,m)	Hvor n og m er positive heltall. Finn fra n til m repetisjoner av elementet.
	Karaktersett. Finner alle de oppførte tegnene. Du kan angi mellomrom ved å bruke en bindestrek. For eksempel - det samme som . Matcher "b" i "brisket" og "a" og "c" i "verk".
[^xyz]	Alle andre tegn enn de som er spesifisert i settet. Du kan også angi et spenn. For eksempel er [^abc] det samme som [^a-c] . Finner "r" i "brisket" og "h" i "chop".
[\b]	Finner tilbaketegn. (Ikke å forveksle med \b .)
\b	Finner en (latinsk) ordgrense, for eksempel et mellomrom. (Ikke å forveksle med [\b]). For eksempel vil /\bn\w/ matche "nei" i "middag"; /\wy\b/ vil finne "ly" i "muligens i går."
\B	Det angir ikke en ordgrense. For eksempel vil /\w\Bn/ samsvare med "på" i "middag på dagen", og /y\B\w/ vil samsvare med "ye" i "muligens i går."
\cX	Hvor X er en bokstav fra A til Å. Indikerer et kontrolltegn i en streng. For eksempel representerer /\cM/ tegnet Ctrl-M.
\d	finner et tall fra et hvilket som helst alfabet (vårt er Unicode). Bruk for å finne vanlige tall. For eksempel vil /\d/ eller // samsvare med "2" i "B2 er serienummeret."
\D	Finner et ikke-numerisk tegn (alle alfabeter). [^0-9] er ekvivalenten for vanlige tall. For eksempel vil /\D/ eller /[^0-9]/ samsvare med "B" i "B2 er serienummeret."
\s	Finner alle mellomrom, inkludert mellomrom, tabulator, ny linje og andre Unicode-mellomrom. For eksempel vil /\s\w*/ matche "bar" i "foo bar."
\S	Finner alle tegn unntatt mellomrom. For eksempel vil /\S\w*/ matche "foo" i "foo bar."
\v	Vertikalt tabulatortegn.
\w	Finner et hvilket som helst ord (latinsk alfabet), inkludert bokstaver, tall og understreker. Tilsvarende. For eksempel vil /\w/ matche "a" i "eple", "5" i "$5,28" og "3" i "3D."
\W	Finner alle ikke-(latinske) verbale tegn. Tilsvarer [^A-Za-z0-9_] . For eksempel vil /\W/ og /[^$A-Za-z0-9_]/ samsvare med "%" i "50%."

Arbeid med regulære uttrykk i Javascript

Arbeid med regulære uttrykk i Javascript er implementert ved hjelp av metoder i String-klassen

exec(regexp) - finner alle treff (oppføringer i det vanlige mønsteret) i en streng. Returnerer en matrise (hvis det er samsvar) og oppdaterer regexp-egenskapen, eller null hvis ingenting blir funnet. Med g-modifikatoren - hver gang denne funksjonen kalles, vil den returnere neste treff etter den forrige som ble funnet - dette implementeres ved å opprettholde en offset-indeks for det siste søket.

match(regexp) - finn en del av en streng ved å bruke et mønster. Hvis g-modifikatoren er spesifisert, returnerer match() en matrise med alle samsvar eller null (i stedet for en tom matrise). Uten g-modifikatoren fungerer denne funksjonen som exec();

test(regexp) - funksjonen sjekker en streng for å matche et mønster. Returnerer sant hvis det er samsvar, og usant hvis det ikke er samsvar.

split(regexp) - Splitter strengen den kalles opp i en rekke understrenger, ved å bruke argumentet som skilletegn.

replace(regexp, mix) - metoden returnerer en modifisert streng i samsvar med malen (regulært uttrykk). Den første parameteren til regexp kan også være en streng i stedet for et regulært uttrykk. Uten g-modifikatoren erstatter metoden i linjen bare den første forekomsten; med modifikatoren g - oppstår en global erstatning, dvs. alle forekomster i en gitt linje endres.

mix - erstatningsmal, kan godta verdiene til en streng, erstatningsmal, funksjon (funksjonsnavn).

Spesialtegn i erstatningsstrengen Erstatning via funksjon

Hvis du spesifiserer en funksjon som den andre parameteren, utføres den for hvert samsvar. En funksjon kan dynamisk generere og returnere en erstatningsstreng. Den første parameteren til funksjonen er den funnet understrengen. Hvis det første argumentet som skal erstattes er et RegExp-objekt, inneholder de neste n parameterne nestede parenteser. De to siste parameterne er posisjonen i linjen der treffet fant sted og selve linjen.

nytt RegExp(mønster[, flagg])

regulært uttrykk ADVANCE

Det er kjent at den bokstavelige syntaksen (/test/i) er foretrukket.

Hvis det regulære uttrykket ikke er kjent på forhånd, er det å foretrekke å lage et regulært uttrykk (i en tegnstreng) ved å bruke konstruktøren (ny RegExp).

Men vær oppmerksom, siden "slash-tegnet" \ spiller rollen som kodebytte, må det skrives to ganger i strengen bokstavelig (ny RegExp): \\

Flagg

jeg ignorer kasus ved matching

g global samsvar, i motsetning til lokal samsvar (matcher som standard bare den første forekomsten av mønsteret), tillater samsvar for alle forekomster av mønsteret OperatørerHva Hvordan Beskrivelse Bruk /testik/i /testik/g ^ - \ ^ $ ? + + * {} {,}

Jeg	flagg	gjør reg. ufølsomme uttrykk
Jeg	g	globalt søk
Jeg	m
tillater matching mot mange strenger som kan hentes fra tekstområde	tegnklasseoperatør	samsvarende tegnsett
- et hvilket som helst tegn i området fra a til å;	vaktoperatør	unntatt
[^a-z] - hvilket som helst tegn UNNTAT tegn i området fra a til å;	bindestrekoperator	samsvarende tegnsett
angi verdiområdet, inklusive	rømningsoperatør	\\
unnslipper alle følgende tegn	start matching operatør	mønstertilpasning må skje i begynnelsen
/^testik/g	mønstertilpasning bør skje på slutten	/testik$/g
operatør?	gjør tegnet valgfritt	/t?est/g
operatør +		/t+est/g
operatør +	symbolet må være til stede én eller flere ganger	/t+est/g
operatør *	symbolet må være til stede én gang eller gjentatte ganger eller være helt fraværende	/t+est/g
operatør()	angi et fast antall tegngjentakelser	/t(4)est/g
operatør (,)	angi antall repetisjoner av et symbol innenfor visse grenser	/t(4,9)est/g

Forhåndsdefinerte karakterklasser Forhåndsdefinert medlemskartlegging\t \n . \d \D \w \W \s \S \b \B

horisontal fane

Linjeoversettelse

Et hvilket som helst annet tegn enn Line Feed

Ethvert tiende siffer, som tilsvarer

Ethvert tegn annet enn det tiende sifferet, som tilsvarer [^0-9]

Ethvert tegn (tall, bokstaver og understreker) som tilsvarer

Ethvert tegn annet enn tall, bokstaver og understreker, som tilsvarer [^A-Za-z0-9]

Et hvilket som helst mellomromstegn

Hvilket som helst tegn unntatt mellomrom

Ordgrense

IKKE ordets grense, men dets indre. Del

Gruppering()

Hvis du vil bruke en operator som + (/(abcd)+/) på en gruppe medlemmer, kan du bruke parenteser () .

Fiksasjoner

Den delen av det regulære uttrykket som står i parentes () kalles en commit.

Tenk på følgende eksempel:

/^()k\1/

\1 er ikke et hvilket som helst tegn fra a, b, c.
\1 er et hvilket som helst tegn som utløser et samsvar på det første tegnet. Det vil si at tegnet som samsvarer med \1 er ukjent før det regulære uttrykket er løst.

Ufikserte grupper

Klammer () brukes i 2 tilfeller: for gruppering og for å angi fikseringer. Men det er situasjoner når vi trenger å bruke () bare for gruppering, siden commits ikke er påkrevd, i tillegg, ved å fjerne unødvendige commits gjør vi det lettere for prosesseringsmekanismen for regulære uttrykk.

Så, for å forhindre forpliktelse, må du sette ? før åpningsparentesen:

Str = "Hei verden!"; funnet = str.match(/]*?)>/i); console.log("funnet uten rettelse: ", funnet); // [ "" ]

Funksjonstest Regexp.test()

Testfunksjonen sjekker om det regulære uttrykket samsvarer med strengen (str). Returnerer enten sant eller usant.

Brukseksempel:

Javascript-funksjon kodeF(str)( return /^\d(5)-\d(2)/.test(str); ) //console.log(codeF("12345-12ss")); // true //console.log(codeF("1245-12ss")); // falsk funksjon match str.match(regexp)

Matchfunksjonen returnerer en matrise med verdier eller null hvis ingen treff blir funnet.

Merk: hvis det regulære uttrykket ikke har g-flagget (for å utføre et globalt søk), vil samsvarsmetoden returnere det første treffet i strengen, og som du kan se fra eksempelet, inkluderer treff-matrisen FIXATIONS (den del av det regulære uttrykket i parentes).

Javascript str = "For informasjon, se: Kapittel 3.4.5.1"; re = /kapittel (\d+(\.\d)*)/i // med commits (uten globalt flagg) funnet = str.match(re) console.log(funnet); // ["Kapittel 3.4.5.1", "3.4.5.1", ".1"]

Hvis du gir match()-metoden et globalt regulært uttrykk (med g-flagget), vil en matrise også bli returnert, men med GLOBAL-treff. Det vil si at de registrerte resultatene ikke returneres.

Javascript str = "For informasjon, se: Kapittel 3.4.5.1, Kapittel 7.5"; re = /kapittel (\d+(\.\d)*)/ig // uten forpliktelser - globalt funnet = str.match(re) console.log(funnet); // ["Kapittel 3.4.5.1", "Kapittel 7.5"] Funksjon exec regexp.exec(str)

Exec-funksjonen sjekker om et regulært uttrykk samsvarer med en streng (str). Returnerer en rekke resultater (med commits) eller null . Hvert påfølgende kall til exec (for eksempel når du bruker while) skjer (ved at exec automatisk oppdaterer indeksen for slutten av siste søk, lastIndex), og flytter til neste globale treff (hvis g-flagget er spesifisert).

Javascript var html = "BAM! BUM!"; var reg = /]*?)>/g; //console.log(reg.exec(html)); // ["", "", "div", " class="test""] while((match = reg.exec(html)) !== null)( console.log(reg.exec(html)) ; ) /* ["", "", "b", ""] ["", "", "em", ""] ["", "/", "div", ""] */

Uten det globale flagget fungerer match- og exec-metodene identisk. Det vil si at de returnerer en array med den første globale kampen og forplikter seg.

Javascript // match var html = "BAM! BUM!"; var reg = /]*?)>/; // uten global console.log(html.match(reg)); // ["", "", "div", " class="test""] // exec var html = "BAM! BUM!"; var reg = /]*?)>/; // uten global console.log(reg.exec(html)); // ["", "", "div", " class="test""] Funksjon replace str.replace(regexp, newSubStr|function)
regexp - reg. uttrykk;
newSubStr - strengen som det funnet uttrykket i teksten endres til;

funksjon - kalt for hvert samsvar funnet med en variabel liste over parametere (husk at et globalt søk i en streng finner alle forekomster av et mønstertreff).

Funksjonsparametere:

1 - Komplett matchende delstreng.
2 - Betydningen av parentesgrupper (fikseringer).
3 - Indeks (posisjon) for kampen i kildestrengen.
4 - Kildelinje.

Metoden endrer ikke kallestrengen, men returnerer en ny etter å ha erstattet samsvarene. For å utføre et globalt søk og erstatte, bruk regexp med g-flagget.

"GHGHGHGTTTT".replace(//g,"K"); //"KKKKKKKKKKKK"

Javascript-funksjon upLetter(allStr,letter) ( return letter.toUpperCase(); ) var res = "border-top-width".replace(/-(\w)/g, upLetter); console.log(res); //borderTopWidth

Regulære uttrykk er et av de kraftigste datamanipuleringsverktøyene i JavaScript. I tillegg er dette den mest praktiske måten å behandle data på i tilfeller hvor det er umulig å spesifisere et eksakt søkemønster. Det enkleste eksemplet er å markere alle e-postadresser og telefonnumre i teksten. Åpenbart vil et enkelt søk etter en understreng ikke fungere, fordi Vi vet ikke på forhånd hvilke adresser og telefonnumre som vil stå i teksten.

Regulære uttrykk opererer ikke på eksakte verdier, men på mønstre. Et mønster er skrevet ved hjelp av det regulære uttrykket, og vi skal nå gjøre oss kjent med det grunnleggende.

Så ethvert regulært uttrykk består av en separator, en malkropp og modifikatorer (noen ganger kalles de også brytere).

/mønster/bryter

Her er "/" skilletegn, "mønster" er mønsterets kropp, og "switch" er modifikatorene.

Det er bare to måter å bruke regulære uttrykk i JavaScript: ved å bruke metodene til RegExp-objektet eller ved å bruke metodene til String-objektet.

En forekomst av et RegExp-objekt kan opprettes på to måter - eksplisitt og indirekte:

// eksplisitt metode var re = new RegExp("mønster", "switch"); // indirekte (alternativ) metode var re = /pattern/switch;

Vær oppmerksom på at med den indirekte metoden er mønsteret spesifisert UTEN anførselstegn.

Ethvert regulært uttrykk består av vanlige tegn, spesialtegn og repetisjonskvantifiserere. Vanlige tegn inkluderer bokstaver, tall og symboler, men nasjonale tegn og Unicode-tegn kan brukes som tegn. Merk følgende! "Space" anses også som betydningsfull i vanlige uttrykk, så vær veldig forsiktig når du legger til mellomrom i uttrykket ditt. Enda bedre, bruk et spesielt metategn (se \s-symbolet i tabellen nedenfor).

Spesialtegn (eller metategn) er grunnlaget for regulære uttrykk, fordi Det er spesialtegnene som bestemmer søkerekkefølgen og indikerer for uttrykkstolken ytterligere betingelser og begrensninger. Tabellen viser de viktigste spesialtegnene og gir en kort beskrivelse av dem.

Spesiell karakter	Match i mønster
\	For tegn som vanligvis tolkes bokstavelig, betyr at det neste tegnet er spesielt. For eksempel, /n/ samsvarer med bokstaven n, og /\n/ samsvarer med nylinjetegnet. For karakterer som vanligvis behandles som spesielle, betyr at karakteren må tas bokstavelig. For eksempel representerer /^/ begynnelsen av en linje, mens /\^/ bare samsvarer med ^-tegnet. /\\/ samsvarer med omvendt skråstrek \.
^	Tilsvarer begynnelsen av en linje.
$	Tilsvarer slutten av strengen.
(mønster)	Matcher strengmønsteret og husker matchen som ble funnet.
(?:mønster)	Matcher strengmønsteret, men husker ikke matchen som ble funnet. Brukt til å gruppere deler av et mønster, for eksempel, /ko(?:t\|shka)/ er en kort form av uttrykket /cat\|cat/.
(?=mønster)	Lookahead-matching skjer når strengmønsteret matches uten å huske matchen som ble funnet. For eksempel, /Windows (?=95\|98\|NT\|2000)/ samsvarer med "Windows" i strengen "Windows 98", men samsvarer ikke med strengen "Windows 3.1". Etter matching fortsetter søket fra posisjonen ved siden av det funnet, uten å se fremover.
(?!mønster)	Lookahead-matching oppstår når mønsterstrengen ikke matches uten å huske matchen som ble funnet. For eksempel, /Windows (?!95\|98\|NT\|2000)/ samsvarer med "Windows" i strengen "Windows 3.1", men samsvarer ikke med strengen "Windows 98". Etter matching fortsetter søket fra posisjonen ved siden av det funnet, uten å se fremover.
x\|y	Matcher x eller y.
	Matcher ethvert tegn omsluttet av hakeparenteser.
[^xyz]	Matcher alle tegn unntatt de som er omsluttet av hakeparenteser.
	Matcher et hvilket som helst tegn i det angitte området.
[^a-z]	Matcher alle tegn unntatt de i det angitte området.
\b	Tilsvarer en ordgrense, det vil si posisjonen mellom et ord og et mellomrom eller linjeskift.
\B	Matcher enhver posisjon bortsett fra en ordgrense.
\cX	Tilsvarer Ctrl+X-symbolet. For eksempel er /\cI/ ekvivalent med /\t/
\d	Tilsvarer figuren. Tilsvarende.
\D	Tilsvarer et ikke-numerisk tegn. Tilsvarer [^0-9].
\f	Tilsvarer tegnet for formatoversettelse (FF).
\n	Tilsvarer tegnet for linjeskift (LF).
\r	Tilsvarer vognretur-tegnet (CR).
\s	Tilsvarer mellomromstegn. Tilsvarer /[ \f\n\r\t\v]/.
\S	Matcher alle tegn som ikke er mellomrom. Tilsvarer /[^ \f\n\r\t\v]/.
\t	Tilsvarer tabulatortegnet (HT).
\v	Tilsvarer det vertikale tabulatortegnet (VT).
\w	Matcher en latinsk bokstav, tall eller understrek. Tilsvarende / /.
\W	Matcher ethvert tegn annet enn en bokstav, tall eller understrek. Tilsvarer /[^A-Za-z0-9_] /.
\n	n er et positivt tall. Tilsvarer den n'te huskede understrengen. Beregnes ved å telle venstre parentes. Hvis det er færre venstre parentes før dette tegnet enn n, er \0n ekvivalent.
\0n	n er et oktalt tall som ikke er større enn 377. Tilsvarer tegnet med oktal kode n. For eksempel er /\011/ ekvivalent med /\t/.
\xn	n er et heksadesimalt tall som består av to sifre. Matcher tegnet med heksadesimal kode n. For eksempel er /\x31/ ekvivalent med /1/.
\un	n er et heksadesimalt tall som består av fire sifre. Tilsvarer Unicode-tegnet med heksadesimal kode n. For eksempel er /\u00A9/ ekvivalent med /©/.
.	Punktum. Matcher alle tegn.

Det er mange spesialtegn, og med deres hjelp kan du beskrive nesten hvilken som helst frase eller søkefrase.

Den andre komponenten i mønsteret er kvantifiserere. Dette er et undersett av spesialtegn som spesifiserer betingelsen for repetisjon av tegn eller deres grupper. Kvantifisereren er skrevet til høyre for uttrykket og strekker seg til nærmeste tegn eller gruppe. For eksempel:

(mønster_1)|(mønster_2)(antall)

Her refererer kvantifikatoren "quont" bare til "pattern_2".

Tabellen viser alle de viktigste kvantifikatorene:

Kvantifier	Match i mønster
*	Matcher å gjenta forrige tegn null eller flere ganger.
+	Matcher å gjenta forrige tegn en eller flere ganger.
?	Matcher å gjenta forrige tegn null eller én gang. . Matcher alle tegn unntatt nylinje.
(n)	n er et ikke-negativt tall. Tilsvarer nøyaktig n forekomster av det forrige tegnet.
(n,)	n er et ikke-negativt tall. Matcher n eller flere forekomster av det forrige tegnet. /x(1,)/ er ekvivalent med /x+/. /x(0,)/ er ekvivalent med /x*/.
(n,m)	n og m er ikke-negative tall. Tilsvarer minst n og maksimalt m forekomster av det forrige tegnet. /x(0,1)/ er ekvivalent med /x?/.

Så vi har blitt kjent med det grunnleggende i det regulære uttrykksspråket, og nå skal vi prøve ut vår nye kunnskap i praksis. Her er et eksempel på bruk av test()-metoden

var sample = "Appelsiner blir til appelsinjuice";

var re = /oransje*/;

var resultat = re.test(sample) ? "" " : "" Ikke "; document.write("Strengen "" + eksempel + resultat + "matcher mønsteret " + re);

Eksempel på bruk av exec()-metoden

var sample = "Appelsiner blir til appelsinjuice";

var re = /oransje*/;

var resultat = re.exec(sample);