Regulære udtryk js erstatter. En guide til regulære udtryk i JavaScript

Denne artikel dækker det grundlæggende i at bruge regulære udtryk i Javascript.

Indledning Hvad er et regulært udtryk?

Et regulært JS-udtryk er en sekvens af tegn, der danner en søgeregel. Denne regel kan derefter bruges til at søge gennem tekst samt erstatte den. I praksis kan et regulært udtryk endda bestå af et enkelt tegn, men mere komplekse søgemønstre er mere almindelige.

I Javascript er regulære udtryk også objekter. Disse er mønstre, der bruges til at matche sekvenser af tegn i strenge. De bruges i metoderne exec() og test() for RegExp-objektet og i metoderne match(), replace(), search og split() for String-objektet.

Eksempel

var mønster = /eksempel/i

/eksempel/i er et regulært udtryk. eksempel er en skabelon (som vil blive brugt i søgningen). i er en modifikator, der angiver følsomhed for store og små bogstaver.

Forberedelse af et regulært udtryk

JS regulære udtryk består af et mønster og en modifikator. Syntaksen vil være sådan her:

/mønster/modifikatorer;

Skabelonen angiver søgereglen. Den består af simple tegn som /abc/ eller en kombination af simple og specielle tegn: /abc/ eller /Chapter (d+).d/ .

Mønstertabelmodifikatorer giver dig mulighed for at gøre forespørgsler skelne mellem store og små bogstaver, globale og så videre. De bruges til at udføre store og små bogstaver søgninger såvel som globale søgninger. Ændringstabel Nu er vi klar til at anvende JS regulære udtryk. Der er to hovedmåder at gøre dette: ved at bruge et regulært udtryksobjekt eller et regulært udtryk på en streng. Brug af et regulært udtryksobjekt Oprettelse af et regulært udtryksobjekt

Dette objekt beskriver et karaktermønster. Det bruges til mønstermatchning. Der er to måder at konstruere et regulært udtryksobjekt på.

Metode 1: Brug af et regulært udtryk, der består af et mønster omsluttet af skråstreger, for eksempel:

var reg = /ab+c/;

Regulære udtryks bogstaver udløser prækompilering af det regulære udtryk, når scriptet parses. Hvis det regulære udtryk er konstant, så brug det til at forbedre ydeevnen.

Metode 2: Kaldning af konstruktorfunktionen for RegExp-objektet, for eksempel:

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

Brug af en konstruktør tillader det regulære JS-udtryk at blive kompileret, mens scriptet kører. Brug denne metode, hvis det regulære udtryk vil ændre sig, eller du ikke kender mønsteret på forhånd. For eksempel hvis du modtager information fra en bruger, der indtaster en søgeforespørgsel.

Regulære udtryksobjektmetoder

Lad os tage et kig på et par almindelige regulære udtryksobjektmetoder:

compile() (forældet i version 1.5) – kompilerer et regulært udtryk;
exec() - Udfører et strengmatch. Returnerer det første match;
test() - udfører et match på en streng. Returnerer sand eller falsk;
toString() – returnerer strengværdien af det regulære udtryk.

Eksempler på brug af test()

Test()-metoden er et regulært udtryk for RegExp-objektet. Den søger efter en mønsterstreng og returnerer sand eller falsk afhængigt af resultatet. Følgende JS regulære udtrykseksempel viser, hvordan en streng søges efter tegnet "e":

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

Da der er et "e" i strengen her, vil resultatet af denne kode være sandt.

Regulære udtryk skal ikke placeres i en variabel. Den samme forespørgsel kan udføres på én linje:

/e/.test("De bedste ting i verden er gratis!");

Brug af exec()

Den søger i en streng ved hjælp af en given søgeregel og returnerer den fundne tekst. Hvis der ikke blev fundet nogen resultater, vil resultatet være null .

Lad os se på metoden i aktion ved at bruge det samme symbol "e" som eksempel:

/e/.exec("De bedste ting i verden er gratis!");

Da der er et "e" i strengen, vil resultatet af denne kode være .e .

Anvendelse af et regulært udtryk på en streng

I Javascript kan disse udtryk også bruges med to metoder af String-objektet: search() og replace(). De er nødvendige for at udføre søgning og erstatning i tekst.

search() metode - bruger et udtryk til at søge efter et match, og returnerer information om placeringen af matchet;
metoden replace() returnerer en ændret streng med et erstattet mønster.

Eksempler

Brug af et regulært JS-udtryk til at udføre en versalfølsom søgning efter udtrykket "w3schools" i strengen:

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

Resultatet i n bliver 6.

Søgemetoden tager også en streng som argument. Stringargumentet vil blive konverteret til et regulært udtryk:

Brug af streng til at søge efter udtrykket "W3schools" i en streng.

I JavaScript er regulære udtryk repræsenteret af RegExp-objekter. RegExp-objekter kan oprettes ved hjælp af RegExp()-konstruktøren, men oftere oprettes de ved hjælp af en speciel bogstavelig syntaks. Ligesom strengliteraler er angivet som tegn omgivet af anførselstegn, angives literaler i regulære udtryk som tegn omgivet af et par skråstreger / .

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

mønster er et regulært udtryk for søgningen (mere om udskiftning senere), og flag er en streng af en hvilken som helst kombination af tegnene g (global søgning), i (case og store bogstaver er ikke vigtig) og m (multi-line search). Den første metode bruges ofte, den anden - nogle gange. For eksempel er to sådanne opkald ækvivalente.

Søgemuligheder

Når vi opretter et regulært udtryk, kan vi angive yderligere søgemuligheder

Tegn i regulære JavaScript-udtryk Symbolkorrespondance

Alfanumeriske tegn	Svare til dem selv
\0	NUL-tegn (\u0000)
\t	Fane (\u0009)
\n	Linjefeed (\u000A)
\v	Lodret fane (\u000B)
\f	Sideoversættelse (\u000C)
\r	Returvogn (\u000D)
\xnn	Et tegn fra det latinske sæt, angivet med det hexadecimale tal nn; f.eks. er \x0A det samme som \n
\uxxxx	Unicode-tegn angivet med hexadecimalt tal xxxx; f.eks. er \u0009 det samme som \t
\cX	Kontroltegnet "X", f.eks. rækkefølgen \cJ svarer til nylinjetegnet \n
\	For almindelige karakterer - gør dem specielle. For eksempel leder udtrykket /s/ blot efter tegnet "s". Og hvis du sætter \ før s, så betegner /\s/ allerede et mellemrumstegn. Og omvendt, hvis tegnet er specielt, for eksempel , vil \ gøre det til et almindeligt "stjernetegn". For eksempel søger /a/ efter 0 eller flere på hinanden følgende "a"-tegn. For at finde a med en stjerne "a" - sæt \ foran specialen. symbol: /a\/ .
^	Angiver begyndelsen af inputdata. Hvis flerlinjesøgningsflaget ("m") er sat, vil det også udløses ved starten af en ny linje. For eksempel vil /^A/ ikke finde "A"et i "et A", men vil finde det første "A" i "En A."
$	Angiver slutningen af inputdata. Hvis multiline-søgeflaget er sat, vil det også virke i slutningen af linjen. For eksempel vil /t$/ ikke finde "t" i "eater", men det vil finde det i "eat".
*	Angiver gentagelse 0 eller flere gange. F.eks. vil /bo*/ finde "boooo" i "A spøgelse booooed" og "b" i "A bird warbled", men vil ikke finde noget i "En ged gryntede".
+	Angiver gentagelse 1 eller flere gange. Svarende til (1,). For eksempel vil /a+/ matche "a" i "slik" og alle "a" i "caaaaaaandy".
?	Indikerer, at elementet kan være til stede eller ikke. For eksempel vil /e?le?/ matche "el" i "angel" og "le" i "vinkel", hvis det bruges umiddelbart efter en af kvantificatorerne * , + , ? , eller () , angiver derefter en "ikke-grådig" søgning (gentager det mindst mulige antal gange, til det nærmeste næste mønsterelement), i modsætning til standardtilstanden "greedy", hvor antallet af gentagelser er maksimalt, selvom det næste mønsterelement også matcher. brugt i forhåndsvisningen, som er beskrevet i tabellen under (?=), (?!) og (?:) .
.	(Decimaltegn) repræsenterer et hvilket som helst andet tegn end en ny linje: \n \r \u2028 eller \u2029. (du kan bruge [\s\S] til at søge efter et hvilket som helst tegn, inklusive nylinjer). For eksempel vil /.n/ matche "an" og "on" i "nej, et æble er på træet", men ikke "nej".
(x)	Finder x og husker. Dette kaldes "hukommelsesbeslag". For eksempel vil /(foo)/ finde og huske "foo" i "foo bar." Den fundne understreng gemmes i søgeresultatarrayet eller i de foruddefinerede egenskaber for RegExp-objektet: $1, ..., $9. Derudover kombinerer parenteserne, hvad der er indeholdt i dem, til et enkelt mønsterelement. For eksempel (abc)* - gentag abc 0 eller flere gange.
(?:x)	Finder x, men husker ikke, hvad den finder. Dette kaldes "hukommelsesparenteser". Den fundne understreng er ikke gemt i resultatarrayet og RegExp-egenskaberne. Som alle parenteser kombinerer de, hvad der er i dem, til et enkelt undermønster.
x(?=y)	Finder kun x, hvis x efterfølges af y. For eksempel vil /Jack(?=Sprat)/ kun matche "Jack", hvis den efterfølges af "Sprat". /Jack(?=Sprat\|Frost)/ vil kun matche "Jack", hvis den efterfølges af "Sprat" eller "Frost". Hverken "Sprat" eller "Frost" vises dog i søgeresultatet.
x(?!y)	Finder kun x, hvis x ikke er efterfulgt af y. For eksempel vil /\d+(?!\.)/ kun matche et tal, hvis det ikke efterfølges af et decimaltegn. /\d+(?!\.)/.exec("3.141") vil finde 141, men ikke 3.141.
x\|y	Finder x eller y. For eksempel vil /grøn\|rød/ matche "grøn" i "grønt æble" og "rød" i "rødt æble".
(n)	Hvor n er et positivt heltal. Finder nøjagtigt n gentagelser af det foregående element. For eksempel vil /a(2)/ ikke finde "a" i "slik", men vil finde både a'er i "caandy" og de to første a'er i "caaandy".
(n,)	Hvor n er et positivt heltal. Finder n eller flere gentagelser af et element. For eksempel vil /a(2,) ikke finde "a" i "slik", men vil finde alle "a" i "caandy" og i "caaaaaaandy."
(n,m)	Hvor n og m er positive heltal. Find fra n til m gentagelser af elementet.
	Karaktersæt. Finder alle de angivne tegn. Du kan angive mellemrum ved at bruge en bindestreg. For eksempel - det samme som . Matcher "b" i "brisket" og "a" og "c" i "pine".
[^xyz]	Ethvert andet tegn end dem, der er angivet i sættet. Du kan også angive et span. For eksempel er [^abc] det samme som [^a-c] . Finder "r" i "brisket" og "h" i "chop".
[\b]	Finder backspace-tegnet. (Ikke at forveksle med \b .)
\b	Finder en (latinsk) ordgrænse, såsom et mellemrum. (Ikke at forveksle med [\b]). For eksempel vil /\bn\w/ matche "nej" i "middag"; /\wy\b/ vil finde "ly" i "muligvis i går."
\B	Det angiver ikke en ordgrænse. For eksempel vil /\w\Bn/ matche "på" i "middag", og /y\B\w/ vil matche "jer" i "muligvis i går."
\cX	Hvor X er et bogstav fra A til Z. Angiver et kontroltegn i en streng. For eksempel repræsenterer /\cM/ tegnet Ctrl-M.
\d	finder et tal fra ethvert alfabet (vores er Unicode). Brug kun til at finde almindelige tal. For eksempel vil /\d/ eller // matche "2" i "B2 er suitenummeret."
\D	Finder et ikke-numerisk tegn (alle alfabeter). [^0-9] svarer til almindelige tal. For eksempel vil /\D/ eller /[^0-9]/ matche "B" i "B2 er suitenummeret."
\s	Matcher ethvert mellemrum, inklusive mellemrum, tabulator, ny linje og andre Unicode-mellemrumstegn. For eksempel vil /\s\w*/ matche "bar" i "foo bar."
\S	Finder ethvert tegn undtagen mellemrum. For eksempel vil /\S\w*/ matche "foo" i "foo bar."
\v	Lodret tabulatortegn.
\w	Finder ethvert ord (latinsk alfabet), inklusive bogstaver, tal og understregninger. Tilsvarende. For eksempel vil /\w/ matche "a" i "æble", "5" i "$5,28" og "3" i "3D."
\W	Finder enhver ikke-(latinsk) verbal karakter. Svarer til [^A-Za-z0-9_] . For eksempel vil /\W/ og /[^$A-Za-z0-9_]/ matche "%" i "50%."

Arbejde med regulære udtryk i Javascript

Arbejde med regulære udtryk i Javascript er implementeret ved hjælp af metoder fra String-klassen

exec(regexp) - finder alle matches (indgange i det almindelige mønster) i en streng. Returnerer et array (hvis der er et match) og opdaterer regexp-egenskaben eller null, hvis der ikke findes noget. Med g-modifikatoren - hver gang denne funktion kaldes, vil den returnere det næste match efter den forrige fundet - dette implementeres ved at opretholde et offset-indeks for den sidste søgning.

match(regexp) - find en del af en streng ved hjælp af et mønster. Hvis g-modifikatoren er angivet, returnerer match() en matrix med alle matches eller null (i stedet for en tom matrix). Uden g-modifikatoren fungerer denne funktion som exec();

test(regexp) - funktionen kontrollerer en streng for at matche et mønster. Returnerer sand, hvis der er et match, og falsk hvis der ikke er match.

split(regexp) - Opdeler den streng, den kaldes på, i et array af understrenge, ved at bruge argumentet som afgrænsning.

replace(regexp, mix) - metoden returnerer en modificeret streng i overensstemmelse med skabelonen (regulært udtryk). Den første parameter til regexp kan også være en streng i stedet for et regulært udtryk. Uden g-modifikatoren erstatter metoden i linjen kun den første forekomst; med modifikationen g - sker der en global udskiftning, dvs. alle forekomster i en given linje ændres.

mix - erstatningsskabelon, kan acceptere værdierne af en streng, erstatningsskabelon, funktion (funktionsnavn).

Specialtegn i erstatningsstrengen Erstatnings via funktion

Hvis du angiver en funktion som den anden parameter, udføres den ved hver match. En funktion kan dynamisk generere og returnere en substitutionsstreng. Funktionens første parameter er den fundne understreng. Hvis det første argument, der skal erstattes, er et RegExp-objekt, så indeholder de næste n parametre indlejrede parenteser. De sidste to parametre er positionen i linjen, hvor matchen fandt sted, og selve linjen.

nyt RegExp(mønster[, flag])

regulært udtryk ADVANCE

Det er kendt, at den bogstavelige syntaks (/test/i) foretrækkes.

Hvis det regulære udtryk ikke er kendt på forhånd, er det at foretrække at oprette et regulært udtryk (i en tegnstreng) ved hjælp af konstruktøren (nyt RegExp).

Men vær opmærksom, da "skråstegnet" \ spiller rollen som kodeskift, skal det skrives to gange i strengen literal (nyt RegExp): \\

Flag

Jeg ignorer sagen, når jeg matcher

g global matching, i modsætning til lokal matching (matcher som standard kun den første forekomst af mønsteret), tillader matches alle forekomster af mønsteret OperatørerHvad Hvordan Beskrivelse Brug /testik/i /testik/g ^ - \ ^ $ ? + + * {} {,}

jeg	flag	gør reg. kasus ufølsomt udtryk
jeg	g	global søgning
jeg	m
tillader matchning mod mange strenge, der kan hentes fra tekstområdet	tegnklasseoperatør	matchende tegnsæt
- ethvert tegn i området fra a til z;	vagtoperatør	undtagen
[^a-z] - ethvert tegn UNDTAGET tegn i området fra a til z;	bindestreg operator	matchende tegnsæt
angive værdiintervallet, inklusive	flugtoperatør	\\
undslipper alle følgende tegn	begynde at matche operatør	mønstertilpasning skal ske i begyndelsen
/^testik/g	mønstertilpasning skal ske til sidst	/testik$/g
operatør?	gør tegnet valgfrit	/t?est/g
operatør +		/t+est/g
operatør +	symbolet skal være til stede én eller flere gange	/t+est/g
operatør *	symbolet skal være til stede én gang eller gentagne gange eller være helt fraværende	/t+est/g
operatør()	sæt et fast antal tegngentagelser	/t(4)est/g
operatør (,)	indstille antallet af gentagelser af et symbol inden for visse grænser	/t(4,9)est/g

Foruddefinerede tegnklasser Foruddefineret medlemskortlægning\t \n . \d \D \w \W \s \S \b \B

vandret fane

Line feed

Ethvert tegn undtagen Line Feed

Ethvert tiende ciffer, hvilket svarer til

Ethvert andet tegn end det tiende ciffer, som svarer til [^0-9]

Ethvert tegn (tal, bogstaver og understregninger), der er ækvivalente

Ethvert tegn bortset fra tal, bogstaver og understregninger, som svarer til [^A-Za-z0-9]

Ethvert mellemrumstegn

Ethvert tegn undtagen mellemrum

Ordgrænse

IKKE ordets grænse, men dets indre. Del

Gruppering()

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

Fikseringer

Den del af det regulære udtryk, der er indesluttet i parentes () kaldes en commit.

Overvej følgende eksempel:

/^()k\1/

\1 er ikke et hvilket som helst tegn fra a, b, c.
\1 er ethvert tegn, der udløser et match på det første tegn. Det vil sige, at tegnet, der matcher \1, er ukendt, indtil det regulære udtryk er løst.

Ufikserede grupper

Klammer () bruges i 2 tilfælde: til gruppering og til at angive fikseringer. Men der er situationer, hvor vi kun skal bruge () til gruppering, da commits ikke er påkrævet, og ved at fjerne unødvendige commits gør vi det desuden lettere for den regulære udtryksbehandlingsmekanisme.

Så for at forhindre at du binder dig, skal du sætte ?

Str = "Hej verden!"; fundet = str.match(/]*?)>/i); console.log("fundet uden rettelse: ", fundet); // [ "" ]

Funktionstest Regexp.test()

Testfunktionen kontrollerer, om det regulære udtryk matcher strengen (str). Returnerer enten sand eller falsk.

Eksempel på brug:

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

Matchfunktionen returnerer en matrix af værdier eller null, hvis der ikke findes nogen match.

Bemærk: hvis det regulære udtryk ikke har g-flaget (for at udføre en global søgning), vil matchmetoden returnere det første match i strengen, og som du kan se fra eksemplet, inkluderer matches-arrayet FIXATIONS (den del af det regulære udtryk omgivet af parentes).

Javascript str = "For information, se venligst: Kapitel 3.4.5.1"; re = /kapitel (\d+(\.\d)*)/i // med commits (uden globalt flag) fundet = str.match(re) console.log(fundet); // ["Kapitel 3.4.5.1", "3.4.5.1", ".1"]

Hvis du giver match()-metoden et globalt regulært udtryk (med g-flaget), vil der også blive returneret et array, men med GLOBAL match. Det vil sige, at de registrerede resultater ikke returneres.

Javascript str = "For information, se: Kapitel 3.4.5.1, Kapitel 7.5"; re = /kapitel (\d+(\.\d)*)/ig // uden commits - globalt fundet = str.match(re) console.log(fundet); // ["Kapitel 3.4.5.1", "Kapitel 7.5"] Funktion exec regexp.exec(str)

Exec-funktionen kontrollerer, om et regulært udtryk matcher en streng (str). Returnerer en række resultater (med commits) eller null . Hvert efterfølgende kald til exec (f.eks. når du bruger while) forekommer (ved at exec automatisk opdaterer indekset for slutningen af den sidste søgning, lastIndex), og flytter til det næste globale match (hvis g-flaget er angivet).

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", ""] */

Uden det globale flag fungerer match- og exec-metoderne identisk. Det vil sige, at de returnerer et array med det første globale match og forpligter sig.

Javascript // match var html = "BAM! BUM!"; var reg = /]*?)>/; // uden global console.log(html.match(reg)); // ["", "", "div", " class="test""] // exec var html = "BAM! BUM!"; var reg = /]*?)>/; // uden global console.log(reg.exec(html)); // ["", "", "div", " class="test""] Funktion replace str.replace(regexp, newSubStr|function)
regexp - reg. udtryk;
newSubStr - strengen, som det fundne udtryk i teksten ændres til;

funktion - kaldet for hvert match fundet med en variabel liste over parametre (husk at en global søgning i en streng finder alle forekomster af et mønstermatch).

Funktionsparametre:

1 - Komplet matchet understreng.
2 - Betydningen af parentesgrupper (fikseringer).
3 - Indeks (position) af kampen i kildestrengen.
4 - Kildelinje.

Metoden ændrer ikke den kaldende streng, men returnerer en ny efter at have erstattet matchene. For at udføre en global søgning og erstat, brug regexp med g-flaget.

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

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

Regulære udtryk er et af de mest kraftfulde datamanipulationsværktøjer i JavaScript. Derudover er dette den mest bekvemme måde at behandle data på i tilfælde, hvor det er umuligt at angive et nøjagtigt søgemønster. Det enkleste eksempel er at fremhæve alle e-mailadresser og telefonnumre i teksten. Det er klart, at en simpel søgning efter en understreng ikke virker, fordi Vi ved ikke på forhånd, hvilke adresser og telefonnumre der kommer til at stå i teksten.

Regulære udtryk opererer ikke på nøjagtige værdier, men på mønstre. Et mønster er skrevet ved hjælp af det regulære udtryk sprog, og vi vil nu stifte bekendtskab med dets grundlæggende.

Så ethvert regulært udtryk består af en separator, en skabelontekst og modifikatorer (nogle gange kaldes de også switche).

/mønster/skift

Her er "/" separatoren, "mønster" er mønsterets krop, og "switch" er modifikatorerne.

Der er kun to måder at bruge regulære udtryk i JavaScript: ved at bruge metoderne til RegExp-objektet eller ved at bruge metoderne til String-objektet.

En forekomst af et RegExp-objekt kan oprettes på to måder - eksplicit og indirekte:

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

Bemærk venligst, at med den indirekte metode er mønsteret angivet UDEN anførselstegn.

Ethvert regulært udtryk består af regulære tegn, specialtegn og gentagelseskvantatorer. Almindelige tegn omfatter bogstaver, tal og symboler, men nationale tegn og Unicode-tegn kan bruges som tegn. Opmærksomhed! "Mellemrum" betragtes også som betydningsfuldt i regulære udtryk, så vær meget forsigtig, når du tilføjer mellemrum til dit udtryk. Endnu bedre, brug et særligt metategn (se \s-symbolet i tabellen nedenfor).

Specialtegn (eller metategn) er grundlaget for regulære udtryk, fordi Det er specialtegnene, der bestemmer søgerækkefølgen og angiver for udtryksfortolkeren yderligere betingelser og begrænsninger. Tabellen viser de vigtigste specialtegn og giver en kort beskrivelse af dem.

Specialkarakter	Match i mønster
\	For tegn, der normalt fortolkes bogstaveligt, betyder det, at det næste tegn er specielt. F.eks. matcher /n/ bogstavet n, og /\n/ matcher nylinjetegnet. For karakterer, der normalt behandles som specielle, betyder det, at karakteren skal tages bogstaveligt. For eksempel repræsenterer /^/ begyndelsen af en linje, mens /\^/ blot matcher tegnet ^. /\\/ matcher omvendt skråstreg \.
^	Matcher begyndelsen af en linje.
$	Matcher slutningen af strengen.
(mønster)	Matcher strengmønsteret og husker det fundne match.
(?:mønster)	Matcher strengmønsteret, men husker ikke det fundne match. Brugt til at gruppere dele af et mønster, f.eks. /ko(?:t\|shka)/ er en kort form af udtrykket /cat\|cat/.
(?=mønster)	Lookahead-matchning opstår, når strengmønsteret matches uden at huske det fundne match. For eksempel matcher /Windows (?=95\|98\|NT\|2000)/ "Windows" i strengen "Windows 98", men matcher ikke i strengen "Windows 3.1". Efter matchning fortsætter søgningen fra positionen ved siden af det fundne match uden at se fremad.
(?!mønster)	Lookahead-matchning opstår, når mønsterstrengen ikke matches uden at huske det fundne match. For eksempel matcher /Windows (?!95\|98\|NT\|2000)/ "Windows" i strengen "Windows 3.1", men matcher ikke i strengen "Windows 98". Efter matchning fortsætter søgningen fra positionen ved siden af det fundne match uden at se fremad.
x\|y	Matcher x eller y.
	Matcher ethvert tegn omgivet af firkantede parenteser.
[^xyz]	Matcher ethvert tegn undtagen dem, der er omgivet af firkantede parenteser.
	Matcher ethvert tegn i det angivne område.
[^a-z]	Matcher ethvert tegn undtagen dem i det angivne område.
\b	Matcher en ordgrænse, dvs. positionen mellem et ord og et mellemrum eller linjeskift.
\B	Matcher enhver position undtagen en ordgrænse.
\cX	Svarer til Ctrl+X-symbolet. For eksempel er /\cI/ ækvivalent med /\t/
\d	Svarer til figuren. Tilsvarende.
\D	Matcher et ikke-numerisk tegn. Svarende til [^0-9].
\f	Svarer til tegnet for formatoversættelse (FF).
\n	Matcher tegnet for linjeskift (LF).
\r	Svarer til vognretur-tegnet (CR).
\s	Matcher mellemrumstegn. Svarer til /[ \f\n\r\t\v]/.
\S	Matcher ethvert tegn uden mellemrum. Svarende til /[^ \f\n\r\t\v]/.
\t	Matcher tabulatortegnet (HT).
\v	Svarer til det lodrette tabulatortegn (VT).
\w	Matcher et latinsk bogstav, tal eller understregning. Svarende til / /.
\W	Matcher ethvert andet tegn end et bogstav, tal eller understregning. Svarende til /[^A-Za-z0-9_] /.
\n	n er et positivt tal. Svarer til den n'te lagrede understreng. Beregnes ved at tælle venstre parentes. Hvis der er færre venstre parenteser før dette tegn end n, så er \0n ækvivalent.
\0n	n er et oktal tal, der ikke er større end 377. Svarer til tegnet med oktal kode n. For eksempel svarer /\011/ til /\t/.
\xn	n er et hexadecimalt tal bestående af to cifre. Matcher tegnet med hexadecimal kode n. For eksempel svarer /\x31/ til /1/.
\un	n er et hexadecimalt tal bestående af fire cifre. Svarer til Unicode-tegnet med hexadecimal kode n. For eksempel svarer /\u00A9/ til /©/.
.	Prik. Matcher enhver karakter.

Der er en masse specialtegn, og med deres hjælp kan du beskrive næsten enhver sætning eller søgesætning.

Den anden komponent i mønsteret er kvantificerere. Dette er en undergruppe af specialtegn, der specificerer betingelsen for gentagelse af tegn eller deres grupper. Kvantifikatoren er skrevet til højre for udtrykket og strækker sig til nærmeste tegn eller gruppe. For eksempel:

(mønster_1)|(mønster_2)(quot)

Her henviser kvantifieren "quont" kun til "pattern_2".

Tabellen viser alle de vigtigste kvantifikatorer:

Kvantifier	Match i mønster
*	Matcher at gentage det forrige tegn nul eller flere gange.
+	Matcher at gentage det forrige tegn en eller flere gange.
?	Matcher at gentage det forrige tegn nul eller én gang. . Matcher ethvert tegn undtagen nylinje.
(n)	n er et ikke-negativt tal. Matcher nøjagtigt n forekomster af det forrige tegn.
(n,)	n er et ikke-negativt tal. Matcher n eller flere forekomster af det forrige tegn. /x(1,)/ svarer til /x+/. /x(0,)/ svarer til /x*/.
(n,m)	n og m er ikke-negative tal. Matcher mindst n og højst m forekomster af det forrige tegn. /x(0,1)/ svarer til /x?/.

Så vi er blevet fortrolige med det grundlæggende i det regulære udtrykssprog, og nu vil vi afprøve vores nye viden i praksis. Her er et eksempel på brug af test() metoden

var sample = "Appelsiner bliver til appelsinjuice";

var re = /orange*/;

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

Eksempel på brug af exec() metode

var sample = "Appelsiner bliver til appelsinjuice";

var re = /orange*/;

var resultat = re.exec(sample);