Regulárny výraz je objekt, ktorý popisuje vzor znakov. Trieda RegExp v jazyku JavaScript predstavuje regulárne výrazy a objekty triedy String a RegExp definujú metódy, ktoré používajú regulárne výrazy na vykonávanie operácií porovnávania vzorov a vyhľadávania v texte s nahradením.

Regulárne výrazy sú výkonné nástroje na spracovanie prichádzajúcich údajov. Úlohu vyžadujúcu výmenu alebo hľadanie textu je možné krásne vykonať s týmto „jazykom v jazyku“.

Stvorenie

V jazyku JavaScript sú regulárne výrazy reprezentované objektmi RegExp. Objekty RegExp je možné vytvárať pomocou konštruktora RegExp (), ale častejšie sa vytvárajú pomocou špeciálnej doslovnej syntaxe. Spôsoby tvorby:

// Použitie literálu na regulárny výraz: var re = / ab + c /;

Literály regulárnych výrazov spôsobujú, že regulárny výraz bude predkompilovaný pri analýze skriptu.

// Volanie funkcie konštruktora objektu RegExp var re = new RegExp ("ab + c");

Použitie konštruktora znamená kompiláciu regulárneho výrazu za behu. Túto metódu je potrebné použiť, ak je známe, že sa výraz zmení.

Špeciálne znaky pre regulárny výraz

\ - Pre bežné symboly - robí ich špeciálnymi. Napríklad výraz / s / hľadá iba znak s. A ak zadáte \ before s, potom / \ s / už označuje prázdny znak.

^ - Označuje začiatok vstupu. Ak je nastavený príznak viacriadkového vyhľadávania („m“), spustí sa tiež na začiatku Nový riadok.

$ - Označuje koniec vstupu. Ak je nastavený príznak viacriadkového vyhľadávania, bude fungovať aj na konci riadka.

* - Indikuje opakovanie 0 alebo viackrát. Napríklad / bo * / nájde „boooo“ v „duch zahučal“ a „b“ v „vták pokrivil“, ale nič v „koze zavrčalo“.

+ - Označuje opakovanie 1 alebo viackrát. Ekvivalent k (1,). Napríklad / a + / sa zhoduje s „a“ v „cukríku“ a so všetkými „a“ v „caaaaaaandy“.

? - Označuje, že prvok môže alebo nemusí byť prítomný.

. - (Desatinná čiarka) označuje akýkoľvek iný znak ako riadkový posuv: \ n \ r \ u2028 alebo \ u2029. (pomocou [\ s \ S] môžete vyhľadať ľubovoľný znak vrátane nových riadkov).

(X)- Nájde x a pamätá si. Hovorí sa tomu „pamäťové rovnátka“. Napríklad / (foo) / nájde a zapamätá si „foo“ v „foo bare“. Nájdený podreťazec je uložený v poli s výsledkami vyhľadávania alebo vo vopred definovaných vlastnostiach objektu RegExp: $ 1,…, 9 $.

(?: X)- Nájde x, ale nepamätá si, čo našiel. Hovorí sa tomu „nepamätajúce sa zátvorky“. Nájdený podreťazec nie je uložený vo výslednom poli a vlastnostiach RegExp. Rovnako ako všetky zátvorky spájajú to, čo je v nich, do jedného subpatternu.

x (? = y)- Nájde x iba vtedy, ak za x nasleduje y. Napríklad / Jack (? = Šprot) / / sa zhoduje s „Jackom“ iba vtedy, ak za ním nasleduje „Šprot“. / Jack (? = Šprot Vo výsledku vyhľadávania sa však nezobrazí „šprot“ ani „mráz“.

x (?! y)- Nájde x iba vtedy, ak za x nie je y. Napríklad /\d+(?!\.)/ sa bude zhodovať s číslom iba vtedy, ak za ním nebude desatinná čiarka. /\d+(?!\.)/.exec(-3.141 ") nájde 141, ale nie 3,141.

x | y- Nájde x alebo y. Napríklad / zelená | červená / zodpovedá „zelenému“ v „zelenom jablku“ a „červenému“ v „červenom jablku“.

n)- Kladné celé číslo. Nájde presne n opakovaní predchádzajúceho prvku.

(n,)- Kladné celé číslo. Nájde n alebo viac opakovaní položky.

(n, m)- Kladné celé čísla. Nájdite n až m opakovaní prvku.

- Sada znakov. Nájde niektorý z nasledujúcich znakov. Medzeru môžete určiť pomlčkou. Napríklad - rovnaké ako.

[^ xyz]- Akýkoľvek znak iný ako sú uvedené v sade. Môžete tiež určiť medzeru. Napríklad [^ abc] je to isté ako [^ a-c].

[\ b]- Nájde znak backspace.

\ b- Nájde hranicu slova (latinka).

\ B- Neoznačuje hranicu slova. Napríklad / \ w \ Bn / sa zhoduje s „zapnutým“ v „poludnie“ a / y \ B \ w / sa zhoduje s „ye“ v „možno včera“.

\ cX- X je písmeno od A do Z. Označuje kontrolný znak v reťazci. Napríklad / \ cM / znamená znak Ctrl-M.

\ d- Nájde číslo z akejkoľvek abecedy.

\ D- Nájde neciferný znak (všetky abecedy). [^ 0-9] je ekvivalent pre bežné číslice.

\ f, \ r, \ n-Zodpovedajúce špeciálne znaky form-feed, line-feed, line feed.

\ s- Nájde ľubovoľný prázdny znak vrátane medzery, tabulátorov, riadkov a iných medzier v Unicode.

\ S- Bude zodpovedať akémukoľvek znaku okrem medzier.

\ t- Tabulátor.

\ v- Zvislý znak tabulátora.

\ w- Nájde ľubovoľný (latinský) slovný znak vrátane písmen, číslic a podčiarkovníka. Ekvivalentné.

\ W- Nájde akýkoľvek (nie latinský) slovný symbol. Ekvivalent k [^ A-Za-z0-9_].

\0 - Nájde znak NUL.

\ xhh- Nájde znak s kódom hh (2 hexadecimálne číslice).

\ uhhhh- Nájde znak s kódom hhhh (4 hexadecimálne číslice).

Vlajky

Príznaky regulárnych výrazov určujú pravidlá pre zhody vzorov na vysokej úrovni. Na rozdiel od zvyšku gramatiky regulárnych výrazov sú vlajky zadané nie medzi lomkami, ale za druhým. V jazyku JavaScript sú podporované tri vlajky.

Vlajka i určuje, že v zhode vzoru sa nerozlišujú malé a veľké písmená, a príznak g- že vyhľadávanie má byť globálne, t.j. musia byť nájdené všetky zhody v reťazci. Vlajka m hľadá vzor vo viacriadkovom režime. Ak hľadaný reťazcový výraz obsahuje znaky riadku, potom v tomto režime kotviace znaky ^ a $ zodpovedajú okrem začiatku a konca celého reťazcového výrazu aj začiatku a koncu každého textového reťazca. Vlajky je možné kombinovať v akejkoľvek kombinácii.

Metódy reťazcovej triedy

Reťazce podporujú štyri metódy používajúce regulárne výrazy.

Metóda Search ()

Ako argument vezme regulárny výraz a vráti buď pozíciu prvého znaku nájdeného podreťazca, alebo -1, ak sa nenašla žiadna zhoda. Nasledujúci hovor napríklad vráti 4:

Var result = "JavaScript" .search ( / script / i); // 4

Ak argument pre metódu search () nie je regulárny výraz, najskôr sa prevedie jeho odovzdaním do konštruktora RegExp. Metóda search () nepodporuje globálne vyhľadávania a príznak ignoruje g vo vašom argumente.

Metóda Replace ()

Vykonáva operáciu vyhľadávania a nahradenia. Ako prvý argument vyžaduje regulárny výraz a ako druhý náhradný reťazec. Metóda hľadá riadok, pre ktorý je volaná, aby zodpovedal zadanému vzoru. Ak regulárny výraz obsahuje príznak g, metóda replace () nahradí všetky zhody, ktoré nájde, náhradným reťazcom. V opačnom prípade nahradí iba prvý nájdený zápas.

Metóda Match ()

Za svoj jediný argument považuje regulárny výraz (alebo svoj argument prevádza na regulárny výraz tak, že ho odovzdá konštruktoru RegExp ()) a vráti pole obsahujúce výsledky vyhľadávania. Ak je v regulárnom výraze nastavený príznak g, metóda vráti pole všetkých zhôd v reťazci. Napríklad:

// vráti ["1", "2", "3"] var result = "1 plus 2 sa rovná 3" .zhoda (/ \ d +/ g);

Ak regulárny výraz neobsahuje príznak g, metóda match () nevykoná globálne vyhľadávanie; vyzerá to len na prvý zápas. Match () však vráti pole, aj keď metóda nevykonáva globálne vyhľadávanie. V tomto prípade je prvým prvkom poľa nájdený podreťazec a všetky zostávajúce prvky sú subexpresiami regulárneho výrazu.

Metóda Split ()

Táto metóda rozdelí reťazec, pre ktorý sa volá, na pole podreťazcov pomocou argumentu ako oddeľovača. Napríklad:

"123,456,789". Rozdelenie (","); // Vráti ["123", "456", "789"]

Metóda split () môže tiež brať ako argument regulárny výraz. Vďaka tomu je metóda silnejšia.

Objekt RegExp

Konštruktor RegExp () prevezme jeden alebo dva reťazcové argumenty a vytvorí nový objekt RegExp. Prvým argumentom pre konštruktor je reťazec obsahujúci telo regulárneho výrazu, t.j. text, ktorý sa musí nachádzať medzi znakmi lomky v doslovnom tvare regexu. Druhý argument pre RegExp () môže chýbať. Ak je zadaný, definuje vlajky regulárneho výrazu. Musí to byť jeden zo symbolov g, i, m alebo kombináciu týchto znakov.

Vlastnosti RegExp

Každý objekt RegExp má päť vlastností:

• zdroj- reťazec iba na čítanie obsahujúci text regulárneho výrazu.
• globálne- booleovská hodnota iba na čítanie, ktorá určuje prítomnosť príznaku g v regulárnom výraze.
• ignoreCase i v regulárnom výraze.
• viacriadkový Je logická hodnota iba na čítanie, ktorá označuje prítomnosť príznaku m v regulárnom výraze.
• lastIndex Je číslo na čítanie / zápis. Pre šablóny s vlajkou g táto vlastnosť obsahuje číslo pozície v reťazci, na ktorom by malo začať ďalšie vyhľadávanie.

Metódy RegExp

Objekty RegExp definujú dve metódy, ktoré vykonávajú porovnávanie vzorov.

Metóda Exec ()

Metóda exec () vykoná na zadanom reťazci regulárny výraz, t.j. hľadá zhodu v reťazci. Ak sa nenájde žiadna zhoda, metóda vráti hodnotu null. Ak sa však nájde zhoda, vráti rovnaké pole ako pole vrátené metódou match () na vyhľadávanie bez príznaku g.

Nulový prvok poľa obsahuje reťazec, ktorý zodpovedá regulárnemu výrazu, a všetky nasledujúce prvky sú podreťazce, ktoré zodpovedajú všetkým podvýrazom. Na rozdiel od match (), metóda exec () vracia pole, ktorého štruktúra nezávisí od prítomnosti príznaku v regulárnom výraze g.

Keď sa metóda exec () volá druhýkrát pre rovnaký regulárny výraz, začne hľadať znak, ktorého poloha je zadaná vo vlastnosti lastIndex. Ak exec () nenájde zhodu, vlastnosť lastIndex je nastavená na 0.

Testovacia metóda

Vyžaduje reťazec a vráti hodnotu true, ak sa reťazec zhoduje s regulárnym výrazom:

Var vzor = / java / i; vzor.test ("JavaScript"); // Vráti hodnotu true

Volanie test () je ekvivalentom volania exec (), vrátenie hodnoty true, ak exec () vráti hodnotu null. Z tohto dôvodu sa metóda test () pri výzve na zadanie globálneho regulárneho výrazu správa rovnako ako metóda exec (): začne hľadať zadaný reťazec z pozície danej vlastnosťou lastIndex a ak nájde zhodu, nastaví vlastnosť lastIndex na číslo pozície znaku bezprostredne nasledujúceho po zápase.

Písanie predlohy

Vzor regulárneho výrazu pozostáva z regulárnych znakov, ako napríklad / abc /, alebo z kombinácie normálnych a špeciálnych znakov, ako napríklad / ab * c / alebo / Chapter (\ d +) \. \ D * /. Posledný príklad obsahuje zátvorky, ktoré sa používajú ako „pamäťový mechanizmus“. Zhoda pre túto časť šablóny sa zapamätá pre budúce použitie.

Použitie jednoduchých šablón

Na nájdenie priamych zhôd v texte sa používajú jednoduché vzory. Napríklad vzor / abc / zodpovedá kombinácii znakov v reťazci iba vtedy, ak sa „abc“ vyskytuje spoločne a v rovnakom poradí.

Regulárne výrazy ( RegExp) - to je veľmi efektívna metóda práca so strunami.

Vytvorením regulárneho výrazu pomocou vlastnej syntaxe môžete:

• vyhľadávací text v rade
• vymeňte podreťazce v rade
• extrahovať informácie zo struny

Takmer všetky programovacie jazyky majú regulárne výrazy. Existujú malé rozdiely v implementácii, ale všeobecné pojmy platia takmer všade.

Regulárne výrazy sa datujú od päťdesiatych rokov minulého storočia, keď boli formalizované ako koncepčný vzor vyhľadávania pre algoritmy na spracovanie reťazcov.

Regulárne výrazy implementované v systéme UNIX, ako napríklad grep, sed a obľúbené textové editory, začali získavať popularitu a boli pridané do programovacieho jazyka Perl a neskôr do mnohých ďalších jazykov.

JavaScript je spolu s jazykom Perl jedným z programovacích jazykov, v ktorých je podpora regulárnych výrazov integrovaná priamo do jazyka.

Náročné, ale užitočné

Začiatočníkom a často aj profesionálnym vývojárom môže regulárne výrazy pripadať ako absolútny nezmysel, ak neinvestujete čas potrebný na ich porozumenie.

Regulárne výrazy ťažko písať, ťažko čitateľné a náročné na údržbu / zmenu.

Regulárne výrazy však niekedy sú jediný rozumný spôsob vykonávať nejaký druh manipulácie so strunami, takže sú veľmi cenným nástrojom.

Táto príručka je zameraná na maximálne využitie jednoduchým spôsobom trochu porozumie regulárnym výrazom v jazyku JavaScript a poskytne informácie o tom, ako čítať a vytvárať regulárne výrazy.

Platí pravidlo, že jednoduché regulárne výrazy sa ľahko čítajú a píšu, zatiaľ čo Zložité regulárne výrazy sa môžu rýchlo zmeniť na neporiadok ak nerozumieš hlboko základom.

Ako vyzerajú regulárne výrazy

V jazyku JavaScript sú regulárne výrazy objekty, ktoré je možné definovať dvoma spôsobmi.

Prvým spôsobom je vytvárať nový objekt RegExp pomocou konštruktora:

Const re1 = nový RegExp („hej“)

Druhým spôsobom je použitie doslovné výrazy:

Const re1 = / ahoj /

Viete, že JavaScript má objektové literály a maticové literály? Tiež má doslovné výrazy regexp.

V uvedenom prípade je hej nazývaný predloha... V doslovnom tvare je to medzi dvoma lomkami, ale v prípade konštruktora objektu to nie je.

Toto je prvý dôležitý rozdiel medzi týmito dvoma spôsobmi definovania regulárnych výrazov a ostatné uvidíme neskôr.

Ako fungujú?

Regex, ktorý sme definovali vyššie ako re1, je veľmi jednoduchý. Vyhľadá reťazec hej bez akýchkoľvek obmedzení: reťazec môže obsahovať veľa textu, ale slovo hej je niekde uprostred a regulárny výraz bude fungovať. Reťazec môže obsahovať iba slovo hej a štandart bude opäť fungovať.

Je to celkom jednoduché.

Môžete skúsiť otestovať regulárny výraz pomocou metódy RegExp.test (String), ktorá vráti logickú hodnotu:

Re1.test ("hej") // ✅ re1.test ("blablabla hej blablabla") // ✅ re1.test ("on") // ❌ re1.test ("blablabla") // ❌

V príklade vyššie sme len skontrolovali, či sa „hej“ zhoduje so vzorcom regexu uloženým v re1.

Je to jednoduché ako lúskanie hrušiek, ale o regulárnych výrazoch už veľa viete.

Kotvenie

bude fungovať bez ohľadu na to, kde je vnútri reťazca hej.

Ak chcete nájsť riadky, ktoré začínajú hej, použite operátor ^:

/^hey/.test("hey ") // ✅ /^hey/.test("bla hey") // ❌

Ak chcete nájsť riadky končiace hej, použite operátor $:

/hey$/.test("hey ") // ✅ /hey$/.test("bla hey") // ✅ /hey$/.test("hej ty ") // ❌

Skombinovaním predchádzajúcich dvoch tvrdení môžete nájsť riadok, ktorý je úplne rovnaký ako hej:

/^hey$/.test("hey ") // ✅

Ak chcete nájsť reťazec, ktorý začína jedným podreťazcom a končí druhým podreťazcom, môžete použiť. *, Ktorý sa zhoduje s ľubovoľným znakom opakovaným 0 alebo viackrát:

/^hey.*joe$/.test("hey joe ") // ✅ /^hey.*joe$/.test("heyjoe") // ✅ /^hey.*joe$/.test("hey ako sa máš joe ") // ✅ /^hey.*joe$/.test("hey joe!") // ❌

Nájdite položky podľa sortimentu

Namiesto hľadania konkrétneho reťazca môžete zadať rozsah znakov, napríklad:

// // a, b, c, ..., x, y, z // // A, B, C, ..., X, Y, Z // // a, b, c // / / 0, 1, 2, 3, ..., 8, 9

Tieto regulárne výrazy vyhľadávajú reťazce, ktoré obsahujú aspoň jeden znak z vybratého rozsahu:

//.test("a ") // ✅ //.test("1") // ❌ //.test("A ") // ❌ //.test("d") // ❌ // .test ("dc") // ✅

Rozsahy je možné kombinovať:

// //.test("a ") // ✅ //.test("1") // ✅ //.test("A ") // ✅

Nájdenie viacerých zhôd položky rozsahu

Môžete skontrolovať, či reťazec obsahuje iba jeden znak z rozsahu, a to pomocou znaku -:

/^$ //^$/.test("A ") // ✅ /^$/.test("Ab") // ❌

Inverzia šablóny

^ Na začiatku vzoru ho viaže na začiatok riadku.

Použitie tohto znaku v rámci rozsahu invertuje rozsah, takže:

/ [^A-Za-z0-9] /.test("a ") // ❌ / [^A-Za-z0-9> /. Test (" 1 ") // ❌ / [^A-Za -z0-9] /. test ("A") // ❌ /[^A-Za-z0-9] /.test("@ ") // ✅

Metaznaky

• \ d sa zhoduje s ľubovoľným číslom, ekvivalentom k
• \ D sa zhoduje s akýmkoľvek znakom, ktorý nie je číslom, ekvivalentom [^ 0-9]
• \ w sa zhoduje s akýmkoľvek alfanumerickým znakom, ekvivalentom k
• \ W sa zhoduje s akýmkoľvek znakom, ktorý nie je alfanumerickou hodnotou, ekvivalentnou k [^ A-Za-z0-9]
• \ s sa zhoduje s ľubovoľným prázdnym znakom: medzera, tabulátor, nový riadok a medzery Unicode
• \ S sa zhoduje s akýmkoľvek znakom, ktorý nie je medzerou
• \ 0 zodpovedá nule
• \ n zodpovedá znaku nového riadka
• \ t zodpovedá znaku karty
• \ uXXXX sa zhoduje so znakom Unicode XXXX (vyžaduje sa príznak u)
• ... zhoduje sa s akýmkoľvek znakom iným ako znakom nového riadka (napríklad \ n) (pokiaľ nepoužívate príznak s, vysvetlite neskôr)
• [^] zodpovedá ľubovoľnému znaku vrátane znaku nového riadka. Užitočné pri práci s viacriadkovými reťazcami

Výber regulárneho výrazu

Ak si chcete jeden vybrať alebo iný riadok, použite | ...

/hey|ho/.test("hey ") // ✅ /hey|ho/.test("ho") // ✅

Kvantifikátory

Predstavte si, že máte regulárny výraz, ktorý kontroluje reťazec, aby sa ubezpečil, že obsahuje iba jednu číslicu:

môžeš použiť kvantifikátor? vďaka čomu bude tento znak voliteľný. V našom prípade sa číslica musí vyskytnúť 0 alebo 1 krát:

ale čo keď chceme, aby sa regulárny výraz zhodoval s viacerými číslicami?

Môžete to urobiť 4 spôsobmi pomocou +, *, (n) a (n, m).

+

Zhoduje sa s jedným alebo viacerými (> = 1) prvkami:

/^\ d+$ //^\d+$/.test("12 ") // ✅ /^\d+$/.test("14") // ✅ /^\d+$/.test("144343 ") // ✅ / ^ \ d + $ /. Test (" ") // ❌ /^\d+$/.test("1a") // ❌

*

Zhoduje sa s 0 alebo viacerými (> = 0) prvkami:

/ ^ \ d + $ //^\d*$/.test("12 ") // ✅ /^\d*$/.test("14") // ✅ / ^ \ d*$ /. test ("144343") // ✅ / ^ \ d * $ /. Test ("") // ✅ /^\d*$/.test("1a ") // ❌

n)

Presne zodpovedá n počtu prvkov:

/ ^ \ d (3) $ //^\d(3)$/.test("123 ") // ✅ /^\d(3)$/.test("12") // ❌ / ^ \ d (3) $ /. test ("1234") // ❌ /^(3)$/.test("Abc ") // ✅

(n, m)

Zhoduje sa s rozsahom n až m prvkov:

/^\ d (3,5) $ //^\d(3,5)$/.test("123 ") // ✅ /^\d(3,5)$/.test("1234") // ✅ /^\d(3,5)$/.test("12345 ") // ✅ /^\d(3,5)$/.test("123456") // ❌

m možno vynechať a druhý limit nechať neobmedzený, aby bolo aspoň n prvkov:

/^\ d (3,) $ //^\d(3,)$/.test("12 ") // ❌ /^\d(3,)$/.test("123") // ✅ /^\d(3,)$/.test("12345 ") // ✅ /^\d(3,)$/.test("123456789")) // ✅

Voliteľné položky

Znamenie nasledujúce za živlom? , urobí to voliteľným:

/ ^ \ d (3) \ w? $ / /^\d(3)\w?$/.test("123 ") // ✅ / ^ \ d (3) \ w? $ /. test (" 123a ") // ✅ /^\d(3)\w?$/.test("123ab") // ❌

Skupiny

Použitím zátvoriek môžete vytvárať skupiny znakov (...).

Nasledujúci príklad hľadá presnú trojcifernú zhodu, za ktorou nasleduje jeden alebo viac alfanumerických znakov:

/ ^ (\ d (3)) (\ w +) $ / /^(\d(3))(\w+)$/.test("123 ") // ❌ / ^ (\ d (3)) (\ w +) $ /. test ("123 s") // ✅ /^(\d(3))(\w+)$/.test("123something ") // ✅ / ^ (\ d (3) ) (\ w +) $ /. test ("1234") // ✅

Duplicitné znaky, ktoré sa zobrazujú za zátvorkami na konci skupiny, sa vzťahujú na celú skupinu:

/ ^ (\ d (2)) + $ / /^(\d(2))+$/.test("12 ") // ✅ / ^ (\ d (2)) + $ /. test (" 123 ") // ❌ /^(\d(2))+$/.test("1234") // ✅

Zachytávanie skupín

Doteraz sme videli, ako je možné testovať reťazce a kontrolovať, či obsahujú konkrétny vzor.

Na regulárnych výrazoch je skvelé to, že môžete uchopte konkrétne časti reťazca a pridajte ich do poľa.

Môžete to urobiť so skupinami, konkrétnejšie s zajatecké skupiny.

Skupiny sú už predvolene zachytené. Teraz namiesto použitia RegExp.test (String), ktorý jednoducho vráti logickú hodnotu, použijeme jednu z nasledujúcich metód:

• String.match (RegExp)
• RegExp.exec (reťazec)

Sú úplne rovnaké a obe vracajú pole s reťazcom, ktorý je kontrolovaný ako prvý prvok, a zvyšné prvky sa zhodujú pre každú nájdenú skupinu.

Ak sa nenájde žiadna zhoda, vráti hodnotu null.

"123s" .match ( / ^ (\ d (3)) (\ w +) $ /) // Pole ["123s", "123", "123s"] / ^ (\ d (3)) (\ w +) $ /. exec ("123s") // Array ["123s", "123", "s"] "hey" .match ( /(hey | ho) /) // Array ["hey", "hej"] /(hey|ho)/.exec("hey ") // Array [" hej "," hej "] /(heyhohohoho)/.exec("ha!") // null

Keď sa skupina viackrát zhoduje, do vráteného poľa sa pridá iba posledná nájdená hodnota.

"123456789" .zhoda ( / (\ d) + /) // pole ["123456789", "9"]

Voliteľné skupiny

Zachytávanie skupín môže byť voliteľné pomocou (...)? ... Ak sa nič nenájde, do vráteného poľa sa pridá nedefinovaný prvok:

/^(\d(3))(\s)?(\w+)$/.exec("123 s ") // Array [" 123 s "," 123 "," "," s "] / ^ (\ d (3)) (\ s)? (\ w +) $ /. exec ("123s") // Pole ["123s", "123", undefined, "s"]

Odkaz na nájdenú skupinu

Každá nájdená skupina má priradené číslo. 1 dolár sa vzťahuje na prvý prvok, 2 doláre na druhý a podobne. Je to užitočné, keď hovoríme o nahradení časti reťazca.

Pomenované skupinové zajatie

to nová príležitosť ES2018.

Skupine môže byť priradený názov, nielen slot vo vrátenom poli:

Const re = / (? \ d (4)) - (? \ d (2)) - (? \ d (2)) / const result = re.exec ("2015-01-02") // result.groups.year === "2015"; // result.groups.month === "01"; // result.groups.day === "02";

Používanie zhody a spustenia bez skupín

Existuje rozdiel pri použití zhody a spustenia bez skupín: prvý prvok poľa nebude obsahovať úplne nájdený reťazec, ale priamu zhodu:

/hey|ho/.exec("hey ") // [" hej "] /(hey).(ho)/.exec("hey ho") // ["hej ho", "hej", "ho "]

Nezachytené skupiny

Pretože skupiny štandardne zachytávajú, potrebujeme spôsob, ako ignorovať niektoré skupiny vo vrátenom poli. To je možné s neobsadené skupiny ktoré začínajú na (?: ...).

"123s" .match (/ ^ (\ d (3)) (?: \ S) (\ w +) $/) // null "123 s" .match (/ ^ (\ d (3)) (? : \ s) (\ w +) $ /) // Pole ["123 s", "123", "s"]

Vlajky

Nasledujúce príznaky môžete použiť v ľubovoľnom regulárnom výraze:

• g: hľadá zápasy globálne
• i: robí písmena regexu necitlivými
• m: zapne viacriadkový režim. V tomto režime ^ a $ zodpovedajú začiatku a koncu celého riadka. Bez tohto príznaku sa s viacriadkovými riadkami zhodujú so začiatkom a koncom každého riadka.
• u: obsahuje podporu Unicode (pridané v ES6 / ES2015)
• s: (novinka v ES2018) skratka pre „jednoriadkový“, umožňuje. porovnávať nové riadky

Vlajky je možné kombinovať a pripájajú sa tiež na koniec doslovného riadku:

/hey/ig.test("HEy ") // ✅

alebo odovzdané ako druhý parameter konštruktoru objektu RegExp:

Nový RegExp („hej“, „ig“). Test („Hej“) // ✅

Kontrola regulárnych výrazov

Môžete skontrolovať vlastnosti regulárnych výrazov:

• zdroj - reťazec šablóny
• viacriadkový - true, ak je nastavený príznak m
• global - true, ak je nastavený príznak g
• ignoreCase - true, ak je nastavený príznak i
• lastIndex

Tienenie

Špeciálne symboly:

Jedná sa o špeciálne znaky, pretože sú to kontrolné znaky pri vytváraní vzorov regulárnych výrazov, takže ak ich chcete použiť na nájdenie zhody v rámci vzoru, musíte im uniknúť so spätným lomítkom:

Hranice čiar

\ b a \ B vám umožňujú určiť, či je reťazec na začiatku alebo na konci slova:

• \ b sa zhoduje, ak je sada znakov na začiatku alebo na konci slova
• \ B sa zhoduje, ak znaková sada nie je na začiatku alebo na konci slova

„Videl som medveďa“ .zhoda ( / \ bbear /) // Pole [„medveď“] „Videl som bradu“ .zhoda ( / \ bbear /) // Pole [„medveď“] „Videl som bradu“ .match ( / \ bbear \ b /) // null "cool_bear" .match ( / \ bbear \ b /) // null

Nahradenie regulárnymi výrazmi

Už sme videli, ako skontrolovať struny na zhodu so vzorom.

Tiež sme videli, ako môžete extrahovať niektoré reťazce zodpovedajúce vzoru do poľa.

Teraz sa pozrime ako nahradiť časti reťazca podľa predlohy.

Objekt reťazca JavaScript má metódu replace (), ktorú je možné použiť bez regulárneho výrazu jedna náhrada v rade:

„Hello world!“. Replace („world“, „dog“) // Hello dog! „Môj pes je dobrý pes!“. Nahradiť („pes“, „mačka“) // Moja mačka je dobrý pes!

Táto metóda môže tiež prijať regulárny výraz ako argument:

„Hello world!“. Replace ( / world /, „dog“) // Hello dog!

Použitie príznaku g je jediná cesta nahraďte viac výskytov v reťazci vanilkovým JavaScriptom:

„Môj pes je dobrý pes!“. Nahradiť ( / pes / g, „mačka“) // Moja mačka je dobrá mačka!

Skupiny nám umožňujú robiť vymyslenejšie veci tým, že si vymeníme časti riadkov:

„Ahoj, svet!". Nahradiť ( / (\ w +), (\ w +)! /, „$ 2: $ 1 !!!“) // „svet: Ahoj !!!“

Namiesto reťazca môžete pomocou funkcie robiť ešte zaujímavejšie veci. Bude doňho odoslaných niekoľko argumentov, napríklad návratové metódy String.match (RegExp) alebo RegExp.exec (String), kde počet argumentov závisí od počtu skupín:

„Ahoj, svet!“. Nahradiť ( / (\ w +), (\ w +)! /, (MatchedString, first, second) => (console.log (first); console.log (second); return ` $ (second.toUpperCase ()): $ (first) !!! `)) //" WORLD: Hello !!! "

Chamtivosť

Regulárne výrazy sa nazývajú chamtivý predvolené.

Čo to znamená?

Vezmite si napríklad tento regulárny výraz:

/\$(.+)\s?/

Máme údajne vyťažiť dolárovú čiastku z reťazca:

/\$(.+)\s?/.exec("To stojí 100 dolárov ") // 0

ale čo keď máme za číslom viac slov, je to rušivé

/\$(.+)\s?/.exec("To stojí 100 dolárov a je to menej ako 200 dolárov ") // 100 a je to menej ako 200 dolárov

Prečo? Pretože regex za znakom $ sa zhoduje s ľubovoľným znakom. + A neprestane, kým nedosiahne koniec riadka. Potom sa to zastaví, pretože? robí koncový priestor voliteľným.

Aby sme to vyriešili, musíme zadať, že by mal byť regex lenivý a nájdite najmenší počet zhôd. Dokážeme to pomocou symbolu? za kvantifikátorom:

/\$(.+?)\s/.exec("To stojí 100 dolárov a je to menej ako 200 dolárov ") // 100

Takže symbol? môže to znamenať rôzne veci v závislosti od jeho polohy, takže to môže byť kvantifikátor aj indikátor lenivý režimu.

Vpredu: Priraďte reťazec podľa toho, čo nasleduje

Použiť? = Na priradenie reťazca, za ktorým nasleduje konkrétny podreťazec

/ Roger (? = Vody) / / Roger (? = Vody) /. Test („Roger je môj pes“) // nepravda / Roger (? = Vody) /. Test („Roger je môj pes a Roger Waters je slávny hudobník “) // pravda

Vykoná reverznú operáciu a vyhľadá zhody v reťazci, za ktorým nasleduje nie za ktorým nasleduje konkrétny podreťazec:

/ Roger (?! Waters) / / Roger (?! Waters) /. Test („Roger is my dog“) // true / Roger (?! Waters) /. Test („Roger je môj pes a Roger Waters je slávny hudobník “) // false

Retrospektíva: priradenie reťazca v závislosti od toho, čo mu predchádza

Toto je nová funkcia v ES2018.

Lookahead používa symbol? =. Spätné použitie?<= :

/(?<=Roger) Waters/ /(?<=Roger) Waters/.test("Pink Waters is my dog") //false /(?<=Roger) Waters/.test("Roger is my dog and Roger Waters is a famous musician") //true

Využíva inverzia retrospektívy?

/(?

Regulárne výrazy a Unicode

Príznak u je povinný pri práci s reťazcami Unicode, najmä vtedy, keď možno budete potrebovať spracovať reťazce v astrálnych rovinách, ktoré nie sú zahrnuté v prvých 1 600 znakoch Unicode.

Napríklad emodži, ale iba oni.

/^.$/.test("a ") // ✅ /^.$/. test ("? ") // ❌ /^.$/ u.test ("? ") // ✅

Preto vždy používajte príznak u.

Unicode, podobne ako bežné znaky, dokáže spracovať rozsahy:

//.test("a ") // ✅ //.test("1") // ✅ / [? -?] / u.test ("?") // ✅ / [? -?] / u .test ("?") // ❌

Prečo JavaScript kontroluje kódy interného zobrazenia?< ? < ? на самом деле \u1F436 < \u1F43A < \u1F98A . Посмотрите полный список эмодзи чтобы увидеть коды и узнать их порядок.

Unikajúce vlastnosti Unicode

Ako sme už povedali vyššie, v regexovom vzore môžete použiť \ d na priradenie akejkoľvek číslice, \ s na priradenie akéhokoľvek znaku iného ako medzeru, \ w na priradenie ľubovoľného alfanumerického znaku atď.

Unikanie vlastností Unicode je funkcia ES2018, ktorá dodáva veľmi efektívnu funkciu rozšírením tohto konceptu na všetky znaky Unicode a pridaním \ p () a \ P ().

Akýkoľvek znak Unicode má sadu vlastností. Napríklad Script definuje rodinu jazykov, ASCII je logická hodnota rovnaká ako true pre znaky ASCII atď. Túto vlastnosť môžete uzavrieť do zložených zátvoriek a regex skontroluje, či je jej hodnota pravdivá:

/^\p(ASCII)+$/u.test("abc ") // ✅ / ^ \ p (ASCII) + $ / u.test (" [chránené e -mailom]") // ✅ /^\p(ASCII)+$/u.test("ABC?") // ❌

ASCII_Hex_Digit je ďalšou booleovskou vlastnosťou, ktorá kontroluje, či reťazec obsahuje iba platné hexadecimálne číslice:

/^\p(ASCII_Hex_Digit)+$/u.test("0123456789ABCDEF ") // ✅ /^\p(ASCII_Hex_Digit)+$/u.test("h")

Existuje mnoho ďalších booleovských vlastností, ktoré môžete otestovať jednoduchým pridaním ich názvu do zložených zátvoriek, vrátane veľkých, malých písmen, White_Space, abecedných, emoji a ďalších:

/^\p(Dolní kufr)$/u.test("h ") // ✅ /^\p(Uppercase)$/u.test("H") // ✅ /^\ p (Emoji) + $ / u.test ("H") // ❌ / ^ \ p (Emoji) + $ / u.test ("??") // ✅

Okrem týchto binárnych vlastností môžete skontrolovať aj ľubovoľnú vlastnosť znakov Unicode, aby zodpovedala konkrétnej hodnote. V nižšie uvedenom príklade skontrolujem, či je reťazec napísaný v gréckej alebo latinskej abecede:

/^\p(Script=Greek)+$/u.test("ελληνικά ") // ✅ /^\p(Script=Latin)+$/u.test("hey") // ✅

Príklady

Extrahovanie čísla z reťazca

Predpokladajme, že existuje reťazec obsahujúci iba jedno číslo, ktoré sa má načítať. / \ d + / by mal urobiť toto:

"Test 123123329" .zhoda ( / \ d + /) // pole ["123123329"]

Hľadať e-mailovú adresu:

Najjednoduchším prístupom je skontrolovať znaky, ktoré nie sú prázdne, pred a za znakom @ pomocou \ S:

/(\S+)@(\S+)\.(\S+)/ / (\ S +) @ (\ S +) \. (\ S +) /. Exec (" [chránené e -mailom]") //["[chránené e -mailom]"," copesc "," gmail "," com "]

Toto je však zjednodušený príklad, pretože pod neho spadá mnoho neplatných e-mailových adries.

Zachytávanie textu medzi úvodzovkami

Predpokladajme, že máte reťazec obsahujúci text uzavretý do dvojitých úvodzoviek a tento text musíte extrahovať.

Najlepším spôsobom, ako to urobiť, je použiť zabavenie skupín pretože vieme, že náš zápas musí začínať a končiť na „, takže môžeme ľahko prispôsobiť vzorec, ale tiež chceme tieto úvodzovky z výsledku odstrániť.

Vo výsledku zistíme, čo potrebujeme:

Const ahoj = "Ahoj" pekný kvet "" const výsledok = /"((^"">*)"/.exec(hello) // Pole ["\" pekný kvet \ "", "pekný kvet"]

Získavanie obsahu zo značky HTML

Môžete napríklad získať obsah zo značky span a súčasne pre značku povoliť ľubovoľný počet argumentov:

/]*>(.*?)<\/span>/ /]*>(.*?)<\/span>/.exec("test ") // null / ]*>(.*?)<\/span>/.exec("test ") // [" test "," test "] / ]*>(.*?)<\/span>/.exec (" test") // ["test"," test "]