BAM! BUM!

", "", "div", " class="test""]

zamijeniti funkciju

str.replace(regexp, newSubStr|funkcija)

• regexp - reg. izražavanje;
• newSubStr - string u koji se mijenja pronađeni izraz u tekstu;
• funkcija - poziva se za svako pronađeno podudaranje s promjenljivom listom parametara (sjetite se da globalna pretraga u nizu pronalazi sve instance podudaranja uzorka).

Povratna vrijednost ove funkcije služi kao zamjena.

Parametri funkcije:

• 1 - Kompletan podniz koji se podudara.
• 2 - Značenje grupa zagrada (fiksacije).
• 3 - Indeks (pozicija) podudaranja u izvornom nizu.
• 4 - Izvorni niz.

Metoda ne mijenja pozivni niz, ali vraća novi nakon zamjene podudaranja. Da izvršite globalnu pretragu i zamjenu, koristite regexp sa g zastavicom.

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

Javascript

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

Regularni izrazi za početnike

Šta su regularni izrazi?

Ako ste ikada radili sa komandnom linijom, vjerovatno ste koristili maske imena datoteka. Na primjer, da biste izbrisali sve datoteke u trenutnom direktoriju koje počinju slovom “d”, možete napisati rm d*.

Regularni izrazi su sličan, ali mnogo moćniji alat za pronalaženje nizova, njihovo testiranje u odnosu na obrazac i drugi sličan rad. Engleski naziv ovog instrumenta je Regularni izrazi ili samo RegExp. Strogo govoreći, regularni izrazi su poseban jezik za opisivanje uzoraka nizova.

Implementacija ovog alata varira u različitim programskim jezicima, iako ne mnogo. U ovom članku ćemo se prvenstveno fokusirati na implementaciju Perl kompatibilnih regularnih izraza.

Osnove sintakse

Prije svega, vrijedno je napomenuti da je svaki niz sam po sebi regularni izraz. Dakle, izraz Haha, očigledno će odgovarati liniji "Haha" i samo to. Regularni izrazi su osjetljivi na velika i mala slova, tako da se niz "haha" (mala slova) više neće podudarati s izrazom iznad.

Međutim, ovdje treba biti oprezan - kao i svaki jezik, regularni izrazi imaju posebne znakove koje treba izbjeći. Evo njihove liste: . ^ $ * + ? ( ) \ | (). Escaping se vrši na uobičajen način - dodavanjem \ ispred posebnog znaka.

Skup znakova

Pretpostavimo da želimo da pronađemo sve ubacivanja u tekstu koji ukazuju na smeh. Haha nam jednostavno neće odgovarati - uostalom, "Hehe", "Hoho" i "Hihi" neće potpasti pod to. I problem sa padežom prvog slova treba nekako riješiti.

Ovdje će nam u pomoć priskočiti skupovi - umjesto specificiranja određenog karaktera, možemo zapisati cijelu listu, a ako se bilo koji od navedenih karaktera pojavi na navedenom mjestu u stringu koji se ispituje, string će se smatrati prikladnim. Uzorci su napisani u uglastim zagradama - uzorak će odgovarati bilo kojem od znakova “a”, “b”, “c” ili “d”.

Unutrašnji set b O Većina specijalnih znakova ne mora biti prikazana, ali korištenje \ ispred njih neće se smatrati greškom. I dalje je potrebno izbjeći znakove “\” i “^”, i, po mogućnosti, “]” (dakle, znači bilo koji od znakova “]” ili “[”, dok je [x] isključivo sekvenca “[ x]”). Naizgled neobično ponašanje regularnih izraza sa znakom “]” zapravo je određeno dobro poznatim pravilima, ali je mnogo lakše jednostavno pobjeći od ovog znaka nego ih zapamtiti. Osim toga, simbol “-” treba da se izbjegne, koristi se za postavljanje raspona (vidi dolje).

Ako napišete simbol ^ odmah iza [, skup će poprimiti suprotno značenje - bilo koji simbol osim navedenih smatrat će se prikladnim. Dakle, obrazac [^xyz] odgovara bilo kojem znaku osim, u stvari, “x”, “y” ili “z”.

Dakle, primjenom ovog alata na naš slučaj, ako napišemo [Xx][aoie]x[aoie], onda će svaki od nizova “Haha”, “hehe”, “hihi” pa čak i “Hoho” odgovarati uzorku.

Predefinirane klase znakova

Za neke setove koji se često koriste, postoje posebni predlošci. Dakle, za opisivanje bilo kojeg razmaka (razmak, tabulator, prijelom reda) koristi se \s, za brojeve - \d, za latinične znakove, brojeve i donje crte "_" - \w.

Ako je potrebno opisati bilo koji znak, za to se koristi tačka. . Ako su navedene klase napisane velikim slovom (\S, \D, \W), onda će promijeniti svoje značenje u suprotno - bilo koji znak bez razmaka, bilo koji znak koji nije broj i bilo koji drugi znak osim Latinica, brojevi ili donja crta.

Takođe, pomoću regularnih izraza moguće je provjeriti položaj reda u odnosu na ostatak teksta. Izraz \b označava granicu riječi, \B je granica koja nije riječ, ^ je početak teksta, a $ je kraj. Dakle, prema \bJava\b obrascu, prva 4 znaka će se naći u redu "Java i JavaScript", a prema \bJava\B obrascu - znakovi od 10. do 13. (kao dio riječi " JavaScript”).

Rasponi

Možda ćete morati odrediti skup koji sadrži slova, na primjer, od “b” do “f”. Umjesto pisanja [bvgdezziklmnoprstuf] možete koristiti mehanizam raspona i napisati [b-f] . Dakle, uzorak x odgovara nizu "xA6", ali ne odgovara "xb9" (prvo, zbog činjenice da su u rasponu naznačena samo velika slova, a drugo, zbog činjenice da 9 nije uključeno u intervalu 0 -8).

Mehanizam raspona je posebno relevantan za ruski jezik, jer za njega ne postoji konstrukcija slična \w . Da biste označili sva slova ruske abecede, možete koristiti obrazac [a-âA-ÂeO] . Imajte na umu da slovo “e” nije uključeno u opšti raspon slova i da se mora posebno navesti.

Kvantifikatori (koji ukazuju na broj ponavljanja)

Vratimo se našem primjeru. Šta ako je uzbuna koja se smeje imala više od jednog samoglasnika između slova x, poput „Haahaaaa“? Naša stara regularna sezona nam više neće moći pomoći. Ovdje ćemo morati koristiti kvantifikatore.

Imajte na umu da se kvantifikator primjenjuje samo na znak koji dolazi prije njega.

Neke često korišćene konstrukcije dobile su posebne oznake u jeziku regularnih izraza:

Dakle, uz pomoć kvantifikatora, možemo poboljšati naš obrazac za interjekcije na [Xx][aoeee]+x[aoeee]*, i moći će prepoznati nizove “Haaha”, “heeeeeeh” i “Hihii”.

Lazy quantification

Pretpostavimo da smo suočeni sa zadatkom da pronađemo sve HTML oznake u nizu

Tproger- moj Draga web stranica o programiranju!

Očigledno rješenje<.*>neće raditi ovdje - pronaći će cijeli niz, jer počinje i završava se oznakom paragrafa. To jest, sadržaj oznake će se smatrati stringom

P> Tproger- moj Draga web stranica o programiranju!

To se događa zbog činjenice da kvantifikator po defaultu radi prema tzv. pohlepan algoritam - pokušava vratiti najduži mogući niz koji ispunjava uvjet. Postoje dva načina za rješavanje problema. Prvi je korištenje izraza<[^>]*> , što će spriječiti da se prava kutna zagrada smatra sadržajem oznake. Drugi je da kvantifikator proglasite ne pohlepnim, već lijen. Da li se to radi dodavanjem desno od kvantifikatora karaktera? . One. za traženje svih oznaka, izraz će se okrenuti<.*?> .

Ljubomorna kvantifikacija

Ponekad, da biste povećali brzinu pretraživanja (posebno u slučajevima kada se niz ne podudara s regularnim izrazom), možete spriječiti algoritam da se vrati na prethodne korake pretraživanja kako bi pronašao moguća podudaranja za ostatak regularnog izraza. To se zove ljubomoran kvantifikacija. Kvantifikator postaje ljubomoran dodavanjem simbola + sa desne strane. Druga upotreba ljubomorne kvantifikacije je isključivanje neželjenih poklapanja. Dakle, obrazac ab*+a u nizu “ababa” će odgovarati samo prva tri znaka, ali ne i znakovima od trećeg do petog, jer znak “a”, koji je na trećoj poziciji, već je korišten za prvi rezultat.

Grupe zagrada

Za naš predložak za ubacivanje „smijati se“, jedina mala stvar koja je ostala je da uzmemo u obzir da se slovo „x“ može pojaviti više puta, na primjer, „Hahahahahaaahahooo“, pa čak i završiti slovom „x“. Ovdje vjerovatno trebamo koristiti grupni kvantifikator [aioe]+x, ali ako samo napišemo [aoie]x+ kvantifikator + će se primijeniti samo na znak “x”, a ne na cijeli izraz. Da biste to popravili, izraz se mora staviti u zagrade: ([aioe]x)+ .

Tako se naš izraz pretvara u [Hh]([aoe]h?)+ - prvo postoji veliko ili malo slovo “x”, a zatim proizvoljan broj samoglasnika koji nije nula, koji su (moguće, ali ne nužno) isprepleteni sa jednim malim slovima “x”. Međutim, ovaj izraz samo djelimično rješava problem - ovaj izraz će uključivati ​​i redove kao što je, na primjer, "hihaheh" - neko se može tako nasmijati, ali pretpostavka je vrlo sumnjiva. Očigledno, skup svih samoglasnika možemo koristiti samo jednom, a onda se nekako moramo osloniti na rezultat prvog pretraživanja. Ali kako?...

Pamćenje rezultata pretrage po grupama (povratne informacije)

Ispostavilo se da se rezultat pretraživanja grupe zagrada upisuje u zasebnu memorijsku ćeliju, kojoj se može pristupiti za korištenje u narednim dijelovima regularnog izraza. Vraćajući se na zadatak pronalaženja HTML oznaka na stranici, možda ćemo morati ne samo da pronađemo oznake, već i da saznamo njihovo ime. U tome nam može pomoći regularni izraz<(.*?)> .

Tproger- moj Draga web stranica o programiranju!

Rezultat pretrage za sve regularne izraze: “

”, “”, “”, “”, “”, “

”.
Rezultat pretrage za prvu grupu: “p”, “b”, “/b”, “i”, “/i”, “/i”, “/p”.

Rezultat pretraživanja po grupi može se referencirati pomoću izraza \n, gdje je n broj od 1 do 9. Na primjer, izraz (\w)(\w)\1\2 odgovara nizovima "aaaa", "abab “, ali ne odgovara “aabb.”

Ako se izraz stavi u zagrade samo da bi se na njega primijenio kvantifikator (nema planova za pamćenje rezultata pretraživanja za ovu grupu), onda odmah treba dodati prvu zagradu?:, na primjer (?:+\w) .

Koristeći ovaj mehanizam, možemo prepisati naš izraz u oblik [Xx]([aoie])x?(?:\1x?)*.

Transfer

Da biste provjerili da li niz zadovoljava barem jedan od obrazaca, možete koristiti analogni logički operator OR, koji se piše pomoću simbola | . Dakle, obrazac Anna|Loneliness uključuje linije "Anna" i "Loneliness", respektivno. Posebno je zgodno koristiti enumeracije unutar grupa zagrada. Tako je, na primjer, (?:a|b|c|d) potpuno ekvivalentno (u ovom slučaju, druga opcija je poželjnija zbog performansi i čitljivosti).

U JavaScript-u, regularni izrazi su predstavljeni RegExp objektima. RegExp objekti se mogu kreirati pomoću konstruktora RegExp(), ali se češće kreiraju pomoću posebne sintakse literala. Baš kao što su literali stringova specificirani kao znakovi zatvoreni u navodnicima, literali regularnog izraza su specificirani kao znakovi zatvoreni u par kosih crta / .

/pattern/flags new RegExp("pattern"[, opcije pretraživanja])

uzorak- regularni izraz za pretraživanje (više o zamjeni kasnije), i zastavice - niz bilo koje kombinacije znakova g (globalna pretraga), i (velika i mala slova nisu bitna) i m (pretraga u više redova). Prva metoda se koristi često, druga - ponekad. Na primjer, dva takva poziva su ekvivalentna.

Opcije pretraživanja

Kada kreiramo regularni izraz, možemo odrediti dodatne opcije pretraživanja

Znakovi u JavaScript regularnim izrazima

Simbol	Prepiska
Alfanumerički znakovi	Odgovaraju sami sebi
\0	NUL znak (\u0000)
\t	Tab (\u0009)
\n	Prijenos reda (\u000A)
\v	Vertikalna kartica (\u000B)
\f	Prijevod stranice (\u000C)
\r	Povratak kočije (\u000D)
\xnn	Znak iz latinskog skupa, specificiran heksadecimalnim brojem nn; na primjer, \x0A je isto što i \n
\uxxxx	Unicode znak specificiran heksadecimalnim brojem xxxx; na primjer, \u0009 je isto što i \t
\cX	Kontrolni znak "X", na primjer, sekvenca \cJ je ekvivalentna znaku novog reda \n
\	Za obične likove - čini ih posebnim. Na primjer, izraz /s/ jednostavno traži znak "s". A ako stavite \ ispred s, onda /\s/ već označava razmak I obrnuto, ako je znak poseban, na primjer *, tada će \ učiniti samo običnim znakom "zvjezdica". Na primjer, /a*/ traži 0 ili više uzastopnih znakova "a". Da biste pronašli a sa zvjezdicom "a*" - stavite \ ispred posebnog. simbol: /a\*/ .
^	Označava početak ulaznih podataka. Ako je postavljena zastavica za više redova ("m"), ona će se također pokrenuti na početku novog reda, na primjer, /^A/ neće pronaći "A" u "an", ali će pronaći prvu "A" u "A."
$	Označava kraj ulaznih podataka. Ako je postavljena zastavica višelinijskog pretraživanja, ona će također raditi na kraju reda, na primjer, /t$/ neće pronaći "t" u "eater", ali će ga pronaći u "eat".
*	Označava ponavljanje 0 ili više puta. Na primjer, /bo*/ će pronaći "boooo" u "Duh booooed" i "b" u "A bird warbled", ali neće pronaći ništa u "A cot granted".
+	Označava ponavljanje 1 ili više puta. Ekvivalentno (1,). Na primjer, /a+/ će odgovarati "a" u "bomboni" i svim "a" u "caaaaaaandy".
?	Označava da element može ili ne mora biti prisutan. Na primjer, /e?le?/ će odgovarati "el" u "anđeo" i "le" u "ugao". , ili () , zatim specificira "ne-pohlepnu" pretragu (ponavljanje minimalnog mogućeg broja puta, do najbližeg sljedećeg elementa uzorka), za razliku od zadanog "pohlepnog" načina, u kojem je broj ponavljanja maksimalan, čak i ako se sljedeći element uzorka također podudara. koristi se u pregledu, koji je opisan u tabeli pod (?=) , (?!) i (?:) .
.	(Decimalna točka) predstavlja bilo koji znak osim novog reda: \n \r \u2028 ili \u2029. (možete koristiti [\s\S] za traženje bilo kojeg znaka, uključujući nove redove). Na primjer, /.n/ će odgovarati "an" i "on" u "ne, jabuka je na drvetu", ali ne i "ne".
(x)	Pronalazi x i pamti. Ovo se zove "memory brackets". Na primjer, /(foo)/ će pronaći i zapamtiti "foo" u "foo bar". Pronađeni podniz je pohranjen u nizu rezultata pretraživanja ili u unaprijed definiranim svojstvima RegExp objekta: $1, ..., $9 Osim toga, zagrade kombinuju ono što se nalazi u njima u jedan element uzorka. Na primjer, (abc)* - ponovite abc 0 ili više puta.
(?:x)	Pronalazi x, ali se ne sjeća šta je pronašao. Ovo se zove "memorijske zagrade". Pronađeni podniz nije pohranjen u nizu rezultata i svojstvima RegExp Poput svih zagrada, oni kombinuju ono što se nalazi u njima u jedan poduzorak.
x(?=y)	Pronalazi x samo ako x prati y. Na primjer, /Jack(?=Sprat)/ će odgovarati samo "Jack" ako ga prati "Sprat". /Jack(?=Sprat|Frost)/ će odgovarati samo "Jack" ako ga prati "Sprat" ili "Frost". Međutim, ni "Sprat" ni "Frost" se neće pojaviti u rezultatima pretrage.
x(?!y)	Pronalazi x samo ako x ne prati y. Na primjer, /\d+(?!\.)/ će odgovarati broju samo ako ne prati decimalni zarez. /\d+(?!\.)/.exec("3.141") će pronaći 141, ali ne i 3.141.
x|y	Pronalazi x ili y. Na primjer, /zeleno|crveno/ će odgovarati "zeleno" u "zelena jabuka" i "crveno" u "crvena jabuka".
(n)	Gdje je n pozitivan cijeli broj. Pronalazi tačno n ponavljanja prethodnog elementa. Na primjer, /a(2)/ neće pronaći "a" u "bomboni", ali će pronaći oba a u "caandy", a prva dva a u "caaandy".
(n,)	Gdje je n pozitivan cijeli broj. Pronalazi n ili više ponavljanja elementa. Na primjer, /a(2,) neće pronaći "a" u "bomboni", ali će pronaći sva "a" u "caandy" i u "caaaaaaandy".
(n,m)	Gdje su n i m pozitivni cijeli brojevi. Pronađite od n do m ponavljanja elementa.
	Skup znakova. Pronalazi bilo koji od navedenih znakova. Možete označiti razmak pomoću crtice. Na primjer, - isto što i . Odgovara "b" u "brisketu" i "a" i "c" u "ache".
[^xyz]	Bilo koji karakter osim onih navedenih u skupu. Također možete odrediti raspon. Na primjer, [^abc] je isto što i [^a-c] . Pronalazi "r" u "brisket" i "h" u "chop".
[\b]	Pronalazi znak za povratak. (Ne treba se brkati sa \b .)
\b	Pronalazi (latinsku) granicu riječi, kao što je razmak. (Ne miješati sa [\b]). Na primjer, /\bn\w/ će odgovarati "ne" u "podne"; /\wy\b/ će odgovarati "ly" u "moguće jučer."
\B	Ne označava granicu riječi. Na primjer, /\w\Bn/ će odgovarati "on" u "podne", a /y\B\w/ će odgovarati "ye" u "vjerovatno jučer."
\cX	Gdje je X slovo od A do Z. Označava kontrolni znak u nizu. Na primjer, /\cM/ predstavlja Ctrl-M karakter.
\d	pronalazi broj iz bilo koje abecede (naš je Unicode). Koristite za pronalaženje samo regularnih brojeva. Na primjer, /\d/ ili // će odgovarati "2" u "B2 je broj apartmana."
\D	Pronalazi nenumerički znak (sve abecede). [^0-9] je ekvivalent za regularne brojeve. Na primjer, /\D/ ili /[^0-9]/ će odgovarati "B" u "B2 je broj apartmana."
\s	Odgovara bilo kojem razmaku, uključujući razmak, tabulator, novi red i druge Unicode znakove razmaka. Na primjer, /\s\w*/ će odgovarati "bar" u "foo bar."
\S	Pronalazi bilo koji znak osim razmaka. Na primjer, /\S\w*/ će odgovarati "foo" u "foo bar."
\v	Vertikalni tabulator.
\w	Pronalazi bilo koji znak riječi (latinica), uključujući slova, brojeve i donje crte. Ekvivalentno. Na primjer, /\w/ će odgovarati "a" u "apple", "5" u "$5,28" i "3" u "3D."
\W	Pronalazi bilo koji ne-(latinski) verbalni znak. Ekvivalentno [^A-Za-z0-9_] . Na primjer, /\W/ i /[^$A-Za-z0-9_]/ će se jednako podudarati sa "%" u "50%."

Rad sa regularnim izrazima u Javascript-u

Rad sa regularnim izrazima u Javascriptu implementiran je metodama klase String

exec(regexp) - pronalazi sva podudaranja (unose u regularnom uzorku) u nizu. Vraća niz (ako postoji podudaranje) i ažurira svojstvo redovnog izraza ili null ako ništa nije pronađeno. Sa modifikatorom g - svaki put kada se ova funkcija pozove, vratit će sljedeće podudaranje nakon prethodnog pronađenog - ovo se implementira održavanjem indeksa pomaka posljednje pretrage.

match(regexp) - pronađite dio niza koristeći obrazac. Ako je naveden modifikator g, onda match() vraća niz svih podudaranja ili null (umjesto prazan niz). Bez modifikatora g, ova funkcija radi kao exec();

test(regexp) - funkcija provjerava da li string odgovara uzorku. Vraća true ako postoji podudaranje i false ako nema podudaranja.

split(regexp) - Rastavlja string na koji je pozvan u niz podstringova, koristeći argument kao graničnik.

zamijeni(regexp, mix) - metoda vraća modificirani string u skladu sa šablonom (regularni izraz). Prvi parametar za regexp također može biti string umjesto regularnog izraza. Bez modifikatora g, metoda u redu zamjenjuje samo prvo pojavljivanje; sa modifikatorom g - dolazi do globalne zamjene, tj. sva pojavljivanja date linije se mijenjaju.

mix - zamjenski predložak, može prihvatiti vrijednosti niza, zamjenskog šablona, ​​funkcije (naziv funkcije).

Posebni znakovi u zamjenskom nizu

Ako navedete funkciju kao drugi parametar, ona se izvršava pri svakom podudaranju. Funkcija može dinamički generirati i vratiti zamjenski niz. Prvi parametar funkcije je pronađeni podniz. Ako je prvi argument za zamjenu RegExp objekt, onda sljedećih n parametara sadrži ugniježđene zagrade podudaranja. Posljednja dva parametra su pozicija u liniji gdje je došlo do podudaranja i sama linija.

Neki ljudi, kada se suoče s problemom, pomisle: "Oh, ja ću koristiti regularne izraze." Sada imaju dva problema.
Jamie Zawinski

Yuan-Ma je ​​rekao: „Potrebno je mnogo sile da se seče drvo preko zrna drveta. Potrebno je mnogo koda za programiranje kroz strukturu problema.
Majstor Yuan-Ma, “Knjiga programiranja”

Alati i tehnike programiranja opstaju i šire se na haotičan evolucijski način. Ponekad ne opstaju oni lijepi i briljantni, već jednostavno oni koji rade dovoljno dobro u svom polju - na primjer, ako su integrirani u drugu uspješnu tehnologiju.

U ovom poglavlju ćemo raspravljati o takvom alatu - regularnim izrazima. Ovo je način za opisivanje obrazaca u nizovima podataka. Oni stvaraju mali, samostalni jezik koji je uključen u JavaScript i mnoge druge jezike i alate.

Redovni rasporedi su i veoma čudni i izuzetno korisni. Njihova sintaksa je zagonetna, a njihov JavaScript programski interfejs je nezgrapno. Ali to je moćan alat za istraživanje i manipulaciju nizovima. Kada ih shvatite, postaćete efikasniji programer.

Kreiranje regularnog izraza

Regular – tip objekta. Može se kreirati pozivanjem RegExp konstruktora ili pisanjem željenog predloška, ​​okruženog kosim crtama.

Var re1 = novi RegExp("abc"); var re2 = /abc/;

Oba ova regularna izraza predstavljaju isti obrazac: znak “a” iza kojeg slijedi znak “b” iza kojeg slijedi znak “c”.

Ako koristite konstruktor RegExp, tada se obrazac piše kao običan string, tako da vrijede sva pravila koja se odnose na obrnute kose crte.

Drugi unos, gdje je uzorak između kosih crta, tretira obrnute kose crte drugačije. Prvo, pošto se obrazac završava kosom crtom naprijed, moramo staviti obrnutu kosu crtu ispred kose crte koju želimo uključiti u naš obrazac. Dodatno, obrnute kose crte koje nisu dio specijalnih znakova kao što je \n bit će sačuvane (umjesto zanemarene kao u nizovima) i promijenit će značenje obrasca. Neki znakovi, kao što su upitnik ili plus, imaju posebno značenje u regularnim izrazima, a ako trebate uskladiti takav znak, mora mu prethoditi i obrnuta kosa crta.

Var eighteenPlus = /osamnaest\+/;

Da biste znali kojim znakovima treba prethoditi kosa crta, morate naučiti listu svih specijalnih znakova u regularnim izrazima. Ovo još nije moguće, pa kada ste u nedoumici, samo stavite obrnutu kosu crtu ispred bilo kojeg znaka koji nije slovo, broj ili razmak.

Provjeravam podudaranja

Redovni imaju nekoliko metoda. Najjednostavniji je test. Ako mu prosledite string, on će vratiti Booleovu vrednost koja pokazuje da li niz sadrži pojavu datog uzorka.

Console.log(/abc/.test("abcde")); // → true console.log(/abc/.test("abxde")); // → netačno

Regularni niz koji se sastoji samo od nespecijalnih znakova jednostavno je niz ovih znakova. Ako je abc bilo gdje u liniji koju testiramo (ne samo na početku), test će vratiti true.

Traži se skup likova

Također možete saznati da li niz sadrži abc koristeći indexOf. Uobičajeni uzorci vam omogućavaju da idete dalje i kreirate složenije uzorke.

Recimo da moramo pronaći bilo koji broj. Kada u regularnom izrazu stavimo skup znakova u uglaste zagrade, to znači da taj dio izraza odgovara bilo kojem od znakova u zagradama.

Oba izraza su u redovima koji sadrže broj.

Console.log(//.test("u 1992")); // → true console.log(//.test("u 1992")); // → istina

U uglastim zagradama, crtica između dva znaka se koristi za specifikaciju raspona znakova, gdje je niz specificiran Unicode kodiranjem. Znakovi od 0 do 9 nalaze se samo u nizu (šifre od 48 do 57), tako da ih sve hvata i odgovara bilo kojem broju.

Nekoliko grupa znakova ima svoje ugrađene skraćenice.

\d Bilo koji broj
\w Alfanumerički znak
\s Razmak (razmak, tabulator, novi red, itd.)
\D nije broj
\W nije alfanumerički znak
\S nije znak razmaka
. bilo koji znak osim prijelaza na red

Dakle, možete postaviti format datuma i vremena kao 01/30/2003 15:20 sa sljedećim izrazom:

Var dateTime = /\d\d-\d\d-\d\d\d\d \d\d:\d\d/; console.log(dateTime.test("30-01-2003 15:20")); // → true console.log(dateTime.test("30-Jan-2003 15:20")); // → netačno

Izgleda užasno, zar ne? Ima previše obrnutih kosih crta, zbog čega je obrazac teško razumjeti. Kasnije ćemo ga malo poboljšati.

Obrnute kose crte se također mogu koristiti u uglastim zagradama. Na primjer, [\d.] znači bilo koji broj ili tačku. Obratite pažnju da tačka unutar uglastih zagrada gubi svoje posebno značenje i postaje jednostavno tačka. Isto važi i za druge specijalne znakove, kao što je +.

Možete invertirati skup znakova - to jest, reći da trebate pronaći bilo koji karakter osim onih koji su u skupu - postavljanjem znaka ^ odmah iza početne uglaste zagrade.

Var notBinary = /[^01]/; console.log(notBinary.test("1100100010100110")); // → false console.log(notBinary.test("1100100010200110")); // → istina

Ponavljanje dijelova šablona

Znamo kako pronaći jedan broj. Šta ako trebamo pronaći cijeli broj - niz od jedne ili više cifara?

Ako stavite znak + iza nečega u redovnom nizu, to će značiti da se ovaj element može ponoviti više puta. /\d+/ označava jednu ili više cifara.

Console.log(/"\d+"/.test(""123"")); // → true console.log(/"\d+"/.test("""")); // → false console.log(/"\d*"/.test(""123"")); // → true console.log(/"\d*"/.test("""")); // → istina

Zvjezdica * ima skoro isto značenje, ali dozvoljava da se obrazac pojavljuje nula puta. Ako je iza nečega zvjezdica, onda to nikada ne sprječava da obrazac bude u liniji - samo se pojavljuje nula puta.

Znak pitanja čini dio obrasca opcionim, što znači da se može pojaviti nula ili jednom. U sljedećem primjeru može se pojaviti znak u, ali uzorak se podudara čak i kada nije.

Var susjed = /neighbou?r/; console.log(neighbor.test("susjed")); // → true console.log(neighbor.test("neighbor")); // → istina

Vitičaste zagrade se koriste za određivanje točnog broja puta da se obrazac mora pojaviti. (4) nakon elementa znači da se mora pojaviti 4 puta u redu. Također možete odrediti razmak: (2,4) znači da se element mora pojaviti najmanje 2 i ne više od 4 puta.

Druga verzija formata datuma i vremena, gdje su dozvoljeni dani, mjeseci i sati od jedne ili dvije cifre. I takođe je malo čitljiviji.

Var dateTime = /\d(1,2)-\d(1,2)-\d(4) \d(1,2):\d(2)/; console.log(dateTime.test("30-1-2003 8:45")); // → istina

Možete koristiti otvorene razmake tako što ćete izostaviti jedan od brojeva. (,5,) znači da se obrazac može pojaviti od nula do pet puta, a (5,) znači od pet ili više.

Grupiranje podizraza

Da biste koristili * ili + operatore na više elemenata odjednom, možete koristiti zagrade. Dio regularnog izraza zatvoren u zagrade smatra se jednim elementom sa stanovišta operatora.

Var cartoonCrying = /boo+(hoo+)+/i; console.log(cartoonCrying.test("Boohoooohoohooo")); // → istina

Prvi i drugi plus se odnose samo na druge o u boo and hoo. Treći + se odnosi na cijelu grupu (hoo+), pronalazeći jednu ili više takvih sekvenci.

Slovo i na kraju izraza čini regularni izraz neosjetljivim na velika i mala slova - tako da B odgovara b.

Utakmice i grupe

Test metoda je najjednostavniji metod za provjeru regularnih izraza. To vam samo govori da li je pronađeno podudaranje ili ne. Regulari također imaju exec metodu, koja će vratiti null ako ništa nije pronađeno, a u suprotnom će vratiti objekt s informacijama o podudaranju.

Var match = /\d+/.exec("jedan dva 100"); console.log(podudaranje); // → ["100"] console.log(match.index); // → 8

Objekt koji vraća exec ima svojstvo indeksa, koje sadrži broj znaka iz kojeg je došlo do podudaranja. Općenito, objekt izgleda kao niz stringova, gdje je prvi element string koji je provjeren za podudaranje. U našem primjeru, ovo će biti niz brojeva koji smo tražili.

Stringovi imaju metodu podudaranja koja radi na skoro isti način.

Console.log("jedan dva 100".match(/\d+/)); // → ["100"]

Kada regularni izraz sadrži podizraze grupirane zagradama, tekst koji odgovara ovim grupama također će se pojaviti u nizu. Prvi element je uvijek potpuno podudaranje. Drugi je dio koji odgovara prvoj grupi (onoj čije su zagrade prve pronađene), zatim drugoj grupi i tako dalje.

Var quotedText = /"([^"]*)"/; console.log(quotedText.exec("ona je rekla "zdravo"")); // → [""zdravo"", "zdravo"]

Kada grupa uopšte nije pronađena (na primer, ako je praćena upitnikom), njena pozicija u nizu je nedefinisana. Ako se grupa podudara nekoliko puta, tada će samo posljednje podudaranje biti u nizu.

Console.log(/bad(ly)?/.exec("bad")); // → ["loše", nedefinisano] console.log(/(\d)+/.exec("123")); // → ["123", "3"]

Grupe su korisne za dohvaćanje dijelova nizova. Ako ne želimo samo provjeriti da li niz ima datum, već ga izdvojiti i kreirati objekt koji predstavlja datum, možemo staviti nizove brojeva u zagrade i odabrati datum iz rezultata exec.

Ali prvo, mala digresija u kojoj ćemo naučiti preferirani način pohranjivanja datuma i vremena u JavaScript-u.

Vrsta datuma

JavaScript ima standardni tip objekta za datume – preciznije, trenutke u vremenu. Zove se datum. Ako jednostavno kreirate objekt datuma koristeći new, dobit ćete trenutni datum i vrijeme.

Console.log(novi datum()); // → Ned 9. nov 2014. 00:07:57 GMT+0300 (CET)

Također možete kreirati objekt koji sadrži dato vrijeme

Console.log(novi datum(2015, 9, 21)); // → Sre, 21. oktobar 2015. 00:00:00 GMT+0300 (CET) console.log(novi datum(2009, 11, 9, 12, 59, 59, 999)); // → Wed Dec 09 2009 12:59:59 GMT+0300 (CET)

JavaScript koristi konvenciju u kojoj brojevi mjeseci počinju s nulom, a brojevi dana počinju s jedinicom. Ovo je glupo i smešno. Budite oprezni.

Posljednja četiri argumenta (sati, minute, sekunde i milisekunde) su opcionalna i postavljena su na nulu ako nedostaju.

Vremenske oznake se pohranjuju kao broj milisekundi koji su prošli od početka 1970. godine. Za vremena prije 1970. koriste se negativni brojevi (to je zbog Unix vremenske konvencije koja je stvorena otprilike u to vrijeme). Metoda getTime objekta datuma vraća ovaj broj. Prirodno je velika.
console.log(novi datum(2013, 11, 19).getTime()); // → 1387407600000 console.log(novi datum(1387407600000)); // → Čet 19. decembar 2013. 00:00:00 GMT+0100 (CET)

Ako konstruktoru Date date jedan argument, on se tretira kao ovaj broj milisekundi. Možete dobiti trenutnu vrijednost milisekundi kreiranjem objekta Date i pozivanjem metode getTime ili pozivom funkcije Date.now.

Objekt Date ima metode getFullYear, getMonth, getDate, getHours, getMinutes i getSeconds za preuzimanje njegovih komponenti. Postoji i getYear metoda koja vraća prilično beskorisni dvocifreni kod poput 93 ili 14.

Stavljanjem relevantnih dijelova predloška u zagrade, možemo kreirati objekt datuma direktno iz niza.

Funkcija findDate(string) (var dateTime = /(\d(1,2))-(\d(1,2))-(\d(4))/; var match = dateTime.exec(string); return novi Datum(Broj(podudaranje), Broj(podudaranje) - 1, Broj(podudaranje) ) console.log(findDate("30-1-2003")); // → Čet, 30. januar 2003. 00:00:00 GMT+0100 (CET)

Granice riječi i linija

Nažalost, findDate će isto tako rado izdvojiti besmisleni datum 00-1-3000 iz niza "100-1-30000". Podudaranje se može dogoditi bilo gdje u nizu, tako da će u ovom slučaju jednostavno početi od drugog znaka i završiti na pretposlednjem znaku.

Ako trebamo natjerati podudaranje da preuzme cijeli niz, koristimo oznake ^ i $. ^ odgovara početku reda, a $ odgovara kraju. Stoga /^\d+$/ odgovara nizu koji sadrži samo jednu ili više cifara, /^!/ odgovara nizu koji počinje uzvikom, a /x^/ ne odgovara ni jednom nizu (ne može postojati x).

Ako, s druge strane, samo želimo biti sigurni da datum počinje i završava na granici riječi, koristimo oznaku \b. Granica riječi može biti početak ili kraj reda, ili bilo koje mjesto u redu gdje se nalazi alfanumerički znak \w na jednoj strani i nealfanumerički znak na drugoj.

Console.log(/cat/.test("concatenate")); // → true console.log(/\bcat\b/.test("concatenate")); // → netačno

Imajte na umu da oznaka granice nije simbol. To je jednostavno ograničenje, što znači da se podudaranje događa samo ako je ispunjen određeni uvjet.

Šabloni po izboru

Recimo da trebate saznati da li tekst sadrži ne samo broj, već i broj iza kojeg slijedi svinja, krava ili piletina u jednini ili množini.

Bilo bi moguće napisati tri regularna izraza i provjeriti ih jedan po jedan, ali postoji bolji način. Simbol | označava izbor između uzoraka lijevo i desno od njega. I možemo reći sljedeće:

Var animalCount = /\b\d+ (svinja|krava|piletina)s?\b/; console.log(animalCount.test("15 svinja")); // → true console.log(animalCount.test("15 kokoši")); // → netačno

Zagrade razgraničavaju dio obrasca na koji se primjenjuje | i mnogi takvi operatori se mogu postaviti jedan za drugim da bi označili izbor između više od dvije opcije.

Tražilica

Regularni izrazi se mogu smatrati dijagramima toka. Sljedeći dijagram opisuje nedavni primjer stoke.

Izraz odgovara nizu ako je moguće pronaći putanju s lijeve strane dijagrama na desnu. Pamtimo trenutnu poziciju u liniji i svaki put kada prolazimo kroz pravougaonik, provjeravamo da li dio linije odmah iza naše pozicije u njoj odgovara sadržaju pravougaonika.

To znači da provjera podudaranja našeg regularnog karaktera u nizu "the 3 pigs" kada prolazite kroz dijagram toka izgleda ovako:

Na poziciji 4 nalazi se granica riječi i prolazimo prvi pravougaonik
- počevši od 4. pozicije nalazimo broj i prolazimo kroz drugi pravougaonik
- na poziciji 5, jedna putanja se zatvara ispred drugog pravougaonika, a druga ide dalje do pravougaonika sa razmakom. Imamo razmak, a ne broj, i biramo drugi put.
- sada smo na poziciji 6, početak “svinja”, i na trostrukom grananju staza. U redu nema „krave“ ili „pilića“, ali postoji „svinja“, pa biramo ovaj put.
- na poziciji 9 nakon trostruke vilice, jedna putanja zaobilazi “s” i ide do posljednjeg pravougaonika s granicom riječi, a druga prolazi kroz “s”. Imamo "s" pa idemo tamo.
- na poziciji 10 nalazimo se na kraju reda i samo granica riječi se može podudarati. Kraj linije se smatra granicom, a prolazimo kroz zadnji pravougaonik. I sada smo uspješno pronašli naš predložak.

U osnovi, način na koji regularni izrazi funkcioniraju je da algoritam počinje na početku stringa i pokušava tamo pronaći podudaranje. U našem slučaju postoji granica riječi, tako da prolazi prvi pravougaonik - ali tamo nema broja, pa naiđe na drugi pravougaonik. Zatim prelazi na drugi znak u nizu, i pokušava tamo pronaći podudaranje... I tako sve dok ne pronađe podudaranje ili dođe do kraja niza, u kom slučaju nije pronađeno podudaranje.

Kickbacks

Regularni izraz /\b(+b|\d+|[\da-f]h)\b/ odgovara ili binarnom broju nakon kojeg slijedi b, decimalni broj bez sufiksa ili heksadecimalni broj (brojevi od 0 do 9 ili simboli od a do h), nakon kojih slijedi h. Relevantan dijagram:

Prilikom traženja podudaranja može se dogoditi da algoritam zauzme gornju putanju (binarni broj), čak i ako u nizu nema takvog broja. Ako postoji red „103“, na primjer, jasno je da će algoritam tek nakon dostizanja broja 3 shvatiti da je na pogrešnom putu. Generalno, linija se poklapa sa regularnim nizom, samo ne u ovoj niti.

Zatim se algoritam vraća nazad. Na račvanju pamti trenutnu poziciju (u našem slučaju, ovo je početak reda, odmah iza granice riječi) tako da se možete vratiti i pokušati drugom putanjom ako odabrani ne uspije. Za string “103”, nakon što naiđe na trojku, on će se vratiti i pokušati proći kroz decimalni put. Ovo će funkcionirati tako da će se pronaći podudaranje.

Algoritam se zaustavlja čim pronađe potpuno podudaranje. To znači da čak i ako je više opcija pogodno, koristi se samo jedna od njih (redom kojim se pojavljuju u redovnom nizu).

Vraćanje unazad se dešava kada se koriste operatori ponavljanja kao što su + i *. Ako tražite /^.*x/ u nizu "abcxe", dio regularnog izraza.* će pokušati da iskoristi cijeli niz. Algoritam će tada shvatiti da mu je potrebno i “x”. Pošto nema "x" nakon kraja niza, algoritam će pokušati tražiti podudaranje tako što će pomjeriti jedan znak unazad. Nakon abcx također nema x, onda se ponovo vraća, ovaj put na podniz abc. I nakon linije, pronalazi x i prijavljuje uspješno podudaranje, na pozicijama od 0 do 4.

Možete napisati redovnu rutinu koja će dovesti do višestrukih vraćanja. Ovaj problem se javlja kada obrazac može odgovarati ulazu na mnogo različitih načina. Na primjer, ako pogriješimo prilikom pisanja regularnog izraza za binarne brojeve, mogli bismo slučajno napisati nešto poput /(+)+b/.

Ako bi algoritam tražio takav obrazac u dugom nizu 0s i 1s koji nema "b" na kraju, prvo bi prošao kroz unutrašnju petlju dok mu ne ponestane cifara. Tada će primetiti da nema "b" na kraju, vratiće se za jednu poziciju, proći kroz spoljnu petlju, ponovo odustati, pokušati da se vrati na drugu poziciju duž unutrašnje petlje... I nastaviće za pretraživanje na ovaj način, koristeći obje petlje. Odnosno, količina posla sa svakim karakterom linije će se udvostručiti. Čak i za nekoliko desetina likova, pronalaženje podudaranja će potrajati jako dugo.

zameniti metodu

Stringovi imaju metodu zamjene koja može zamijeniti dio niza drugim nizom.

Console.log("tata".replace("p", "m")); // → mapa

Prvi argument također može biti regularni izraz, u kom slučaju se prvo pojavljivanje regularnog izraza u redu zamjenjuje. Kada se „g” (globalna) opcija doda regularnom izrazu, sva pojavljivanja se zamjenjuju, a ne samo prva

Console.log("Borobudur".replace(//, "a")); // → Barobudur console.log("Borobudur".replace(//g, "a")); // → Barabadar

Imalo bi smisla proći opciju "zamijeni sve" kroz poseban argument ili kroz poseban metod kao što je replaceAll. Ali nažalost, opcija se prenosi putem samog redovnog sistema.

Puna moć regularnih izraza se otkriva kada koristimo veze do grupa koje se nalaze u nizu, specificiranih u regularnom izrazu. Na primjer, imamo red koji sadrži imena ljudi, jedno ime po redu, u formatu "Prezime, Ime". Ako ih trebamo zamijeniti i ukloniti zarez da bismo dobili "Ime Prezime", pišemo sljedeće:

Console.log("Hopper, Grace\nMcCarthy, John\nRitchie, Dennis" .replace(/([\w ]+), ([\w ]+)/g, "$2 $1")); // → Grace Hopper // John McCarthy // Dennis Ritchie

$1 i $2 u redu za zamjenu odnose se na grupe znakova zatvorene u zagradama. $1 se zamjenjuje tekstom koji odgovara prvoj grupi, $2 drugoj grupi i tako dalje, do $9. Cijelo podudaranje je sadržano u varijabli $&.

Također možete proslijediti funkciju kao drugi argument. Za svaku zamjenu bit će pozvana funkcija čiji će argumenti biti pronađene grupe (i cijeli odgovarajući dio reda), a njen rezultat će biti umetnut u novi red.

Jednostavan primjer:

Var s = "CIA i FBI"; console.log(s.replace(/\b(fbi|cia)\b/g, function(str) (vraćanje str.toUpperCase(); ))); // → CIA i FBI

Evo još zanimljivijeg:

Var stock = "1 limun, 2 kupusa i 101 jaje"; funkcija minusOne(podudaranje, količina, jedinica) (iznos = Broj(iznos) - 1; ako je (iznos == 1) // samo jedan ostao, uklonite "s" na krajnjoj jedinici = unit.slice(0, unit. dužina - 1 if (iznos == 0) iznos = "ne" + jedinica ) console.log(/(\d+) (\w+)/g, minusOne); ); // → bez limuna, 1 kupus i 100 jaja

Kôd uzima string, pronalazi sva pojavljivanja brojeva iza kojih slijedi riječ i vraća niz sa svakim brojem smanjenim za jedan.

Grupa (\d+) ulazi u argument iznos, a (\w+) ulazi u argument jedinice. Funkcija pretvara iznos u broj - i to uvijek radi, jer je naš obrazac \d+. A zatim mijenja riječ, u slučaju da je ostala samo 1 stavka.

Pohlepa

Lako je koristiti zamjenu za pisanje funkcije koja uklanja sve komentare iz JavaScript koda. Evo prvog pokušaja:

Funkcija stripComments(code) ( return code.replace(/\/\/.*|\/\*[^]*\*\//g, ""); ) console.log(stripComments("1 + /* 2 */3")); // → 1 + 3 console.log(stripComments("x = 10;// deset!")); // → x = 10; console.log(stripComments("1 /* a */+/* b */ 1")); // → 1 1

Dio prije operatora "ili" odgovara dvije kose crte iza kojih slijedi bilo koji broj znakova osim novog reda. Dio koji uklanja komentare u više redaka je složeniji. Koristimo [^], tj. bilo koji znak koji nije prazan kao način za pronalaženje bilo kojeg znaka. Ne možemo koristiti tačku jer se blok komentari nastavljaju u novom redu, a znak novog reda ne odgovara tački.

Ali rezultat prethodnog primjera je netačan. Zašto?

[^]* dio će prvo pokušati uhvatiti što više znakova može. Ako zbog toga sljedeći dio regularnog niza ne pronađe podudaranje, vratit će se za jedan znak i pokušati ponovo. U primjeru, algoritam pokušava zgrabiti cijelu liniju, a zatim se vraća nazad. Nakon što je vratio 4 znaka, on će pronaći */ u redu - a to nije ono što smo željeli. Htjeli smo da zgrabimo samo jedan komentar, a ne da idemo do kraja reda i pronađemo posljednji komentar.

Zbog toga kažemo da su operatori ponavljanja (+, *, ?, i ()) pohlepni, što znači da prvo zgrabe onoliko koliko mogu, a zatim se vraćaju. Ako postavite pitanje nakon ovakvog operatora (+?, *?, ??, ()?), oni će se pretvoriti u nepohlepne i početi da pronalaze najmanja moguća pojavljivanja.

I to je ono što nam treba. Prisiljavanjem zvjezdice da pronađe podudaranja u minimalnom mogućem broju znakova u redu, trošimo samo jedan blok komentara i ništa više.

Funkcija stripComments(code) ( return code.replace(/\/\/.*|\/\*[^]*?\*\//g, ""); ) console.log(stripComments("1 /* a */+/* b */ 1")); // → 1 + 1

Mnoge greške se javljaju kada se koriste pohlepni operatori umjesto onih koji nisu pohlepni. Kada koristite operator ponavljanja, uvijek prvo razmotrite opciju ne-pohlepnog operatora.

Dinamičko kreiranje RegExp objekata

U nekim slučajevima, tačan obrazac nije poznat u vrijeme pisanja koda. Na primjer, morat ćete potražiti ime korisnika u tekstu i staviti ga u donje crte. Pošto ćete ime znati tek nakon pokretanja programa, ne možete koristiti kosicu.

Ali možete konstruisati string i koristiti konstruktor RegExp. Evo primjera:

Var name = "harry"; var text = "A Harry ima ožiljak na čelu."; var regexp = new RegExp("\\b(" + ime + ")\\b", "gi"); console.log(text.replace(regexp, "_$1_")); // → I _Harry_ ima ožiljak na čelu.

Prilikom kreiranja granica riječi moramo koristiti dvostruke kose crte jer ih pišemo u normalnom redu, a ne u regularnom izrazu sa kosim crtama naprijed. Drugi argument za RegExp sadrži opcije za regularne izraze - u našem slučaju “gi”, tj. globalno i bez obzira na velika i mala slova.

Ali šta ako je ime “dea+hlrd” (ako je naš korisnik kulhatzker)? Kao rezultat, dobićemo besmisleni regularni izraz koji neće pronaći podudaranja u nizu.

Možemo dodati obrnute kose crte ispred bilo kojeg znaka koji nam se ne sviđa. Ne možemo dodati obrnute kose crte prije slova jer su \b ili \n specijalni znakovi. Ali možete bez problema dodati kose crte ispred bilo kojeg nealfanumeričkog karaktera.

Var name = "dea+hlrd"; var text = "Ovaj dea+hlrd nervira sve."; var escaped = name.replace(/[^\w\s]/g, "\\$&"); var regexp = new RegExp("\\b(" + escaped + ")\\b", "gi"); console.log(text.replace(regexp, "_$1_")); // → Ovo _dea+hlrd_ je iznerviralo sve.

metoda pretrage

Metoda indexOf se ne može koristiti s regularnim izrazima. Ali postoji metoda pretraživanja koja samo očekuje regularni izraz. Kao i indexOf, vraća indeks prvog pojavljivanja, ili -1 ako se ništa ne dogodi.

Console.log(" word".search(/\S/)); // → 2 console.log(" ".search(/\S/)); // → -1

Nažalost, ne postoji način da kažete metodi da traži podudaranje počevši od određenog pomaka (kao što možete učiniti s indexOf). To bi bilo od pomoći.

lastIndex svojstvo

Exec metoda također ne pruža zgodan način za početak pretraživanja sa date pozicije u nizu. Ali to daje nezgodan način.

Regex objekat ima svojstva. Jedan od njih je izvor, koji sadrži niz. Drugi je lastIndex, koji kontrolira, pod određenim uvjetima, gdje će početi sljedeća pretraga pojavljivanja.

Ovi uvjeti uključuju da globalna opcija g mora biti prisutna i da se pretraga mora obaviti korištenjem exec metode. Razumnije rešenje bi bilo jednostavno dozvoliti da se dodatni argument prosleđuje exec, ali razumnost nije osnovna karakteristika JavaScript interfejsa regularnog izraza.

Var obrazac = /y/g; pattern.lastIndex = 3; var match = pattern.exec("xyzzy"); console.log(match.index); // → 4 console.log(pattern.lastIndex); // → 5

Ako je pretraga bila uspješna, exec poziv ažurira lastIndex svojstvo da ukazuje na poziciju nakon pronađene pojave. Ako nije bilo uspjeha, lastIndex se postavlja na nulu - baš kao i lastIndex novokreiranog objekta.

Kada koristite globalnu regularnu varijablu i višestruke exec pozive, ova automatska ažuriranja lastIndexa mogu uzrokovati probleme. Vaš regularni server može započeti pretragu sa pozicije lijevo od prethodnog poziva.

Var cifra = /\d/g; console.log(digit.exec("ovdje je: 1")); // → ["1"] console.log(digit.exec("i sada: 1")); // → null

Još jedan zanimljiv efekat opcije g je da menja način rada metode podudaranja. Kada se pozove s ovom opcijom, umjesto vraćanja niza kao što je rezultat exec, pronalazi sva pojavljivanja uzorka u nizu i vraća niz pronađenih podstringova.

Console.log("Banana".match(/an/g)); // → ["an", "an"]

Zato budite oprezni sa globalnim regularnim varijablama. Slučajevi u kojima su potrebni - zamijenite pozive ili mjesta na kojima posebno koristite lastIndex - vjerovatno su svi slučajevi u kojima ih treba koristiti.

Ciklusi pojavljivanja

Tipičan zadatak je iteracija kroz sva pojavljivanja uzorka u nizu tako da može pristupiti objektu podudaranja u tijelu petlje, koristeći lastIndex i exec.

Var input = "Red sa 3 broja u njemu... 42 i 88."; broj var = /\b(\d+)\b/g; var match; while (match = number.exec(input)) console.log("Found ", match, " on ", match.index); // → Pronađeno 3 x 14 // Pronađeno 42 x 33 // Pronađeno 88 x 40

Koristi se od činjenice da je vrijednost dodjele vrijednost koja se dodjeljuje. Koristeći match = re.exec(input) kao uslov u while petlji, pretražujemo na početku svake iteracije, pohranjujemo rezultat u varijablu i završavamo petlju kada se pronađu sva podudaranja.

Parsing INI fajlova

Da zaključimo poglavlje, pogledajmo problem pomoću regularnih izraza. Zamislite da pišemo program koji automatski prikuplja informacije o našim neprijateljima putem interneta. (Nećemo pisati cijeli program, samo dio koji čita datoteku postavki. Žao nam je.) Fajl izgleda ovako:

Searchengine=http://www.google.com/search?q=$1 spitefulness=9.7 ; tačka-zarez se stavlja ispred komentara; svaki odjeljak se odnosi na različitog neprijatelja puno ime=Larry Doe type=kindergarten bull website=http://www.geocities.com/CapeCanaveral/11451 fullname=Gargamel type=evil wizard outputdir=/home/marijn/enemies/gargamel

Tačan format datoteke (koji se dosta koristi i obično se naziva INI) je sljedeći:

Prazni redovi i redovi koji počinju tačkom i zarezom se zanemaruju
- linije zatvorene u uglaste zagrade počinju novi dio
- redovi koji sadrže alfanumerički identifikator nakon čega slijedi = dodajte postavku u ovaj odjeljak

Sve ostalo su netačni podaci.

Naš zadatak je da konvertujemo takav niz u niz objekata, svaki sa svojstvom imena i nizom postavki. Jedan objekat je potreban za svaki odeljak, a drugi je potreban za globalne postavke na vrhu datoteke.

Pošto datoteku treba raščlaniti red po red, dobra je ideja početi razbijanjem datoteke na redove. Da bismo to uradili, koristili smo string.split("\n") u poglavlju 6. Neki operativni sistemi ne koriste jedan znak \n za prijelom reda, već dva - \r\n. Pošto metoda split uzima regularne izraze kao argument, možemo podijeliti linije koristeći izraz /\r?\n/, dozvoljavajući i jedan \n i \r\n između redova.

Funkcija parseINI(string) ( // Počnimo sa objektom koji sadrži postavke najvišeg nivoa var currentSection = (ime: null, polja: ); var kategorije = ; string.split(/\r?\n/).forEach(function (linija ) ( podudaranje var; if (/^\s*(;.*)?$/.test(line)) ( povratak; ) else if (podudaranje = line.match(/^\[(.*)\ ]$ /)) ( currentSection = (name: match, fields: ); category.push(currentSection); ) else if (match = line.match(/^(\w+)=(.*)$/)) ( currentSection fields.push((name: match, value: match) else ("Red "" + line + "" sadrži nevažeće podatke."); ));

Kôd prolazi kroz sve linije, ažurirajući trenutni objekt odjeljka „trenutni odjeljak“. Prvo, provjerava da li se linija može zanemariti pomoću regularnog izraza /^\s*(;.*)?$/. Možete li zamisliti kako ovo funkcionira? Dio između zagrada odgovara komentarima, a? čini tako da će regularni znak odgovarati i linijama koje se sastoje samo od razmaka.

Ako linija nije komentar, kod provjerava da li počinje novi odjeljak. Ako da, kreira novi objekat za trenutni odeljak, kojem se dodaju naknadne postavke.

Posljednja značajna mogućnost je da je niz normalna postavka, u kom slučaju se dodaje trenutnom objektu.

Ako nijedna od opcija ne radi, funkcija ispušta grešku.

Obratite pažnju na to kako česta upotreba ^ i $ osigurava da izraz odgovara cijelom nizu, a ne samo njegovom dijelu. Ako ih ne koristite, kod će općenito raditi, ali će ponekad proizvesti čudne rezultate i grešku će biti teško pronaći.

Konstrukcija if (match = string.match(...)) je slična triku korištenja dodjele kao uvjeta u while petlji. Često ne znate da će poziv podudaranja uspjeti, tako da možete pristupiti samo rezultatskom objektu unutar if bloka koji ga provjerava. Kako ne bismo prekinuli prekrasan lanac if provjera, rezultat pretraživanja dodjeljujemo varijabli i odmah koristimo ovu dodjelu kao provjeru.

Međunarodni simboli

Zbog početno jednostavne implementacije jezika i naknadne fiksacije takve implementacije „u granitu“, JavaScript regularni izrazi su glupi sa znakovima koji se ne nalaze u engleskom jeziku. Na primjer, znak „slovo“, sa stanovišta JavaScript regularnih izraza, može biti jedno od 26 slova engleske abecede, a iz nekog razloga i donja crta. Slova poput é ili β, koja su jasno slova, ne odgovaraju \w (i odgovarat će \W, što nije slovo).

U čudnom zaokretu, istorijski \s (razmak) odgovara svim znakovima koji se smatraju razmakom u Unicodeu, uključujući stvari poput razmaka bez prekida ili mongolskog separatora samoglasnika.

Neke implementacije regularnih izraza u drugim jezicima imaju posebnu sintaksu za traženje posebnih kategorija Unicode znakova, kao što su "sva velika slova", "sve interpunkcije" ili "kontrolni znakovi". Postoje planovi da se takve kategorije dodaju u JavaScript, ali one, po svemu sudeći, neće uskoro biti implementirane.

Zaključak

Regulari su objekti koji predstavljaju obrasce pretraživanja u nizovima. Oni koriste vlastitu sintaksu da izraze ove obrasce.

/abc/ Niz znakova
// Bilo koji znak sa liste
/[^abc]/ Bilo koji znak osim znakova sa liste
// Bilo koji znak iz intervala
/x+/ Jedno ili više pojavljivanja uzorka x
/x+?/ Jedno ili više pojavljivanja, nije pohlepno
/x*/ Nula ili više pojavljivanja
/x?/ Nula ili jedno pojavljivanje
/x(2,4)/ Od dva do četiri pojavljivanja
/(abc)/ Grupa
/a|b|c/ Bilo koji od nekoliko obrazaca
/\d/ Bilo koji broj
/\w/ Bilo koji alfanumerički znak (“slovo”)
/\s/ Bilo koji razmak
/./ Bilo koji znak osim prijeloma reda
/\b/ Granica riječi
/^/ Početak reda
/$/ Kraj reda

Redovni izraz ima testnu metodu za provjeru da li je uzorak u nizu. Postoji exec metoda koja vraća niz koji sadrži sve pronađene grupe. Niz ima svojstvo indeksa, koje sadrži broj karaktera iz kojeg je došlo do podudaranja.

Stringovi imaju metodu podudaranja za uparivanje uzoraka i metodu pretraživanja koja vraća samo početnu poziciju pojave. Metoda zamjene može zamijeniti pojavljivanja uzorka drugim nizom. Osim toga, možete proslijediti funkciju za zamjenu koja će izgraditi zamjensku liniju na osnovu predloška i pronađenih grupa.

Uobičajeni znakovi imaju postavke koje se pišu nakon završne kose crte. Opcija i čini regularni izraz neosjetljivim na velika i mala slova, a opcija g ga čini globalnim, što, između ostalog, uzrokuje zamjenu metoda zamjene svih pronađenih pojava, a ne samo prvog.

Konstruktor RegExp se može koristiti za kreiranje regularnih izraza iz stringova.

Regulatori su oštar instrument sa neudobnom ručkom. One uvelike pojednostavljuju neke zadatke, a mogu postati neizvodljive prilikom rješavanja drugih, složenih problema. Dio učenja korištenja regularnog izraza je da budete u stanju odoljeti iskušenju da ga napunite zadatkom za koji nije namijenjen.

Vježbe

Neminovno ćete pri rješavanju problema naići na nerazumljive slučajeve, a ponekad možete i očajavati kada vidite nepredvidivo ponašanje nekih regularnih izraza. Ponekad pomaže proučavanje ponašanja običnog motora putem online usluge kao što je debuggex.com, gdje možete vidjeti njegovu vizualizaciju i uporediti je sa željenim efektom.

Regular golf

“Golf” u kodu je igra u kojoj je potrebno izraziti dati program u minimalnom broju znakova. Redovni golf je praktična vježba u pisanju najmanjih mogućih regularnih igrača da pronađu zadani obrazac, i samo to.

Za svaki od podredova napišite regularni izraz da provjerite njihovu lokaciju u redu. Redovni motor bi trebao pronaći samo ove specificirane podnizove. Ne brinite o granicama riječi osim ako nije posebno spomenuto. Kada imate uobičajeni obrazac koji radi, pokušajte ga smanjiti.

Auto i mačka
- pop i rekvizit
- tvor, trajekt i ferari
- Bilo koja reč koja se završava na ious
- Razmak iza kojeg slijedi tačka, zarez, dvotočka ili tačka-zarez.
- Riječ duža od šest slova
- Riječ bez slova e

// Unesite svoje regularne izraze verify(/.../, ["moj auto", "loše mačke"], ["kamper", "visoka umjetnost"]); verify(/.../, ["pop kultura", "mad props"], ["plop"]); verify(/.../, ["feret", "ferry", "ferrari"], ["ferrum", "transfer A"]); verify(/.../, ["kako je ukusno", "prostrana soba"], ["ruinous", "consciousness"]); verify(/.../, ["loša interpunkcija ."], ["izbjeći tačku"]); verify(/.../, ["hottenottententen"], ["ne", "hotten totten tenten"]); verify(/.../, ["crveni kljunaš", "ljuljavo gnijezdo"], ["zemljani krevet", "majmun koji uči"]); funkcija verify(regexp, da, ne) ( // Zanemari nedovršene vježbe if (regexp.source == "...") return; yes.forEach(function(s) ( if (!regexp.test(s)) konzola .log("Nije pronađeno "" + s + """ ) no.forEach(funkcija(e) (if (regexp.test(s)) console.log("Neočekivana pojava "" + s + " ""); ); ));

Citati u tekstu

Recimo da ste napisali priču i koristili pojedinačne navodnike kako biste naznačili dijalog. Sada želite zamijeniti navodnike u dijalogu dvostrukim navodnicima, a jednostruke navodnike ostaviti u skraćenicama za riječi kao što su nisu.

Osmislite obrazac koji razlikuje ove dvije upotrebe navodnika i napišite poziv zamjenskoj metodi koja vrši zamjenu.

Opet brojevi

Nizovi brojeva se mogu pronaći jednostavnim regularnim izrazom /\d+/.

Napišite izraz koji pronalazi samo brojeve napisane u JavaScript stilu. Mora podržavati mogući minus ili plus prije broja, decimalnog zareza i naučne oznake 5e-3 ili 1E10 - opet sa mogućim plusom ili minusom. Također imajte na umu da ne moraju nužno biti brojevi prije ili poslije tačke, ali se broj ne može sastojati od jedne tačke. To jest, .5 ili 5. su važeći brojevi, ali jedna tačka sama po sebi nije.

// Ovdje unesite regularni niz. broj var = /^...$/; // Testovi: ["1", "-1", "+15", "1.55", ".5", "5.", "1.3e2", "1E-4", "1e+12"] .forEach(funkcija(e) ( if (!number.test(s)) console.log("Nisam pronašao "" + s + """); )); ["1a", "+-1", "1.2.3", "1+1", "1e4.5", ".5.", "1f5", "."].forEach(funkcija(e) ( if (broj.test(ovi)) console.log("Neispravno prihvaćeno "" + s + """); ));

Ovaj članak pokriva osnove upotrebe regularnog izraza u Javascriptu.

Uvod

Šta je regularni izraz?

JS regularni izraz je niz znakova koji formira pravilo pretraživanja. Ovo pravilo se zatim može koristiti za pretraživanje teksta, kao i za njegovu zamjenu. U praksi, regularni izraz se čak može sastojati od jednog znaka, ali složeniji obrasci pretraživanja su češći.

U Javascriptu, regularni izrazi su također objekti. Ovo su obrasci koji se koriste za usklađivanje nizova znakova u nizovima. Koriste se u exec() i test() metodama RegExp objekta i u metodama match(), replace(), search i split() objekta String.

Primjer

var obrazac = /primjer/i

/primjer/i je regularni izraz. primjer je šablon ( koji će se koristiti u pretrazi). i je modifikator koji pokazuje osjetljivost na velika i mala slova.

Priprema regularnog izraza

JS regularni izrazi se sastoje od uzorka i modifikatora. Sintaksa će biti otprilike ovako:

/uzorak/modifikatori;

Šablon specificira pravilo pretraživanja. Sastoji se od jednostavnih znakova poput /abc/ ili kombinacije jednostavnih i posebnih znakova: /abc/ ili /Chapter (d+).d/ .

Tablica šablona

Modifikatori vam omogućavaju da upite učinite osjetljivim na velika i mala slova, globalnim i tako dalje. Koriste se za obavljanje pretraživanja osjetljivih na velika i mala slova, kao i globalne pretrage.

Tabela modifikatora

Sada smo spremni za primjenu JS regularnih izraza. Postoje dva glavna načina da to učinite: korištenjem objekta regularnog izraza ili regularnog izraza na stringu.

Korištenje objekta regularnog izraza

Kreirajte objekat regularnog izraza

Ovaj objekat opisuje obrazac karaktera. Koristi se za usklađivanje uzoraka. Postoje dva načina da se konstruiše objekat regularnog izraza.

Metoda 1: Upotreba literala regularnog izraza koji se sastoji od uzorka zatvorenog kosim crtama, na primjer:

var reg = /ab+c/;

Literali regularnog izraza pokreću pre-kompilaciju regularnog izraza kada se skript analizira. Ako je regularni izraz konstantan, onda ga koristite za poboljšanje performansi.

Metoda 2: Pozivanje funkcije konstruktora RegExp objekta, na primjer:

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

Upotreba konstruktora omogućava kompajliranje JS regularnog izraza dok je skripta pokrenuta. Koristite ovu metodu ako će se regularni izraz promijeniti ili ako ne znate obrazac unaprijed. Na primjer, ako dobijete informacije od korisnika koji unese upit za pretraživanje.

Metode objekata regularnog izraza

Pogledajmo nekoliko uobičajenih metoda objekata regularnih izraza:

• compile() ( zastarjelo u verziji 1.5) – kompajlira regularni izraz;
• exec() - Izvodi podudaranje niza. Vraća prvo podudaranje;
• test() - izvodi podudaranje na nizu. Vraća true ili false ;
• toString() – vraća vrijednost niza regularnog izraza.

Primjeri

Korištenje test()

Test() metoda je regularni izraz RegExp objekta. On traži niz uzoraka i vraća true ili false ovisno o rezultatu. Sljedeći primjer JS regularnog izraza pokazuje kako se niz traži za karakter “ e”:

var patt = /e/; patt.test("Najbolje stvari na svijetu su besplatne!");

Pošto se ovdje u redu nalazi “ e“, rezultat ovog koda će biti istinit.

Regularni izrazi ne moraju biti smješteni u varijablu. Isti upit se može uraditi u jednom redu:

/e/.test("Najbolje stvari na svijetu su besplatne!");

Korištenje exec()

Pretražuje niz koristeći dato pravilo pretraživanja i vraća pronađeni tekst. Ako nije pronađeno nijedno podudaranje, rezultat će biti nul.

Pogledajmo metodu u akciji, koristeći primjer istog simbola “ e”:

/e/.exec("Najbolje stvari na svijetu su besplatne!");

Pošto red sadrži “ e“, rezultat ovog koda će biti .e .

Primjena regularnog izraza na string

U Javascriptu, ovi izrazi se također mogu koristiti s dvije metode String objekta: search() i replace(). Potrebni su za pretraživanje i zamjenu u tekstu.

• search() metoda - koristi izraz za traženje podudaranja i vraća informacije o lokaciji podudaranja;
• Metoda replace() vraća izmijenjeni niz sa zamijenjenim uzorkom.

Primjeri

Korištenje JS regularnog izraza za izvođenje pretraživanja izraza osjetljivog na velika i mala slova w3schools” u redu:

var str = "Posjetite W3Schools"; var n = str.search(/w3schools/i);

Rezultat u n će biti 6.

Metoda pretraživanja također uzima string kao argument. Argument string će biti konvertovan u regularni izraz:

Korištenje niza za traženje izraza " W3schools” u redu.

Izbor