Regulārās izteiksmes js aizstāj. JavaScript regulāro izteiksmju ceļvedis

Šajā rakstā ir aprakstīti Javascript regulārās izteiksmes lietošanas pamati.

Ievads Kas ir regulārā izteiksme?

JS regulārā izteiksme ir rakstzīmju secība, kas veido meklēšanas kārtulu. Pēc tam šo noteikumu var izmantot, lai meklētu tekstā, kā arī to aizstātu. Praksē regulāra izteiksme var sastāvēt pat no vienas rakstzīmes, taču biežāk sastopami sarežģītāki meklēšanas modeļi.

Javascript regulārās izteiksmes ir arī objekti. Tie ir modeļi, ko izmanto, lai saskaņotu rakstzīmju secības virknēs. Tos izmanto RegExp objekta exec() un test() metodēs, kā arī String objekta match(), replace(), search un split() metodēs.

Piemērs

var modelis = /example/i

/example/i ir regulāra izteiksme. piemērs ir veidne (kas tiks izmantota meklēšanā). i ir modifikators, kas norāda reģistrjutību.

Regulāras izteiksmes sagatavošana

JS regulārās izteiksmes sastāv no modeļa un modifikatora. Sintakse būs aptuveni šāda:

/pattern/modifiers;

Veidne norāda meklēšanas noteikumu. Tas sastāv no vienkāršām rakstzīmēm, piemēram, /abc/ vai vienkāršu un speciālo rakstzīmju kombinācijas: /abc/ vai /Chapter (d+).d/ .

Rakstu tabulas modifikatori ļauj vaicājumos iestatīt reģistrjutīgus, globālus utt. Tos izmanto, lai veiktu reģistrjutīgu meklēšanu, kā arī globālu meklēšanu. Modifikatoru tabula Tagad esam gatavi lietot JS regulārās izteiksmes. Ir divi galvenie veidi, kā to izdarīt: izmantojot regulāras izteiksmes objektu vai regulāru izteiksmi virknē. Regulārās izteiksmes objekta izmantošana Regulārās izteiksmes objekta izveide

Šis objekts apraksta rakstzīmju modeli. To izmanto modeļu saskaņošanai. Pastāv divi veidi, kā izveidot regulāras izteiksmes objektu.

1. metode. Regulāras izteiksmes literāļa izmantošana, kas sastāv no parauga, kas ietverts slīpsvītrās, piemēram:

var reg = /ab+c/;

Regulārās izteiksmes literāļi aktivizē regulārās izteiksmes iepriekšēju kompilāciju, kad skripts tiek parsēts. Ja regulārā izteiksme ir nemainīga, izmantojiet to, lai uzlabotu veiktspēju.

2. metode: RegExp objekta konstruktora funkcijas izsaukšana, piemēram:

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

Konstruktora izmantošana ļauj JS regulāro izteiksmi kompilēt, kamēr darbojas skripts. Izmantojiet šo metodi, ja regulārā izteiksme mainīsies vai jūs iepriekš nezināt modeli. Piemēram, ja saņemat informāciju no lietotāja, kurš ievada meklēšanas vaicājumu.

Regulārās izteiksmes objektu metodes

Apskatīsim dažas izplatītas regulārās izteiksmes objektu metodes:

• compile() (novecojis versijā 1.5) – apkopo regulāro izteiksmi;
• exec() — veic virknes atbilstību. Atgriež pirmo maču;
• test() - veic atbilstību virknei. Atgriež patiesu vai nepatiesu ;
• toString() – atgriež regulārās izteiksmes virknes vērtību.

Test() izmantošanas piemēri

Test() metode ir RegExp objekta regulāra izteiksme. Tas meklē raksta virkni un atkarībā no rezultāta atgriež patiesu vai nepatiesu. Šis JS regulārās izteiksmes piemērs parāda, kā virknē tiek meklēta rakstzīme “e”:

var patt = /e/; patt.test("Labākās lietas pasaulē ir bez maksas!");

Tā kā virknē šeit ir burts “e”, šī koda rezultāts būs patiess.

Regulāras izteiksmes nav jāievieto mainīgajā. To pašu vaicājumu var veikt vienā rindā:

/e/.test("Labākās lietas pasaulē ir bez maksas!");

Izmantojot exec()

Tas meklē virkni, izmantojot noteiktu meklēšanas noteikumu, un atgriež atrasto tekstu. Ja neviena atbilstība netika atrasta, rezultāts būs nulle .

Apskatīsim metodi darbībā, kā piemēru izmantojot to pašu simbolu “e”:

/e/.exec("Labākās lietas pasaulē ir bez maksas!");

Tā kā virknē ir burts “e”, šī koda rezultāts būs .e .

Regulāras izteiksmes lietošana virknei

Javascript šīs izteiksmes var izmantot arī ar divām String objekta metodēm: search () un aizstāt (). Tie ir nepieciešami, lai veiktu meklēšanu un aizstāšanu tekstā.

• search() metode - izmanto izteiksmi, lai meklētu atbilstību, un atgriež informāciju par atbilstības atrašanās vietu;
• Metode aizstāt () atgriež modificētu virkni ar aizstātu modeli.

Piemēri

Izmantojot JS regulāro izteiksmi, lai virknē veiktu frāzes “w3schools” reģistrjutīgu meklēšanu:

var str = "Apmeklēt W3Schools"; var n = str.search(/w3schools/i);

Rezultāts n būs 6.

Meklēšanas metode arī izmanto virkni kā argumentu. Virknes arguments tiks pārveidots par regulāru izteiksmi:

Izmantojot virkni, lai virknē meklētu frāzi “W3schools”.

Programmā JavaScript regulārās izteiksmes attēlo RegExp objekti. RegExp objektus var izveidot, izmantojot RegExp() konstruktoru, bet biežāk tie tiek veidoti, izmantojot īpašu literālo sintaksi. Tāpat kā virknes literāļi tiek norādīti kā rakstzīmes, kas ievietotas pēdiņās, regulārās izteiksmes literāļi tiek norādīti kā rakstzīmes, kas ietvertas slīpsvītru rakstzīmju pārī / .

/pattern/flags new RegExp("raksts"[, meklēšanas opcijas])

modelis ir regulāra izteiksme meklēšanai (vairāk par aizstāšanu vēlāk), un karodziņi ir virkne no jebkuras rakstzīmju kombinācijas g (globālā meklēšana), i (reģistrs nav svarīgs) un m (vairāku rindiņu meklēšana). Pirmo metodi izmanto bieži, otro - dažreiz. Piemēram, divi šādi zvani ir līdzvērtīgi.

Meklēšanas iespējas

Veidojot regulāro izteiksmi, varam norādīt papildu meklēšanas opcijas

Rakstzīmes JavaScript regulārajās izteiksmēs Simbolu sarakste

Burtciparu rakstzīmes	Atbilst sev
\0	NUL rakstzīme (\u0000)
\t	Cilne (\u0009)
\n	Rindas plūsma (\u000A)
\v	Vertikālā cilne (\u000B)
\f	Lapas tulkojums (\u000C)
\r	Karietes atgriešana (\u000D)
\xnn	Rakstzīme no latīņu kopas, kas norādīta ar heksadecimālo skaitli nn; piemēram, \x0A ir tas pats, kas \n
\uxxxx	Unikoda rakstzīme, kas norādīta ar heksadecimālo skaitli xxxx; piemēram, \u0009 ir tas pats, kas \t
\cX	Vadības rakstzīme "X", piemēram, secība \cJ ir līdzvērtīga jaunrindas rakstzīmei \n
\	Parastajiem varoņiem - padara tos īpašus. Piemēram, izteiksme /s/ vienkārši meklē rakstzīmi "s". Un, ja pirms s ievietojat \, tad /\s/ jau apzīmē atstarpes rakstzīmi un otrādi, ja rakstzīme ir īpaša, piemēram, *, tad \ padarīs to tikai par parastu "zvaigznīti". Piemēram, /a*/ meklē 0 vai vairākas secīgas "a" rakstzīmes. Lai atrastu a ar zvaigznīti "a*", ievietojiet \ pirms īpašā. simbols: /a\*/ .
^	Norāda ievades datu sākumu. Ja ir iestatīts vairāku rindiņu meklēšanas karodziņš ("m"), tas tiks aktivizēts arī jaunas rindas sākumā. Piemēram, /^A/ neatradīs "A" burtā "A", bet atradīs pirmo "A" burtā "An A."
$	Norāda ievades datu beigas. Ja ir iestatīts vairāku rindu meklēšanas karodziņš, tas darbosies arī rindas beigās. Piemēram, /t$/ neatradīs "t" laukā "eat", bet to atradīs "eat".
*	Norāda atkārtojumu 0 vai vairāk reižu. Piemēram, /bo*/ neatradīs "boooo" frāzē "A spoks booooed" un "b" ierakstā "Putns griezās", bet neko neatradīs sadaļā "Kaza ņurdēja".
+	Norāda atkārtojumu 1 vai vairāk reizes. Atbilst (1,). Piemēram, /a+/ atbilst "a" vārdam "konfektes" un visiem "a" vārdiem "caaaaaaandy".
?	Norāda, ka elements var būt vai var nebūt. Piemēram, /e?le?/ sakritīs ar "el" "angel" un "le" "leņķī", ja to izmantos uzreiz aiz viena no kvantoriem * , + , ? , vai () , pēc tam norāda "nemantkārīgo" meklēšanu (atkārtojot minimālo iespējamo reižu skaitu līdz tuvākajam nākamajam modeļa elementam), pretstatā noklusējuma "mantkārīgajam" režīmam, kas maksimāli palielina atkārtojumu skaitu, pat ja nākamais raksta elements arī atbilst , ? izmantots priekšskatījumā, kas ir aprakstīts tabulā zem (?=) , (?!) un (?:) .
.	(Decimālzīme) apzīmē jebkuru rakstzīmi, kas nav jauna rindiņa: \n \r \u2028 vai \u2029. (varat izmantot [\s\S], lai meklētu jebkuru rakstzīmi, ieskaitot jaunas rindiņas). Piemēram, /.n/ sakritīs ar "an" un "on", ja "nē, ābols ir uz koka", bet ne "nē".
(x)	Atrod x un atceras. To sauc par "atmiņas iekavām". Piemēram, /(foo)/ "foo bar" atradīs un atcerēsies "foo". Atrastā apakšvirkne tiek saglabāta meklēšanas rezultātu masīvā vai RegExp objekta iepriekš definētajos rekvizītos: $1, ..., $9 Turklāt iekavas apvieno tajās ietverto vienā modeļa elementā. Piemēram, (abc)* - atkārtojiet abc 0 vai vairāk reizes.
(?:x)	Atrod x, bet neatceras, ko atrod. To sauc par "atmiņas iekavām". Atrastā apakšvirkne netiek saglabāta rezultātu masīvā un RegExp rekvizītos.
x(?=y)	Atrod x tikai tad, ja x seko y. Piemēram, /Jack(?=Sprot)/ sakritīs tikai ar vārdu "Džeks", ja tam sekos "Šprotes". /Jack(?=Sprat|Frost)/ atbilst "Jack" tikai tad, ja tam sekos "Sprot" vai "Frost". Tomēr meklēšanas rezultātos neparādīsies ne "Šprotes", ne "Frost".
x(?!y)	Atrod x tikai tad, ja x neseko y. Piemēram, /\d+(?!\.)/ atbilst skaitlim tikai tad, ja tam nesekos komata zīme. /\d+(?!\.)/.exec("3.141") atradīs 141, bet ne 3.141.
x|y	Atrod x vai y. Piemēram, /green|sarkans/ atbilst "zaļam" vārdam "zaļš ābols" un "sarkans" ar vārdu "sarkans ābols".
(n)	Kur n ir pozitīvs vesels skaitlis. Atrod tieši n iepriekšējā elementa atkārtojumus. Piemēram, /a(2)/ neatradīs "a" jēdzienā "konfektes", bet atradīs gan a "Candy", gan pirmos divus a "caaandy".
(n,)	Kur n ir pozitīvs vesels skaitlis. Atrod n vai vairāk elementa atkārtojumu. Piemēram, /a(2,) neatradīs "a" mapē "condy", bet atradīs visu "a" vārdkopā "candy" un "caaaaaaandy".
(n,m)	Kur n un m ir pozitīvi veseli skaitļi. Atrodiet elementa atkārtojumus no n līdz m.
	Rakstzīmju kopa. Atrod jebkuru no uzskaitītajām rakstzīmēm. Varat norādīt atstarpi, izmantojot domuzīmi. Piemēram, - tas pats, kas . Atbilst "b" vārdam "brisket" un "a" un "c" vārdam "ache".
[^xyz]	Jebkura rakstzīme, kas nav norādīta komplektā. Varat arī norādīt diapazonu. Piemēram, [^abc] ir tāds pats kā [^a-c] . Atrod "r" "brisket" un "h" "karbonāde".
[\b]	Atrod atpakaļatkāpes rakstzīmi. (Nejaukt ar \b .)
\b	Atrod (latīņu) vārda robežu, piemēram, atstarpi. (Nejaukt ar [\b]). Piemēram, /\bn\w/ atbilst "nē" vārdam "pusdienlaiks"; /\wy\b/ mapē "iespējams vakar" atradīs "ly".
\B	Tas nenorāda vārda robežu. Piemēram, /\w\Bn/ sakritīs ar "on" ar "noonday", un /y\B\w/ atbildīs ar "ye" ar "iespējams, vakar".
\cX	Kur X ir burts no A līdz Z. Norāda vadības rakstzīmi virknē. Piemēram, /\cM/ apzīmē rakstzīmi Ctrl-M.
\d	atrod ciparu no jebkura alfabēta (mūsējais ir Unicode). Izmantojiet, lai atrastu tikai parastos skaitļus. Piemēram, /\d/ vai // atbilst "2" laukā "B2 ir komplekta numurs".
\D	Atrod rakstzīmi, kas nav ciparu (visi alfabēti). [^0-9] ir ekvivalents parastajiem skaitļiem. Piemēram, /\D/ vai /[^0-9]/ atbilst "B" laukā "B2 ir komplekta numurs".
\s	Atbilst jebkurai atstarpes rakstzīmei, tostarp atstarpei, tabulēšanai, jaunajai rindiņai un citām Unikoda atstarpes rakstzīmēm. Piemēram, /\s\w*/ sakritīs ar "bar" ar "foo bar".
\S	Atrod jebkuru rakstzīmi, izņemot atstarpi. Piemēram, /\S\w*/ atbilst "foo" laukā "foo bar".
\v	Vertikāla cilnes rakstzīme.
\w	Atrod jebkuru vārda (latīņu alfabēta) rakstzīmi, tostarp burtus, ciparus un pasvītras. Līdzvērtīgs. Piemēram, /\w/ atbilst "a" vārdam "ābols", "5" formātā "5,28 ASV dolāri" un "3" formātā "3D".
\W	Atrod jebkuru ne-(latīņu) verbālo rakstzīmi. Ekvivalents [^A-Za-z0-9_] . Piemēram, /\W/ un /[^$A-Za-z0-9_]/ vienādi atbildīs "%" pozīcijā "50%.

Darbs ar Javascript regulārajām izteiksmēm

Darbs ar regulārām izteiksmēm Javascript tiek realizēts, izmantojot klases String metodes

exec(regexp) — virknē atrod visas atbilstības (ierakstus parastajā shēmā). Atgriež masīvu (ja ir atbilstība) un atjaunina regexp rekvizītu vai nulli, ja nekas netiek atrasts. Ar g modifikatoru - katru reizi, kad šī funkcija tiek izsaukta, tā atgriezīs nākamo atbilstību pēc iepriekšējā atrastā - tas tiek īstenots, saglabājot pēdējās meklēšanas nobīdes indeksu.

match(regexp) - atrodiet virknes daļu, izmantojot modeli. Ja ir norādīts g modifikators, tad match() atgriež visu atbilstību masīvu vai nulli (nevis tukšu masīvu). Bez g modifikatora šī funkcija darbojas kā exec();

test(regexp) - funkcija pārbauda virkni, lai tā atbilstu paraugam. Atgriež true, ja ir atbilstība, un false, ja atbilstības nav.

split(regexp) — sadala izsaukto virkni apakšvirkņu masīvā, izmantojot argumentu kā atdalītāju.

aizstāt(regexp, mix) - metode atgriež modificētu virkni saskaņā ar veidni (regulārā izteiksme). Pirmais regexp parametrs var būt arī virkne, nevis regulāra izteiksme. Bez g modifikatora metode rindā aizstāj tikai pirmo gadījumu; ar modifikatoru g - notiek globāla aizstāšana, t.i. tiek mainīti visi gadījumi dotajā rindā. mix - aizvietošanas veidne, var pieņemt virknes, aizstāšanas veidnes, funkcijas (funkcijas nosaukuma) vērtības.

Speciālās rakstzīmes aizstāšanas virknēAizvietošana, izmantojot funkciju

Ja kā otro parametru norādāt funkciju, tā tiek izpildīta katrā mačā. Funkcija var dinamiski ģenerēt un atgriezt aizstāšanas virkni. Funkcijas pirmais parametrs ir atrastā apakšvirkne. Ja pirmais arguments, kas jāaizstāj, ir RegExp objekts, tad nākamie n parametri satur ligzdotu iekavas. Pēdējie divi parametri ir pozīcija rindā, kurā notika atbilstība, un pati līnija.

jauns RegExp(raksts[, karodziņi])

regulārā izteiksme ADVANCE

Ir zināms, ka priekšroka tiek dota burtiskajai sintaksei (/test/i).

Ja regulārā izteiksme iepriekš nav zināma, tad vēlams izveidot regulāro izteiksmi (rakstzīmju virknē), izmantojot konstruktoru (jauns RegExp).

Bet pievērsiet uzmanību, jo “slīpsvītra zīme” \ spēlē koda maiņas lomu, tā ir jāieraksta divas reizes virknes literālā (jaunā RegExp): \\

Karogi

es ignorēju reģistru saskaņojot

g globālā atbilstība, atšķirībā no lokālās atbilstības (pēc noklusējuma atbilst tikai pirmajam modeļa gadījumam), ļauj saskaņot visus modeļa gadījumus

Operatori Kas Kā Apraksts Izmantojieti g m ^ - \ ^ $ ? + + * {} {,}

karogs	vai reg. reģistrjutīga izteiksme	/testik/i
karogs	globālā meklēšana	/testik/g
karogs	ļauj saskaņot ar daudzām virknēm, kuras var iegūt no textarea
rakstzīmju klases operators	rakstzīmju kopas saskaņošana	- jebkura rakstzīme diapazonā no a līdz z;
caret operators	izņemot	[^a-z] — jebkura rakstzīme, IZŅEMOT rakstzīmes diapazonā no a līdz z;
defises operators	norāda vērtību diapazonu, ieskaitot	- jebkura rakstzīme diapazonā no a līdz z;
bēgšanas operators	aizbēg no jebkura nākamā rakstzīmes	\\
sākt saskaņošanas operatoru	modeļu saskaņošanai jānotiek sākumā	/^testik/g
atbilstības beigu operators	modeļu saskaņošanai jānotiek beigās	/testik$/g
operators?	padara rakstzīmi neobligātu	/t?est/g
operators +		/t+est/g
operators +	simbolam ir jābūt vienu reizi vai vairākkārt	/t+est/g
operators *	simbolam ir jābūt vienreiz vai atkārtoti, vai arī tam nav jābūt vispār	/t+est/g
operators()	iestatiet noteiktu rakstzīmju atkārtojumu skaitu	/t(4)est/g
operators (,)	iestatiet simbola atkārtojumu skaitu noteiktās robežās	/t(4,9)est/g

Iepriekš noteiktas rakstzīmju klases Iepriekš noteikta dalībnieku kartēšana\t \n . \d \D \w \W \s \S \b \B

horizontālā cilne

Līnijas tulkojums

Jebkura rakstzīme, izņemot Line Feed

Jebkurš desmitais cipars, kas ir līdzvērtīgs

Jebkura rakstzīme, kas nav desmitais cipars, kas ir līdzvērtīgs [^0-9]

Jebkura rakstzīme (cipari, burti un pasvītras), kas ir līdzvērtīga

Jebkura rakstzīme, izņemot ciparus, burtus un pasvītras, kas ir līdzvērtīga [^A-Za-z0-9]

Jebkura atstarpes rakstzīme

Jebkura rakstzīme, izņemot atstarpi

Vārdu robeža

NAV vārda robeža, bet tā iekšējā. daļa

Grupēšana()

Ja dalībnieku grupai vēlaties lietot operatoru, piemēram, + (/(abcd)+/), varat izmantot iekavas () .

Fiksācijas

Regulārās izteiksmes daļu iekavās () sauc par apņemšanos.

Apsveriet šādu piemēru:

/^()k\1/

\1 nav neviena rakstzīme no a , b , c .
\1 ir jebkura rakstzīme, kas aktivizē pirmās rakstzīmes atbilstību. Tas nozīmē, ka rakstzīme, kas atbilst \1, nav zināma, kamēr regulārā izteiksme nav atrisināta.

Nefiksētas grupas

Iekavas () izmanto 2 gadījumos: grupēšanai un fiksāciju apzīmēšanai. Taču ir situācijas, kad () jāizmanto tikai grupēšanai, jo commits nav nepieciešamas, turklāt, noņemot nevajadzīgās saistības, mēs atvieglojam regulārās izteiksmes apstrādes mehānismu.

Tātad, lai novērstu apņemšanos, pirms sākuma iekavas jāievieto ?

Str = "Sveiki pasaule!"; found = str.match(/]*?)>/i); console.log("atrasts bez labojuma: ", atrasts); // [ "" ]

Funkciju pārbaude Regexp.test()

Testa funkcija pārbauda, ​​vai regulārā izteiksme atbilst virknei (str). Atgriež vai nu patiesu, vai nepatiesu .

Lietošanas piemērs:

Javascript funkcijas kodsF(str)( return /^\d(5)-\d(2)/.test(str); ) //console.log(codeF("12345-12ss")); // true //console.log(codeF("1245-12ss")); // nepatiesa funkcija atbilst str.match(regexp)

Atbilstības funkcija atgriež vērtību masīvu vai nulli, ja atbilstība netiek atrasta. Piezīme: ja regulārajai izteiksmei nav karoga g (lai veiktu globālu meklēšanu), atbilstības metode atgriezīs pirmo atbilstību virknē, un, kā redzams no piemēra, atbilstības masīvā ir iekļauti FIXATIONS ( regulārās izteiksmes daļa iekavās).

Javascript str = "Lai iegūtu informāciju, lūdzu, skatiet: 3.4.5.1. nodaļu"; re = /chapter (\d+(\.\d)*)/i // ar apņemšanos (bez globālā karoga) atrasts = str.match(re) console.log(found); // ["3.4.5.1. nodaļa", "3.4.5.1.", ".1"]

Ja metodi match() nodrošināsit ar globālu regulāru izteiksmi (ar karogu g), tiks atgriezts arī masīvs, taču ar GLOBĀLĀM atbilstībām. Tas ir, reģistrētie rezultāti netiek atgriezti.

Javascript str = "Lai iegūtu informāciju, skatiet: 3.4.5.1. nodaļu, 7.5. nodaļu"; re = /chapter (\d+(\.\d)*)/ig // bez saistībām - globāli atrasts = str.match(re) console.log(atrasts); // ["Nodaļa 3.4.5.1", "Chapter 7.5"] Funkcija exec regexp.exec(str)

Funkcija exec pārbauda, ​​vai regulārā izteiksme atbilst virknei (str). Atgriež rezultātu masīvu (ar commits) vai nulli . Katrs nākamais exec izsaukums (piemēram, izmantojot while) notiek (exec automātiski atjaunina pēdējās meklēšanas beigu indeksu lastIndex) un pāriet uz nākamo globālo atbilstību (ja ir norādīts g karodziņš).

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

Bez globālā karoga atbilstības un izpildes metodes darbojas identiski. Tas nozīmē, ka viņi atgriež masīvu ar pirmo globālo atbilstību un apņemas.

Javascript // match var html = "BAM! BUM!"; var reg = /]*?)>/; // bez globālās konsoles.log(html.match(reg)); // ["", "", "div", " class="test""] // exec var html = "BAM! BUM!"; var reg = /]*?)>/; // bez globālās konsoles.log(reg.exec(html)); // ["", "", "div", " class="test""] Funkcija aizstāt str.replace(regexp, newSubStr|funkcija)

• regexp - reg. izteiksme;
• newSubStr - virkne, uz kuru tiek mainīta atrastā izteiksme tekstā;
• funkcija — tiek izsaukta katrai atrastajai atbilstībai ar mainīgu parametru sarakstu (atgādiniet, ka globālā meklēšana virknē atrod visus parauga atbilstības gadījumus).

Šīs funkcijas atgriešanas vērtība kalpo kā aizstāšana.

Funkciju parametri:

• 1 — pilnīga atbilstošā apakšvirkne.
• 2 - iekavu grupu (fiksāciju) nozīme.
• 3 — atbilstības rādītājs (pozīcija) avota virknē.
• 4. Avota līnija.

Metode nemaina izsaukuma virkni, bet pēc atbilstības aizstāšanas atgriež jaunu. Lai veiktu globālu meklēšanu un aizstātu, izmantojiet regexp ar karogu g.

"GHGHGHGTTTT".aizstāt(//g,"K"); //"KKKKKKKKKKKK"

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

Regulārās izteiksmes ir viens no jaudīgākajiem JavaScript datu apstrādes rīkiem. Turklāt tas ir ērtākais datu apstrādes veids gadījumos, kad nav iespējams norādīt precīzu meklēšanas modeli. Vienkāršākais piemērs ir tekstā iezīmēt visas e-pasta adreses un tālruņu numurus. Acīmredzot vienkārša apakšvirknes meklēšana nedarbosies, jo Mēs jau iepriekš nezinām, kuras adreses un tālruņu numuri parādīsies tekstā.

Regulārās izteiksmes nedarbojas ar precīzām vērtībām, bet gan uz modeļiem. Raksts tiek uzrakstīts, izmantojot regulāro izteiksmju valodu, un tagad mēs iepazīsimies ar tā pamatiem.

Tātad jebkura regulārā izteiksme sastāv no atdalītāja, veidnes pamatteksta un modifikatoriem (dažreiz tos sauc arī par slēdžiem).

/pattern/slēdzis

Šeit "/" ir atdalītājs, "raksts" ir modeļa pamatteksts un "slēdzis" ir modifikatori.

Ir tikai divi veidi, kā izmantot regulārās izteiksmes JavaScript: izmantojot RegExp objekta metodes vai izmantojot String objekta metodes.

RegExp objekta gadījumu var izveidot divos veidos — tiešā un netiešā:

// skaidra metode var re = new RegExp("raksts", "slēdzis"); // netiešā (alternatīvā) metode var re = /pattern/switch;

Lūdzu, ņemiet vērā, ka ar netiešo metodi modelis tiek norādīts BEZ pēdiņām.

Jebkura regulāra izteiksme sastāv no regulārām rakstzīmēm, speciālajām rakstzīmēm un atkārtojuma kvantoriem. Parastās rakstzīmes ietver burtus, ciparus un simbolus, bet nacionālās rakstzīmes un unikoda rakstzīmes var izmantot kā rakstzīmes. Uzmanību!

Speciālās rakstzīmes (vai metarakstzīmes) ir regulāro izteiksmju pamatā, jo Tieši speciālās rakstzīmes nosaka meklēšanas secību un norāda izteiksmju tulkotājam papildu nosacījumus un ierobežojumus. Tabulā ir parādītas galvenās īpašās rakstzīmes un sniegts to īss apraksts.

Īpašs raksturs	Saskaņot rakstu
\	Rakstzīmēm, kuras parasti tiek interpretētas burtiski, nozīmē, ka nākamā rakstzīme ir īpaša. Piemēram, /n/ atbilst burtam n un /\n/ atbilst jaunrindas rakstzīmei. Personām, kuras parasti uzskata par īpašām, nozīmē, ka varonis ir jāsaprot burtiski. Piemēram, /^/ apzīmē rindas sākumu, savukārt /\^/ vienkārši atbilst rakstzīmei ^. /\\/ atbilst atpakaļvērstajai slīpsvītrai \.
^	Atbilst rindas sākumam.
$	Atbilst virknes beigām.
(raksts)	Atbilst virknes modelim un atceras atrasto atbilstību.
(?:pattern)	Atbilst virknes modelim, bet neatceras atrasto atbilstību. Izmanto, lai grupētu raksta daļas, piemēram, /ko(?:t|shka)/ ir izteiksmes /cat|cat/ īsa forma.
(?=raksts)	Izskatāmā atbilstība notiek, ja virknes modelis tiek saskaņots, neatceroties atrasto atbilstību. Piemēram, /Windows (?=95|98|NT|2000)/ atbilst "Windows" virknē "Windows 98", bet nesakrīt virknē "Windows 3.1". Pēc saskaņošanas meklēšana turpinās no pozīcijas, kas atrodas blakus atrastajai sērijai, neskatoties uz priekšu.
(?! raksts)	Izskatāmā atbilstība notiek, ja virknes raksts nesakrīt, neatceroties atrasto atbilstību. Piemēram, /Windows (?!95|98|NT|2000)/ atbilst "Windows" virknē "Windows 3.1", bet nesakrīt virknē "Windows 98". Pēc saskaņošanas meklēšana turpinās no pozīcijas, kas atrodas blakus atrastajai sērijai, neskatoties uz priekšu.
x|y	Atbilst x vai y.
	Atbilst jebkurai rakstzīmei, kas ievietota kvadrātiekavās.
[^xyz]	Atbilst jebkurai rakstzīmei, izņemot tās, kas ir liktas kvadrātiekavās.
	Atbilst jebkurai rakstzīmei norādītajā diapazonā.
[^a-z]	Atbilst jebkurai rakstzīmei, izņemot tās, kas atrodas norādītajā diapazonā.
\b	Atbilst vārda robežai, tas ir, vietai starp vārdu un atstarpi vai rindiņas padevi.
\B	Atbilst jebkurai pozīcijai, izņemot vārda robežu.
\cX	Atbilst simbolam Ctrl+X. Piemēram, /\cI/ ir līdzvērtīgs /\t/
\d	Atbilst skaitlim. Līdzvērtīgs.
\D	Atbilst rakstzīmei, kas nav ciparu. Atbilst [^0-9].
\f	Atbilst formāta tulkojuma (FF) rakstzīmei.
\n	Atbilst līnijas plūsmas (LF) rakstzīmei.
\r	Atbilst karieta atgriešanas (CR) rakstzīmei.
\s	Atbilst atstarpes raksturam. Ekvivalents /[ \f\n\r\t\v]/.
\S	Atbilst jebkurai rakstzīmei, kas nav atstarpes. Ekvivalents /[^ \f\n\r\t\v]/.
\t	Atbilst tabulēšanas rakstzīmei (HT).
\v	Atbilst vertikālās cilnes rakstzīmei (VT).
\w	Atbilst latīņu burtam, ciparam vai pasvītrai. Līdzvērtīgs / /.
\W	Atbilst jebkurai rakstzīmei, kas nav burts, cipars vai pasvītra. Ekvivalents /[^A-Za-z0-9_] /.
\n	n ir pozitīvs skaitlis. Atbilst n-tajai iegaumētajai apakšvirknei. Aprēķināts, saskaitot kreisās iekavas. Ja pirms šīs rakstzīmes ir mazāk kreiso iekavu nekā n, tad \0n ir līdzvērtīgs.
\0n	n ir oktālais skaitlis, kas nav lielāks par 377. Atbilst rakstzīmei ar oktālo kodu n. Piemēram, /\011/ ir līdzvērtīgs /\t/.
\xn	n ir heksadecimāls skaitlis, kas sastāv no diviem cipariem. Atbilst rakstzīmei ar heksadecimālo kodu n. Piemēram, /\x31/ ir līdzvērtīgs /1/.
\un	n ir heksadecimāls skaitlis, kas sastāv no četriem cipariem. Atbilst unikoda rakstzīmei ar heksadecimālo kodu n. Piemēram, /\u00A9/ ir līdzvērtīgs /©/.
.	Punkts. Atbilst jebkuram raksturam.

Ir daudz speciālo rakstzīmju, un ar to palīdzību jūs varat aprakstīt gandrīz jebkuru frāzi vai meklēšanas frāzi.

Otrā modeļa sastāvdaļa ir kvantori. Šī ir speciālo rakstzīmju apakškopa, kas norāda rakstzīmju vai to grupu atkārtošanās nosacījumu. Kvantifikators ir rakstīts pa labi no izteiksmes un sniedzas līdz tuvākajai rakstzīmei vai grupai. Piemēram:

(raksts_1)|(raksts_2)(pēdas)

Šeit kvantors "quont" attiecas tikai uz "pattern_2".

Tabulā ir parādīti visi galvenie kvanti:

Kvantifikators	Saskaņot rakstu
*	Atbilst iepriekšējās rakstzīmes atkārtošanai nulle vai vairākas reizes.
+	Atbilst iepriekšējās rakstzīmes atkārtošanai vienu vai vairākas reizes.
?	Atbilst iepriekšējās rakstzīmes atkārtošanai nulle vai vienu reizi. . Atbilst jebkurai rakstzīmei, izņemot jaunu rindiņu.
(n)	n ir nenegatīvs skaitlis. Precīzi atbilst n iepriekšējās rakstzīmes gadījumiem.
(n,)	n ir nenegatīvs skaitlis. Atbilst n vai vairākiem iepriekšējās rakstzīmes gadījumiem. /x(1,)/ ir līdzvērtīgs /x+/. /x(0,)/ ir līdzvērtīgs /x*/.
(n,m)	n un m ir nenegatīvi skaitļi. Atbilst vismaz n un ne vairāk kā m iepriekšējās rakstzīmes gadījumiem. /x(0,1)/ ir līdzvērtīgs /x?/.

Tātad, esam iepazinušies ar regulārās izteiksmes valodas pamatiem un tagad izmēģināsim savas jaunās zināšanas praksē. Šeit ir testa() metodes izmantošanas piemērs

var sample = "No apelsīniem tiek pagatavota apelsīnu sula"; var re = /oranža*/; var rezultāts = re.test(sample) ? "" " : "" Nav ";

document.write("Virkne "" + paraugs + rezultāts + "atbilst paraugam " + re);

Exec() metodes izmantošanas piemērs

var sample = "No apelsīniem tiek pagatavota apelsīnu sula"; var re = /oranža*/; var rezultāts = re.exec(sample); document.write("Atrasta atbilstība: "" + rezultāts + """);

Un šajā piemērā mēs izmantosim alternatīvu veidu, kā izveidot RegExp objektu:

var sample = "No apelsīniem tiek pagatavota apelsīnu sula"; var rezultāts = /oranžs*/.tests(sample) ? "" " : "" Nav ";

document.write("Virkne "" + paraugs + rezultāts + "atbilst paraugam ");