Js regulāro izteiksmju telpa. Regulāras izteiksmes. Izmantojot spēli un izpildītāju bez grupām

Regulāras izteiksmes

Regulārā izteiksme ir objekts, kas apraksta rakstzīmju modeli. RegExp klase JavaScript apzīmē regulāras izteiksmes, un klases String un RegExp objekti definē metodes, kas izmanto regulārās izteiksmes, lai veiktu rakstu saskaņošanas un teksta meklēšanas un aizstāšanas darbības. JavaScript regulāro izteiksmju gramatika satur diezgan pilnīgu Perl 5 lietotās regulārās izteiksmes sintakses apakškopu, tāpēc, ja jums ir pieredze darbā ar Perl, varat viegli rakstīt modeļus JavaScript programmās.

Perl regulāro izteiksmju līdzekļi, kas netiek atbalstīti ECMAScript, ietver karogus s (vienas rindas režīms) un x (paplašinātā sintakse); atkāpšanās secības \a, \e, \l, \u, \L, \U, \E, \Q, \A, \Z, \z un \G un citas paplašinātas konstrukcijas, kas sākas ar (?.

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ā virkņu literāļi tiek norādīti kā rakstzīmes, ko ieskauj pēdiņas, regulārās izteiksmes literāļi tiek norādīti kā rakstzīmes, kuras ieskauj slīpsvītru rakstzīmju pāris (/). Tātad jūsu JavaScript kodā var būt šādas rindas:

Var modelis = /s$/;

Šī rinda izveido jaunu RegExp objektu un piešķir to modeļa mainīgajam. Šis RegExp objekts meklē visas virknes, kas beidzas ar "s" rakstzīmi. To pašu regulāro izteiksmi var definēt, izmantojot RegExp() konstruktoru:

Var modelis = new RegExp("s$");

Regulārās izteiksmes modeļa specifikācija sastāv no rakstzīmju secības. Lielākā daļa rakstzīmju, tostarp visas burtciparu rakstzīmes, burtiski apraksta rakstzīmes, kurām jābūt klāt. Tas nozīmē, ka regulārā izteiksme /java/ atbilst visām rindām, kas satur apakšvirkni “java”.

Citas rakstzīmes regulārajās izteiksmēs nav paredzētas, lai atrastu to precīzus ekvivalentus, bet tām ir īpaša nozīme. Piemēram, regulārajā izteiksmē /s$/ ir divas rakstzīmes. Pirmā rakstzīme s apzīmē burtiskas rakstzīmes meklēšanu. Otrkārt, $ ir īpaša metarakstzīme, kas iezīmē rindas beigas. Tātad šī regulārā izteiksme atbilst jebkurai virknei, kas beidzas ar rakstzīmi s.

Nākamajās sadaļās ir aprakstītas dažādas rakstzīmes un metarakstzīmes, kas tiek izmantotas JavaScript regulārajās izteiksmēs.

Kā minēts iepriekš, visas alfabēta rakstzīmes un cipari regulārajās izteiksmēs sakrīt. Regulārās izteiksmes sintakse JavaScript atbalsta arī iespēju norādīt noteiktas rakstzīmes, kas nav alfabētiskas, izmantojot atsoļa secības, kas sākas ar slīpsvītru (\). Piemēram, secība \n atbilst jaunās rindas rakstzīmei. Šie simboli ir norādīti tabulā:

Dažām pieturzīmēm regulārajās izteiksmēs ir īpaša nozīme:

^ $ . * + ? = ! : | \ / () { } -

Šo simbolu nozīme ir izskaidrota nākamajās sadaļās. Dažiem no tiem ir īpaša nozīme tikai noteiktos regulāro izteiksmju kontekstos, savukārt citos kontekstos tie tiek interpretēti burtiski. Tomēr parasti, lai burtiski iekļautu kādu no šīm rakstzīmēm regulārajā izteiksmē, pirms tās ir jāievieto slīpsvītra. Citām rakstzīmēm, piemēram, pēdiņām un @, nav īpašas nozīmes, un tās vienkārši atbilst regulārās izteiksmēs.

Ja nevarat precīzi atcerēties, pirms kurām rakstzīmēm ir jābūt \, varat droši ievietot atpakaļvērstās slīpsvītru jebkuras rakstzīmes priekšā. Tomēr ņemiet vērā, ka daudziem burtiem un cipariem ir īpaša nozīme, ja tie tiek apvienoti ar slīpsvītru, tāpēc burtiem un cipariem, kurus meklējat burtiski, pirms rakstzīmes \ nevajadzētu būt. Lai regulārajā izteiksmē iekļautu pašu atpakaļvērstās slīpsvītras rakstzīmi, pirms tās noteikti ir jāievada cita atpakaļsvītras rakstzīme. Piemēram, šī regulārā izteiksme atbilst jebkurai virknei, kurā ir slīpsvītra rakstzīme: /\\/.

Atsevišķas burtiskās rakstzīmes var apvienot rakstzīmju klasēs, ievietojot tās kvadrātiekavās. Rakstzīmju klase atbilst jebkurai šajā klasē esošajai rakstzīmei. Tāpēc regulārā izteiksme // atbilst vienai no rakstzīmēm a, b vai c.

Negatīvo rakstzīmju klases var arī definēt, lai tās atbilstu jebkurai rakstzīmei, izņemot tās, kas norādītas iekavās. Nolieguma rakstzīmju klasi norāda rakstzīme ^ kā pirmā rakstzīme aiz kreisās iekavas. Regulārā izteiksme /[^abc]/ atbilst jebkurai rakstzīmei, izņemot a, b vai c. Rakstzīmju klasēs rakstzīmju diapazonu var norādīt, izmantojot defisi. Visas mazās latīņu rakstzīmes tiek atrastas, izmantojot izteiksmi //, un jebkuru burtu vai ciparu no latīņu rakstzīmju kopas var atrast, izmantojot izteiksmi //.

Dažas rakstzīmju klases ir īpaši izplatītas, tāpēc JavaScript regulārās izteiksmes sintakse ietver speciālās rakstzīmes un atsoļa secības, lai tās attēlotu. Tādējādi \s atbilst atstarpes, tabulēšanas un jebkuras Unikoda atstarpes rakstzīmes, un \S atbilst visām ārpus Unikoda atstarpes rakstzīmēm.

Tālāk esošajā tabulā ir sniegts šo īpašo rakstzīmju saraksts un rakstzīmju klašu sintakse. (Ņemiet vērā, ka dažas rakstzīmju klases atsoļa secības atbilst tikai ASCII rakstzīmēm un nav paplašinātas, lai strādātu ar unikoda rakstzīmēm. Varat skaidri definēt savas unikoda rakstzīmju klases, piemēram, /[\u0400-\u04FF]/ atbilst jebkurai rakstzīmei kirilicas alfabētam. .)

Ņemiet vērā, ka klases īpašo rakstzīmju atsoļu secības var ievietot kvadrātiekavās. \s atbilst jebkurai atstarpes rakstzīmei un \d atbilst jebkuram ciparam, līdz ar to /[\s\d]/ atbilst jebkurai atstarpes rakstzīmei vai ciparam.

Ņemot vērā līdz šim iegūtās zināšanas par regulārās izteiksmes sintaksi, mēs varam aprakstīt divciparu skaitli kā /\d\d/ vai četrciparu skaitli kā /\d\d\d\d/, bet nevaram, piemēram, , aprakstiet skaitli, kas sastāv no jebkura ciparu skaita vai trīs burtu virknes, kam seko neobligāts cipars. Šajos sarežģītākajos modeļos tiek izmantota regulārās izteiksmes sintakse, kas norāda, cik reižu doto regulārās izteiksmes elementu var atkārtot.

Atkārtotie simboli vienmēr seko modelim, kuram tie tiek piemēroti. Daži atkārtojumu veidi tiek izmantoti diezgan bieži, un ir pieejami īpaši simboli, kas norāda uz šiem gadījumiem. Piemēram, + atbilst vienam vai vairākiem iepriekšējā modeļa gadījumiem. Šajā tabulā ir sniegts atkārtojuma sintakses kopsavilkums:

Šajās rindās ir parādīti vairāki piemēri:

Var modelis = /\d(2,4)/; // Atbilst skaitlim, kas sastāv no diviem līdz četriem cipariem = /\w(3)\d?/; // Precīzi sakrīt trīs vārda rakstzīmes un viens neobligāts ciparu raksts = /\s+java\s+/; // Atbilst vārdam "java" ar vienu vai vairākām atstarpēm // pirms un pēc tā modelis = /[^(]*/; // Atbilst nullei vai vairākām rakstzīmēm, izņemot sākuma iekavas

Esiet piesardzīgs, lietojot atkārtojošas rakstzīmes * un ?. Tie var atbilst pirms tiem norādītā modeļa trūkumam un līdz ar to rakstzīmju trūkumam. Piemēram, regulārā izteiksme /a*/ atbilst virknei "bbbb", jo tajā nav rakstzīmes a.

Tabulā norādītās atkārtojumu rakstzīmes atspoguļo maksimālo iespējamo atkārtojumu skaitu, kas ļaus saskaņot nākamās regulārās izteiksmes daļas. Mēs sakām, ka tā ir mantkārīga atkārtošana. Ir iespējams arī īstenot atkārtojumu, kas tiek veikts ne mantkārīgā veidā. Pietiek norādīt jautājuma zīmi aiz atkārtojuma simbola (vai simboliem): ??, +?, *? vai pat (1,5)?.

Piemēram, regulārā izteiksme /a+/ atbilst vienam vai vairākiem burta a gadījumiem. Attiecas uz virkni "aaa", tas atbilst visiem trim burtiem. No otras puses, izteiksme /a+?/ atbilst vienam vai vairākiem burta a gadījumiem un atlasa mazāko iespējamo rakstzīmju skaitu. Piemērots tai pašai virknei, šis raksts atbilst tikai pirmajam burtam a.

“Nemantkārīga” atkārtošana ne vienmēr dod gaidīto rezultātu. Apsveriet modeli /a+b/, kas atbilst vienam vai vairākiem burtiem a, kam seko burts b. Lietojot virknei "aaab", tā atbilst visai virknei.

Tagad pārbaudīsim /a+?b/ "ne-mantkārīgo" versiju. Varētu domāt, ka tas atbilstu b, pirms kura ir tikai viens a. Ja tiek lietota viena un tā pati virkne, "aaab" ir jāatbilst vienai rakstzīmei a un pēdējai rakstzīmei b. Tomēr šis modelis faktiski atbilst visai virknei, tāpat kā mantkārīgā versija. Fakts ir tāds, ka regulārās izteiksmes modeļa meklēšana tiek veikta, atrodot pirmo pozīciju virknē, no kuras sākas atbilstība. Tā kā atbilstība ir iespējama, sākot no virknes pirmās rakstzīmes, īsākas atbilstības, kas sākas no nākamajām rakstzīmēm, pat netiek ņemtas vērā.

Regulāro izteiksmju gramatika ietver speciālās rakstzīmes alternatīvu definēšanai, apakšizteikumu grupēšanai un atsaucēm uz iepriekšējām apakšizteiksmēm. Caurules simbols | kalpo alternatīvu atdalīšanai. Piemēram, /ab|cd|ef/ atbilst vai nu virknei "ab", vai virknei "cd", vai virknei "ef", un modelis /\d(3)|(4)/ atbilst vai nu trīs cipariem. vai četri mazie burti .

Ņemiet vērā, ka alternatīvas tiek apstrādātas no kreisās puses uz labo, līdz tiek atrasta atbilstība. Ja tiek atrasta atbilstība ar kreiso alternatīvu, labā tiek ignorēta, pat ja var panākt “labāku” atbilstību. Tāpēc, kad raksts /a|ab/ tiek lietots virknei "ab", tas atbildīs tikai pirmajai rakstzīmei.

Regulārajās izteiksmēs iekavām ir vairākas nozīmes. Viens no tiem ir atsevišķu elementu grupēšana vienā apakšizteiksmē, lai elementi, izmantojot speciālās rakstzīmes |, *, +, ? un citi tiek uzskatīti par vienu veselumu. Piemēram, raksts /java(script)?/ atbilst vārdam "java", kam seko izvēles vārds "script", un /(ab|cd)+|ef)/ atbilst virknei "ef" vai vienam vai vairākiem. viena atkārtojumi no stīgām "ab" vai "cd".

Cits iekavas lietojums regulārajās izteiksmēs ir apakšrakstu definēšana paraugā. Ja mērķa virknē tiek atrasta regulārās izteiksmes atbilstība, var izvilkt to mērķa virknes daļu, kas atbilst jebkuram noteiktam iekavās ievietotam apakšparaugam.

Pieņemsim, ka vēlaties atrast vienu vai vairākus mazos burtus, kam seko viens vai vairāki cipari. Lai to izdarītu, varat izmantot veidni /+\d+/. Bet pieņemsim arī, ka mēs vēlamies tikai skaitļus katra mača beigās. Ja šo raksta daļu ievietojam iekavās (/+(\d+)/), mēs varam iegūt skaitļus no visām atrastajām atbilstībām. Kā tas tiek darīts, tiks aprakstīts tālāk.

Saistīts iekavas apakšizteiksmju lietojums ir atsauce uz apakšizteiksmēm no tās pašas regulārās izteiksmes iepriekšējās daļas. Tas tiek panākts, norādot vienu vai vairākus ciparus aiz rakstzīmes \. Skaitļi attiecas uz iekavās ievietotās apakšizteiksmes pozīciju regulārajā izteiksmē. Piemēram, \1 attiecas uz pirmo apakšizteiksmi, un \3 attiecas uz trešo. Ņemiet vērā, ka apakšizteiksmes var būt ligzdotas cita citā, tāpēc skaitīšanai tiek izmantota kreisās iekavas pozīcija. Piemēram, šajā regulārajā izteiksmē ligzdotas apakšizteiksmes (kripta) atsauce izskatītos šādi: \2:

/(ava(cript)?)\sis\s(fun\w*)/

Atsauce uz iepriekšējo apakšizteiksmi nenorāda uz šīs apakšizteiksmes modeli, bet gan uz atrasto tekstu, kas atbilst šim modelim. Tāpēc atsauces var izmantot, lai uzliktu ierobežojumu, kas atlasa virknes daļas, kurās ir tieši tādas pašas rakstzīmes. Piemēram, šī regulārā izteiksme atbilst nullei vai vairāk rakstzīmēm vienpēdiņās vai dubultpēdiņās. Tomēr tas neprasa, lai sākuma un beigu pēdiņas atbilstu viena otrai (tas ir, lai abas pēdiņas būtu vienas vai dubultas):

/[""][^""]*[""]/

Mēs varam pieprasīt, lai pēdiņas atbilstu, izmantojot šādu atsauci:

Šeit \1 atbilst pirmajai apakšizteiksmei. Šajā piemērā saite uzliek ierobežojumu, kas nosaka, ka beigu pēdiņai jāatbilst sākuma pēdiņai. Šī regulārā izteiksme nepieļauj vienas pēdiņas dubultpēdiņās un otrādi.

Ir iespējams arī grupēt elementus regulārā izteiksmē, neveidojot numurētas atsauces uz šiem elementiem. Tā vietā, lai vienkārši grupētu elementus starp ( un ), sāciet grupu ar simboliem (?: un beidziet ar simbolu). Apsveriet, piemēram, šādu modeli:

/(ava(?:cript)?)\sis\s(fun\w*)/

Šeit apakšizteiksme (?:cript) ir nepieciešama tikai grupēšanai, lai grupai varētu lietot atkārtojuma rakstzīmi ?. Šīs modificētās iekavas neveido saiti, tāpēc šajā regulārajā izteiksmē \2 attiecas uz tekstu, kas atbilst paraugam (fun\w*).

Šajā tabulā ir uzskaitīti atlases, grupēšanas un atsauces operatori regulārajās izteiksmēs:

Kā aprakstīts iepriekš, daudzi regulārās izteiksmes elementi atbilst vienai virknes rakstzīmei. Piemēram, \s atbilst vienai atstarpes rakstzīmei. Citi regulārās izteiksmes elementi atbilst pozīcijām starp rakstzīmēm, nevis pašām rakstzīmēm. Piemēram, \b atbilst vārda robežai — robežai starp \w (ASCII teksta rakstzīme) un \W (kas nav teksta rakstzīme) vai robežai starp ASCII teksta rakstzīmi un rindas sākumu vai beigām.

Tādi elementi kā \b nenorāda nekādas rakstzīmes, kurām jāatrodas saskaņotajā virknē, taču tie norāda derīgas pozīcijas saskaņošanai. Šos elementus dažreiz sauc par regulārās izteiksmes enkura elementiem, jo ​​tie noenkuro modeli noteiktā virknes vietā. Visbiežāk izmantotie enkura elementi ir ^ un $, kas saista modeļus attiecīgi ar rindas sākumu un beigām.

Piemēram, vārdu “JavaScript” savā rindā var atrast, izmantojot regulāro izteiksmi /^JavaScript$/. Lai atrastu vienu vārdu “Java” (nevis prefiksu, piemēram, “JavaScript”), varat mēģināt izmantot modeli /\sJava\s/, kurā pirms un pēc vārda ir nepieciešama atstarpe.

Taču šāds risinājums rada divas problēmas. Pirmkārt, tas atradīs vārdu "Java" tikai tad, ja to abās pusēs ieskauj atstarpes, un nevarēs to atrast rindas sākumā vai beigās. Otrkārt, ja šis modelis sakrīt, tā atgrieztajā virknē būs sākuma un beigu atstarpes, kas nav tieši tas, ko mēs vēlamies. Tāpēc tā vietā, lai izmantotu paraugu, kas atbilst atstarpes rakstzīmēm \s, mēs izmantosim modeli (vai enkuru), kas atbilst vārdu robežām \b. Rezultāts būs šāda izteiksme: /\bJava\b/.

Enkura elements \B atbilst pozīcijai, kas nav vārda robeža. Tas nozīmē, ka paraugs /\Bcript/ atbildīs vārdiem “JavaScript” un “postscript” un neatbildīs vārdiem “skripts” vai “Skriptēšana”.

Patvaļīgas regulāras izteiksmes var kalpot arī kā enkura nosacījumi. Ja ievietojat izteiksmi starp rakstzīmēm (?= un), tā kļūst par uz priekšu vērstu atbilstības testu pret nākamajām rakstzīmēm, pieprasot, lai šīs rakstzīmes atbilstu norādītajam modelim, bet tās nedrīkst iekļaut atbilstības virknē.

Piemēram, lai atbilstu parastas programmēšanas valodas nosaukumam, kam seko kols, varat izmantot izteiksmi /ava(cript)?(?=\:)/. Šis raksts atbilst vārdam “JavaScript” virknē “JavaScript: The Definitive Guide”, taču tas neatbilst vārdam “Java” virknē “Java in a Nutshell”, jo tam neseko kols.

Ja ievadīsit nosacījumu (?!), tā būs negatīva pārsūtīšanas pārbaude nākamajām rakstzīmēm, pieprasot, lai tālāk norādītās rakstzīmes neatbilst norādītajam modelim. Piemēram, modelis /Java(?!Script)(\w* )/ atbilst apakšvirknei “Java”, kam seko lielais burts un jebkurš ASCII teksta rakstzīmju skaits, ar nosacījumu, ka apakšvirknei “Java” neseko apakšvirkne “Script”. Tā atbildīs virknei “JavaBeans”, bet ne virknei. "Javanese" atbildīs virknei "JavaScrip", bet neatbildīs virknēm "JavaScript" vai "JavaScripter".

Tālāk esošajā tabulā ir sniegts regulārās izteiksmes enkura rakstzīmju saraksts.

Un pēdējais regulārās izteiksmes gramatikas elements. Regulārās izteiksmes karodziņi norāda augsta līmeņa modeļu atbilstības noteikumus. Atšķirībā no pārējās regulārās izteiksmes gramatikas karodziņi tiek norādīti nevis starp slīpsvītra rakstzīmēm, bet gan aiz otrās. JavaScript atbalsta trīs karogus.

Karogs i norāda, ka modeļa saskaņošanai ir jābūt reģistrjutīgai, un karogs g- ka meklēšanai jābūt globālai, t.i. ir jāatrod visas atbilstības virknē. Karogs m veic raksta meklēšanu vairāku rindu režīmā. Ja meklējamajā virknes izteiksmē ir jaunas rindiņas, tad šajā režīmā enkura rakstzīmes ^ un $ papildus visas virknes izteiksmes sākumam un beigām atbilst arī katras teksta rindiņas sākumam un beigām. Piemēram, modelis /java$/im atbilst gan “java”, gan “Java\nis fun”.

Šos karogus var kombinēt jebkurā kombinācijā. Piemēram, lai meklētu vārda "java" (vai "Java", "JAVA u.c.) pirmo reizi, neņemot vērā reģistrjutīgos vārdus, varat izmantot reģistrjutīgo regulāro izteiksmi /\bjava\b/ i. Un, lai virknē atrastu visus šī vārda gadījumus, varat pievienot g karogu: /\bjava\b/gi.

Līdz šim mēs esam apsprieduši mūsu izveidoto regulāro izteiksmju gramatiku, taču neesam apskatījuši, kā šīs regulārās izteiksmes faktiski var izmantot JavaScript skriptos. Šajā sadaļā mēs apspriedīsim objekta String metodes, kas izmanto regulāras izteiksmes modeļu saskaņošanai un meklēšanai ar aizstāšanu. Un tad mēs turpināsim sarunu par modeļu saskaņošanu ar regulārām izteiksmēm, apskatot RegExp objektu un tā metodes un īpašības.

Strings atbalsta četras metodes, izmantojot regulārās izteiksmes. Vienkāršākā no tām ir meklēšanas () metode. Tas izmanto regulāro izteiksmi kā argumentu un atgriež vai nu saskaņotās apakšvirknes pirmās rakstzīmes pozīciju, vai -1, ja atbilstība netiek atrasta. Piemēram, šāds zvans atgriezīs 4:

Var rezultāts = "JavaScript".search(/script/i); // 4

Ja meklēšanas() metodes arguments nav regulāra izteiksme, tas vispirms tiek pārveidots, nododot to RegExp konstruktoram. Meklēšanas () metode neatbalsta globālo meklēšanu un ignorē g karogu savā argumentā.

Aizvietošanas () metode veic meklēšanas un aizstāšanas darbību. Kā pirmais arguments tiek izmantota regulāra izteiksme, bet otrais - aizstājējvirkne. Metode meklē līniju, kurā tā tiek izsaukta, lai atrastu atbilstību norādītajam modelim.

Ja regulārajā izteiksmē ir karodziņš g, metode aizstāt () visas atrastās atbilstības aizstāj ar aizstājējvirkni. Pretējā gadījumā tas aizstāj tikai pirmo atrasto atbilstību. Ja aizstāj() metodes pirmais arguments ir virkne, nevis regulāra izteiksme, tad metode veic virknes burtisku meklēšanu, nevis pārvērš to regulārā izteiksmē, izmantojot RegExp() konstruktoru, kā to dara meklēšana() metode.

Piemēram, mēs varam izmantot aizvietošanas () metodi, lai vārdu "JavaScript" konsekventi rakstītu ar lielo burtu visā teksta rindā:

// Neatkarīgi no rakstzīmju reģistra, mēs tās aizstājam ar vārdu vajadzīgajā gadījumā var result = "javascript".replace(/JavaScript/ig, "JavaScript");

Aizvietošanas () metode ir jaudīgāka, nekā liecina šis piemērs. Atgādināšu, ka regulārā izteiksmē iekavās esošās apakšizteiksmes ir numurētas no kreisās puses uz labo un ka regulārā izteiksme atceras tekstu, kas atbilst katrai apakšizteiksmei. Ja aizstāšanas virknē ir zīme $, kam seko skaitlis, metode aizstāj () aizstāj šīs divas rakstzīmes ar tekstu, kas atbilst norādītajai apakšizteiksmei. Šī ir ļoti noderīga funkcija. Mēs varam to izmantot, piemēram, lai aizstātu taisnās pēdiņas virknē ar tipogrāfiskām pēdiņām, kuras simulē ar ASCII rakstzīmēm:

// citāts ir citāts, kam seko jebkurš rakstzīmju skaits //, izņemot pēdiņas (kuras mēs atceramies), kam seko cits citāts // var quote = /"([^"]*)"/g; // Aizstāt taisnas pēdiņas ar tipogrāfiskām un atstāt "$1" nemainītu // citāta saturs, kas saglabāts $1 var text = ""JavaScript" ir interpretēta programmēšanas valoda."; var rezultāts = text.replace(quote, ""$1"" ) ; // "JavaScript" ir tulkota programmēšanas valoda.

Svarīgi atzīmēt, ka otrais arguments aizstāšanai () var būt funkcija, kas dinamiski aprēķina aizstāšanas virkni.

Metode Match() ir visizplatītākā no String klases metodēm, kas izmanto regulāras izteiksmes. Tas izmanto regulāro izteiksmi kā vienīgo argumentu (vai pārvērš savu argumentu par regulāru izteiksmi, nododot to RegExp() konstruktoram) un atgriež masīvu, kurā ir meklēšanas rezultāti. Ja g karodziņš ir iestatīts regulārajā izteiksmē, metode atgriež visu virknē esošo atbilstību masīvu. Piemēram:

// atgriezīs ["1", "2", "3"] var rezultāts = "1 plus 2 ir vienāds ar 3".match(/\d+/g);

Ja regulārajā izteiksmē nav g karoga, metode match() neveic globālo meklēšanu; tas tikai meklē pirmo maču. Tomēr match() atgriež masīvu pat tad, ja metode neveic globālo meklēšanu. Šajā gadījumā pirmais masīva elements ir atrastā apakšvirkne, un visi pārējie elementi ir regulārās izteiksmes apakšizteiksmes. Tāpēc, ja match() atgriež masīvu arr, tad arr saturēs visu atrasto virkni, arr apakšvirkni, kas atbilst pirmajai apakšizteiksmei utt. Velkot paralēli ar aizstāj() metodi, varam teikt, ka $n saturs tiek ievadīts arr[n].

Piemēram, apskatiet šo kodu, kas parsē URL:

Var url = /(\w+):\/\/([\w.]+)\/(\S*)/; var text = "Apmeklējiet mūsu vietni http://www..php"; var rezultāts = text.match(url); if (result != null) ( var fullurl = rezultāts; // Satur "http://www..php" var protokols = rezultāts; // Satur "http" var host = rezultāts; // Satur "www..php" ")

Jāņem vērā, ka regulārai izteiksmei, kurai nav iestatīts globālās meklēšanas karodziņš g, metode match() atgriež tādu pašu vērtību kā regulārās izteiksmes metode exec(): atgrieztajam masīvam ir indeksa un ievades īpašības, kā aprakstīts. tālāk apspriestajā exec( ).

Pēdējā String objekta metode, kas izmanto regulāras izteiksmes, ir split (). Šī metode sadala virkni, kurā tā tiek izsaukta, apakšvirkņu masīvā, izmantojot argumentu kā atdalītāju. Piemēram:

"123 456 789".split(","); // Atgriezties ["123","456","789"]

Split() metode kā argumentu var izmantot arī regulāru izteiksmi. Tas padara metodi jaudīgāku. Piemēram, varat norādīt norobežotāju, kas pieļauj patvaļīgu atstarpes rakstzīmju skaitu abās pusēs:

"1, 2, 3 , 4 , 5".split(/\s*,\s*/); // Atgriezt ["1", "2", "3", "4", "5"]

Kā minēts, regulārās izteiksmes tiek attēlotas kā RegExp objekti. Papildus RegExp() konstruktoram RegExp objekti atbalsta trīs metodes un vairākas īpašības.

Konstruktors RegExp() izmanto vienu vai divus virknes argumentus un izveido jaunu RegExp objektu. Pirmais konstruktora arguments ir virkne, kas satur regulārās izteiksmes pamattekstu, t.i. teksts, kam regulārā izteiksmē literālā ir jāparādās starp slīpsvītru rakstzīmēm. Ņemiet vērā, ka virknes literāļi un regulārās izteiksmes izmanto rakstzīmi \, lai attēlotu atsoļa secības, tāpēc, nododot regulāro izteiksmi kā virknes literālu RegExp() konstruktoram, katra \ rakstzīme ir jāaizstāj ar \\ rakstzīmju pāri.

Var trūkt otrā RegExp() argumenta. Ja norādīts, tas definē regulārās izteiksmes karogus. Tam ir jābūt vienai no rakstzīmēm g, i, m vai šo rakstzīmju kombinācijai. Piemēram:

// Atrod visus piecciparu skaitļus virknē. Piezīme // simbolu izmantošana šajā piemērā \\ var zipcode = new RegExp("\\d(5)", "g");

Konstruktors RegExp() ir noderīgs, ja regulārā izteiksme tiek ģenerēta dinamiski, un tāpēc to nevar attēlot, izmantojot regulārās izteiksmes literālo sintaksi. Piemēram, lai atrastu lietotāja ievadītu virkni, izpildes laikā ir jāizveido regulāra izteiksme, izmantojot RegExp().

Katram RegExp objektam ir pieci rekvizīti. Avota rekvizīts ir tikai lasāma virkne, kas satur regulārās izteiksmes tekstu. Globālais rekvizīts ir tikai lasāma Būla vērtība, kas nosaka, vai g karodziņš atrodas regulārajā izteiksmē. Rekvizīts ignoreCase ir tikai lasāma Būla vērtība, kas nosaka, vai regulārajā izteiksmē ir i karodziņš. Daudzrindu rekvizīts ir tikai lasāma Būla vērtība, kas nosaka, vai regulārajā izteiksmē ir m karogs. Un pēdējais īpašums, lastIndex, ir vesels skaitlis, ko var lasīt un rakstīt. Modeļiem ar karodziņu g šis rekvizīts satur pozīcijas numuru rindā, no kuras jāsākas nākamajai meklēšanai. Kā aprakstīts tālāk, to izmanto exec() un test() metodēm.

RegExp objekti definē divas metodes, kas veic modeļu saskaņošanu; tie darbojas līdzīgi iepriekš aprakstītajām String klases metodēm. Galvenā RegExp klases metode, ko izmanto modeļu saskaņošanai, ir exec() . Tā ir līdzīga iepriekš minētajai klases String metodei match(), izņemot to, ka tā ir RegExp klases metode, kas izmanto virkni kā argumentu, nevis String klases metodi, kas izmanto RegExp argumentu.

Metode exec() izpilda regulāro izteiksmi norādītajai virknei, t.i. meklē sērkociņus virknē. Ja atbilstība netiek atrasta, metode atgriež nulli. Tomēr, ja tiek atrasta atbilstība, tā atgriež to pašu masīvu, ko atgriež metode match() meklēšanai bez karoga g. Masīva nulles elements satur virkni, kas atbilst regulārajai izteiksmei, un visi nākamie elementi satur apakšvirknes, kas atbilst visām apakšizteiksmēm. Turklāt īpašums rādītājs satur rakstzīmes pozīcijas numuru, ar kuru sākas attiecīgais fragments, un rekvizītu ievade attiecas uz meklēto rindu.

Atšķirībā no match(), exec() metode atgriež masīvu, kura struktūra nav atkarīga no g karoga klātbūtnes regulārajā izteiksmē. Atgādināšu, ka, nododot globālo regulāro izteiksmi, metode match() atgriež atrasto atbilstību masīvu. Un exec() vienmēr atgriež vienu atbilstību, bet sniedz pilnīgu informāciju par to. Kad exec() tiek izsaukts regulārai izteiksmei, kas satur g karogu, metode iestata regulārās izteiksmes objekta rekvizītu lastIndex uz rakstzīmes pozīcijas numuru, kas atrodas tieši aiz atrastās apakšvirknes.

Kad exec() tiek izsaukts otro reizi ar to pašu regulāro izteiksmi, tā sāk meklēšanu ar rakstzīmi, kuras pozīcija ir norādīta rekvizītā lastIndex. Ja exec() neatrod atbilstību, rekvizīts lastIndex tiek iestatīts uz 0. (Varat arī iestatīt lastIndex uz nulli jebkurā laikā, kas jādara visos gadījumos, kad meklēšana beidzas pirms pēdējās atbilstības vienā rindā ir atrasts, un meklēšana sākas citā rindā ar to pašu RegExp objektu.) Šī īpašā darbība ļauj atkārtoti izsaukt) exec(), lai atkārtotu visas regulārās izteiksmes atbilstības rindā. Piemēram:

Var modelis = /Java/g; var text = "JavaScript ir jautrāks par Java!"; var rezultāts; while((result = pattern.exec(text)) != null) ( console.log("Atrasts "" + rezultāts + """ + " pozīcijā " + result.index + "; nākamā meklēšana sāksies no " + modelis .lastIndex);)

Vēl viena RegExp objekta metode ir test(), kas ir daudz vienkāršāka nekā exec() metode. Tas aizņem virkni un atgriež patieso vērtību, ja virkne atbilst regulārajai izteiksmei:

Var modelis = /java/i; pattern.test("JavaScript"); // Atgriezties patiesi

Test() izsaukšana ir līdzvērtīga exec() izsaukšanai, kas atgriež true, ja exec() atgriež kaut ko citu, nevis nulli. Šī iemesla dēļ metode test() darbojas tāpat kā exec() metode, kad tiek izsaukta globālā regulārā izteiksme: tā sāk meklēt norādīto virkni pozīcijā, ko nosaka rekvizīts lastIndex, un, ja tā atrod atbilstību. , iestata rekvizītu lastIndex uz rakstzīmes pozīcijas numuru tieši blakus atrastajai atbilstībai. Tāpēc, izmantojot test() metodi, jūs varat izveidot līnijas šķērsošanas cilpu tāpat kā izmantojot exec() metodi.

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

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.

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/ .

Š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 raksta, 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.

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() metode ir RegExp objekta regulāra izteiksme. Tas meklē raksta virkni un atgriež patiesu vai nepatiesu atkarībā no rezultāta. Š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!");

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 .

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.

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”.

Regulāras izteiksmes (RegExp) ir ļoti efektīvs veids, kā strādāt ar virknēm.

Konstruējot regulāru izteiksmi, izmantojot īpašu sintaksi, varat:

• meklēt tekstu virknē
• aizstāt apakšvirknes virknē
• izvilkt informāciju no virknes

Gandrīz visās programmēšanas valodās ir regulāras izteiksmes. Īstenošanā ir nelielas atšķirības, taču vispārīgie jēdzieni attiecas gandrīz visur.

Regulārās izteiksmes ir datētas ar 1950. gadiem, kad tās tika formalizētas kā konceptuāls virkņu apstrādes algoritmu meklēšanas modelis.

UNIX ieviestās regulārās izteiksmes, piemēram, grep, sed un populārie teksta redaktori, sāka iegūt popularitāti un tika pievienotas Perl programmēšanas valodai, bet vēlāk arī daudzām citām valodām.

JavaScript kopā ar Perl ir viena no programmēšanas valodām, kas atbalsta regulāras izteiksmes, kas iebūvētas tieši valodā.

Regulāras izteiksmes iesācējiem un bieži vien pat profesionāliem izstrādātājiem var šķist absolūtas muļķības, ja neieguldāt laiku, kas nepieciešams to izpratnei.

Regulāras izteiksmes ir grūti rakstīt, grūti lasīt un grūti uzturēt/mainīt.

Bet dažreiz regulāras izteiksmes ir vienīgais saprātīgais veids, kā veikt dažas manipulācijas ar virkni, tāpēc tās ir ļoti vērtīgs rīks.

Šīs apmācības mērķis ir pēc iespējas vienkāršākā veidā sniegt jums izpratni par regulārajām izteiksmēm JavaScript un sniegt informāciju par regulāro izteiksmju lasīšanu un izveidi.

Īkšķis ir tāds, ka vienkāršas regulārās izteiksmes ir viegli lasāmas un rakstāmas, savukārt sarežģītas regulārās izteiksmes var ātri kļūt par putru, ja jūs dziļi nesaprotat pamatus.

Programmā JavaScript regulārā izteiksme ir objekts, ko var definēt divos veidos.

Pirmais veids ir izveidot jaunu RegExp objektu, izmantojot konstruktoru:

Const re1 = new RegExp ("hey")

Otrs veids ir izmantot regulārās izteiksmes literāļus:

Const re1 = /hey/

Vai jūs zināt, kas ir JavaScript? objektu literāļi Un masīva literāļi? Tas satur arī regexp literāļi.

Iepriekš minētajā piemērā hey sauc par modeli. Burtiskā formā tas atrodas starp divām slīpsvītrām, bet objekta konstruktora gadījumā tā nav.

Šī ir pirmā svarīgā atšķirība starp diviem regulāro izteiksmju definēšanas veidiem; pārējo redzēsim vēlāk.

Regulārā izteiksme, ko iepriekš definējām kā re1, ir ļoti vienkārša. Tā meklē virkni hey bez ierobežojumiem: virknē var būt daudz teksta, un vārds hey ir kaut kur pa vidu, un regulārā izteiksme darbosies. Rindā var būt tikai vārds hey, un regulārā izteiksme atkal darbosies.

Tas ir diezgan vienkārši.

Varat mēģināt pārbaudīt regulāro izteiksmi, izmantojot metodi RegExp.test(String), kas atgriež Būla vērtību:

Re1.test("hey") // ✅ re1.test("blablabla hey blablabla") // ✅ re1.test("he") // ❌ re1.test("blablabla") // ❌

Iepriekš minētajā piemērā mēs vienkārši pārbaudījām, vai "hey" atbilst regulārās izteiksmes modelim, kas saglabāts re1 .

Tas ir viegls gabals, taču jūs jau zināt daudz par regulārām izteiksmēm.

darbosies neatkarīgi no tā, kur līnijas iekšpusē atrodas hey.

Ja vēlaties atrast rindas, kas sākas ar hey, izmantojiet operatoru ^:

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

Ja vēlaties atrast rindas, kas beidzas ar hey, izmantojiet operatoru $:

/hey$/.test("hey") // ✅ /hey$/.test("bla hey") // ✅ /hey$/.test("hey you") // ❌

Apvienojot divus iepriekšējos apgalvojumus, varat atrast virkni, kas precīzi atbilst hey:

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

Lai atrastu virkni, kas sākas ar vienu apakšvirkni un beidzas ar citu apakšvirkni, varat izmantot .* , kas atbilst jebkurai rakstzīmei, kas atkārtojas 0 vai vairāk reizes:

/^hey.*joe$/.test("hey joe") // ✅ /^hey.*joe$/.test("heyjoe") // ✅ /^hey.*joe$/.test("hei kā tev iet Džo") // ✅ /^hey.*joe$/.test("hey joe!") // ❌

Tā vietā, lai meklētu noteiktu virkni, varat norādīt rakstzīmju diapazonu, piemēram:

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

Šīs regulārās izteiksmes meklē virknes, kurās ir vismaz viena rakstzīme no atlasītā diapazona:

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

Diapazonus var apvienot:

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

Varat pārbaudīt, vai virknē ir tikai viena rakstzīme no diapazona, izmantojot rakstzīmi -:

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

Rakstzīme ^ raksta sākumā noenkuro to līdz rindas sākumam.

Izmantojot šo rakstzīmi diapazonā, diapazons tiek apgriezts, tāpēc:

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

• \d atbilst jebkuram skaitlim, ekvivalentam
• \D atbilst jebkurai rakstzīmei, kas nav cipars, līdzvērtīga [^0-9]
• \w atbilst jebkurai burtciparu rakstzīmei, ekvivalentam
• \W atbilst jebkurai rakstzīmei, kas nav burtciparu vērtība, kas ir līdzvērtīga [^A-Za-z0-9]
• \s atbilst jebkurai atstarpes rakstzīmei: atstarpe, tabulēšana, jauna rindiņa un unikoda atstarpes
• \S atbilst jebkurai rakstzīmei, kas nav atstarpe
• \0 atbilst nullei
• \n atbilst jaunās rindiņas rakstzīmei
• \t atbilst tabulēšanas rakstzīmei
• \uXXXX sakrīt ar Unikoda rakstzīmi ar kodu XXXX (nepieciešams u karodziņš)
• . atbilst jebkurai rakstzīmei, izņemot jaunu rindiņu (piemēram, \n) (ja neizmantojat karodziņu s, mēs paskaidrosim vēlāk)
• [^] atbilst jebkurai rakstzīmei, ieskaitot jaunu rindiņu. Noderīga, strādājot ar daudzrindu virknēm

Ja vēlaties atlasīt vienu vai otru rindu, izmantojiet operatoru |. .

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

Iedomājieties, ka jums ir regulāra izteiksme, kas pārbauda virkni, lai pārliecinātos, ka tajā ir tikai viens cipars:

Vai varat izmantot kvantoru? , kas padarīs šo rakstzīmi neobligātu. Mūsu gadījumā ciparam ir jāparādās 0 vai 1 reizi:

bet ko darīt, ja mēs vēlamies, lai regulārā izteiksme darbotos ar vairākiem cipariem?

To var izdarīt 4 veidos, izmantojot + , * , (n) un (n,m) .

Atbilst vienam vai vairākiem (>=1) elementiem:

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

Atbilst 0 vai vairāk (>=0) elementu:

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

Precīzi atbilst n elementu skaitam:

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

Atbilst diapazonam no n līdz m elementiem:

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

m var izlaist un otro robežu atstāt neierobežotu, lai būtu vismaz n elementi:

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

Nākamā rakstzīme pēc elementa? , padarīs to neobligātu:

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

Izmantojot iekavas, varat izveidot rakstzīmju grupas (...) .

Tālāk sniegtajā piemērā tiek meklēta precīza 3 ciparu atbilstība, kam seko viena vai vairākas burtciparu rakstzīmes.

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

Atkārtotas rakstzīmes, kas parādās pēc grupas beigu iekavas, attiecas uz visu grupu:

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

Līdz šim mēs esam redzējuši, kā pārbaudīt virknes un pārbaudīt, vai tajās ir noteikts modelis.

Foršā lieta regulārajās izteiksmēs ir tāda, ka varat satvert noteiktas virknes daļas un ievietot tās masīvā.

To var izdarīt, izmantojot grupas vai, konkrētāk, izmantojot grupu uztveršanu.

Pēc noklusējuma grupas jebkurā gadījumā tiek uzņemtas. Tagad tā vietā, lai izmantotu RegExp.test(String), kas vienkārši atgriež Būla vērtību, mēs izmantosim vienu no šīm metodēm:

• String.match (RegExp)
• RegExp.exec (virkne)

Tie ir tieši tādi paši, un abi atgriež masīvu ar virkni, kas tiek pārbaudīta kā pirmais elements, un pārējie elementi satur atbilstības katrai atrastajai grupai.

Ja neviena atbilstība netiek atrasta, tas atgriež nulli.

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

Ja grupa atbilst vairākas reizes, atgrieztajam masīvam tiks pievienota tikai pēdējā atrastā vērtība.

"123456789".match(/(\d)+/) //Masīvs [ "123456789", "9" ]

Grupu tveršanu var padarīt neobligātu, izmantojot (...)? . Ja nekas netiek atrasts, atgrieztajam masīvam tiks pievienots nedefinēts elements:

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

Katrai atrastajai grupai tiek piešķirts numurs. $1 attiecas uz pirmo elementu, $2 uz otro un tā tālāk. Tas ir noderīgi, ja mēs runājam par virknes daļas aizstāšanu.

Šī ir jauna ES2018 funkcija.

Grupai var piešķirt nosaukumu, nevis tikai slotu atgrieztajā masīvā:

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

Lietojot match un exec bez grupām, pastāv atšķirība: masīva pirmais elements nesaturēs pilnībā atrasto virkni, bet gan tiešo atbilstību:

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

Tā kā grupas pēc noklusējuma ir tveramas, mums ir nepieciešams veids, kā ignorēt dažas grupas atgrieztajā masīvā. Tas ir iespējams, izmantojot nepārtverošās grupas, kuras sākas ar (?:...) .

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

Jebkurā regulārajā izteiksmē varat izmantot šādus karogus:

• g: meklē atbilstības visā pasaulē
• i: padara regulāro izteiksmi nejutīgu
• m: iespējo vairākrindu režīmu. Šajā režīmā ^ un $ atbilst visas rindas sākumam un beigām. Bez šī karoga, ar daudzrindu virknēm tie atbilst katras rindas sākumam un beigām.
• u: iespējo Unicode atbalstu (pievienots ES6/ES2015)
• s: (jaunums ES2018) saīsinājums no "single line", tas ļauj. atbilst jaunām rindiņām

Karogus var apvienot, un tie tiek pievienoti arī burtiskās virknes beigās:

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

vai nodots kā otrais parametrs RegExp objekta konstruktoram:

Jauns RegExp("hey", "ig").test("HEy") // ✅

Varat pārbaudīt regulārās izteiksmes īpašības:

• avots - veidnes virkne
• daudzrindu — patiess, ja ir iestatīts m karogs
• globāls — patiess, ja ir iestatīts g karodziņš
• ignoreCase — patiess, ja ir iestatīts i karodziņš
• pēdējaisIndekss

Īpaši simboli:

Šīs ir īpašās rakstzīmes, jo tās ir kontroles rakstzīmes, veidojot regulārās izteiksmes modeļus, tādēļ, ja vēlaties tās izmantot, lai atrastu atbilstības shēmā, jums tās ir jāatceļ ar slīpsvītru:

\b un \B ļauj noteikt, vai rinda atrodas vārda sākumā vai beigās:

• \b atbilst, ja rakstzīmju kopa atrodas vārda sākumā vai beigās
• \B atbilst, ja rakstzīmju kopa nav vārda sākumā vai beigās

"Es redzēju lāci".match(/\bbear/) //Array ["bear"] "Es redzēju bārdu".match(/\bbear/) //Array ["bear"] "Es redzēju bārdu" .match(/\bbear\b/) //null "cool_bear".match(/\bbear\b/) //null

Mēs jau esam redzējuši, kā pārbaudīt virknes, lai tās atbilstu rakstam.

Mēs arī redzējām, kā daļu no virknēm, kas atbilst rakstam, varat iegūt masīvā.

Tagad apskatīsim, kā nomainīt virknes daļas, pamatojoties uz modeli.

String objektam JavaScript ir aizvietošanas () metode, ko var izmantot bez regulārām izteiksmēm viena nomaiņa rindā:

"Sveika pasaule!".replace("pasaule", "suns") //Sveiks suns! "Mans suns ir labs suns!".replace("suns", "kaķis") //Mans kaķis ir labs suns!

Šī metode kā argumentu var izmantot arī regulāro izteiksmi:

"Sveika pasaule!".replace(/world/, "suns") //Sveiks suns!

Karoga g izmantošana ir vienīgais veids, kā aizstāt vairākus rindiņas gadījumus vaniļas JavaScript:

"Mans suns ir labs suns!".replace(/dog/g, "cat") //Mans kaķis ir labs kaķis!

Grupas ļauj mums darīt košākas lietas, apmainot virkņu daļas:

"Sveika, pasaule!".replace(/(\w+), (\w+)!/, "$2: $1!!!") // "pasaule: Sveiki!!!"

Virknes vietā varat izmantot funkciju, lai veiktu vēl interesantākas lietas. Tam tiks nodoti vairāki argumenti, piemēram, tie, ko atgriež metodes String.match(RegExp) vai RegExp.exec(String), kur argumentu skaits ir atkarīgs no grupu skaita:

"Sveika, pasaule!".replace(/(\w+), (\w+)!/, (matchedString, first, second) => ( console.log(first); console.log(otrais); return `$( second.toUpperCase()): $(first)!!!` )) //"PASAULE: Sveiki!!!"

Tiek uzskatīts, ka regulārās izteiksmes pēc noklusējuma ir mantkārīgas.

Ko tas nozīmē?

Ņemiet, piemēram, šo regulāro izteiksmi:

/\$(.+)\s?/

Mums vajadzētu iegūt dolāra summu no virknes:

/\$(.+)\s?/.exec("Tas maksā 100 ASV dolārus") //0

bet ja pēc skaitļa mums ir vairāk vārdu, tas novērš uzmanību

/\$(.+)\s?/.exec("Tas maksā 100 USD un ir mazāks par 200 USD") //100 un tas ir mazāks par 200 USD

Kāpēc? Jo regulārā izteiksme aiz $ zīmes atbilst jebkurai .+ rakstzīmei un neapstājas, līdz tā sasniedz rindas beigas. Tad tas apstājas, jo \s? padara aizmugurējo vietu neobligātu.

Lai to labotu, mums ir jānorāda, ka regulārajai izteiksmei jābūt slinkai un jāatrod mazākais atbilstības skaits. Vai mēs varam to izdarīt ar simbolu? aiz kvantatora:

/\$(.+?)\s/.exec("Tas maksā 100 ASV dolārus, un tas ir mazāks par 200 ASV dolāriem") //100

Tātad, simbols? var nozīmēt dažādas lietas atkarībā no tā stāvokļa, tāpēc tas var būt gan kvantors, gan slinkuma režīma indikators.

Izmanto ?=, lai atrastu atbilstības virknē, kam seko noteikta apakšvirkne

/Roger(?=Waters)/ /Roger(?=Waters)/.test("Rodžers ir mans suns") //false /Roger(?=Waters)/.test("Rodžers ir mans suns un Rodžers Voterss ir slavens mūziķis") //patiess

Veic apgriezto darbību un atrod atbilstības virknē, kurām neseko noteikta apakšvirkne:

/Roger(?!Waters)/ /Roger(?!Waters)/.test("Rodžers ir mans suns") //true /Roger(?! Voters)/.test("Rodžers ir mans suns un Rodžers Voterss ir slavens mūziķis") //false

Šī ir jauna ES2018 funkcija.

Uz priekšu tiek izmantots simbols ?=. Vai izmanto retrospektīvu?

Karogs u ir nepieciešams, strādājot ar unikoda virknēm, it īpaši, ja var būt nepieciešams apstrādāt virknes astrālajās plaknēs, kas nav iekļautas pirmajās 1600 unikoda rakstzīmēs.

Piemēram, emocijzīmes, bet tas arī viss.

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

Tāpēc vienmēr izmantojiet u karogu.

Unicode, tāpat kā parastās rakstzīmes, var apstrādāt diapazonus:

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

JavaScript pārbauda skata iekšējos kodus, vai tad?< ? < ? на самом деле \u1F436 < \u1F43A < \u1F98A . Посмотрите полный список эмодзи чтобы увидеть коды и узнать их порядок.

Kā minēts iepriekš, regulārās izteiksmes shēmā varat izmantot \d, lai atbilstu jebkuram skaitlim, \s, lai atbilstu jebkurai rakstzīmei, kas nav atstarpe, \w, lai atbilstu jebkurai burtciparu rakstzīmei utt.

Unikoda rekvizītu atkāpšanās ir ES2018 līdzeklis, kas pievieno ļoti lielisku līdzekli, paplašinot šo koncepciju uz visām unikoda rakstzīmēm un pievienojot \p() un \P() .

Jebkurai Unikoda rakstzīmei ir rekvizītu kopa. Piemēram, skripts definē valodu saimi, ASCII ir Būla vērtība, kas ir vienāda ar patieso ASCII rakstzīmēm utt. Varat ievietot šo rekvizītu cirtainos iekavās, un regulārā izteiksme pārbaudīs, vai tā vērtība ir patiesa:

/^\p(ASCII)+$/u.test("abc") // ✅ /^\p(ASCII)+$/u.test("ABC@") // ✅ /^\p(ASCII) +$/u.test("ABC?") // ❌

ASCII_Hex_Digit ir vēl viens Būla rekvizīts, kas pārbauda, ​​vai virknē ir tikai derīgi heksadecimālie cipari:

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

Ir daudz citu Būla rekvizītu, kurus varat pārbaudīt, vienkārši pievienojot to nosaukumu cirtaini iekavās, tostarp lielie burti , mazie burti , atstarpe , alfabēts , emocijzīmes un citi:

/^\p(Mazie burti)$/u.test("h") // ✅ /^\p(Lielie burti)$/u.test("H") // ✅ /^\p(Emoji)+$/ u.test("H") // ❌ /^\p(Emoji)+$/u.test("???") // ✅

Papildus šiem binārajiem rekvizītiem varat pārbaudīt jebkuru Unikoda rakstzīmju rekvizītu, lai tas atbilstu noteiktai vērtībai. Tālāk esošajā piemērā es pārbaudu, vai virkne ir rakstīta grieķu vai latīņu alfabētā:

/^\p(Script=grieķu)+$/u.test("ελληνικά") // ✅ /^\p(Script=latīņu valoda)+$/u.test("hey") // ✅

Pieņemsim, ka ir virkne, kurā ir tikai viens skaitlis, kas jāizvelk. /\d+/ jādara šādi:

"Test 123123329".match(/\d+/) // Masīvs [ "123123329"]

Vienkāršākā pieeja ir pārbaudīt, vai pirms un pēc @ zīmes nav rakstzīmes, kas nav atstarpes, izmantojot \S:

/(\S+)@(\S+)\.(\S+)/ /(\S+)@(\S+)\.(\S+)/.exec(" [aizsargāts ar e-pastu]") //["[aizsargāts ar e-pastu]", "copesc", "gmail", "com"]

Tomēr šis ir vienkāršots piemērs, jo tajā ir iekļautas daudzas nederīgas e-pasta adreses.

Iedomāsimies, ka jums ir virkne, kurā ir teksts, kas ievietots dubultpēdiņās, un jums ir jāizvelk šis teksts.

Labākais veids, kā to izdarīt, ir izmantot grupu tveršanu, jo mēs zinām, ka mūsu spēlei ir jāsākas un jābeidzas ar " , tāpēc mēs varam viegli pielāgot modeli, taču mēs arī vēlamies noņemt šīs pēdiņas no rezultāta.

Rezultātā atradīsim nepieciešamo:

Const hello = "Sveiki, "jauks zieds"" const rezultāts = /"([^"]*)"/.exec(hello) //Array [ "\"jauks zieds\"", "jauks zieds"]

Piemēram, iegūstiet saturu no span taga, vienlaikus atļaujot tagam jebkādu argumentu skaitu:

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

Regulāro izteiksmju sintakse ir diezgan sarežģīta, un tās apguve prasa nopietnas pūles. Labākais regulāro izteiksmju ceļvedis mūsdienās ir J. Frīdla grāmata “Regulārās izteiksmes”, kas, autora vārdiem runājot, ļauj “mācīties domāt regulārās izteiksmēs”.

Regulārā izteiksme ir līdzeklis virkņu vai rakstzīmju secības apstrādei, kas nosaka teksta modeli.

Modifikators - ir paredzēts regulārās izteiksmes “norādīšanai”.

Metarakstzīmes ir īpašas rakstzīmes, kas darbojas kā komandas regulāro izteiksmju valodā.

Regulārā izteiksme ir iestatīta kā regulārs mainīgais, pēdiņu vietā tiek izmantota tikai slīpsvītra, piemēram: var reg=/reg_expression/

Ar visvienkāršākajām veidnēm mēs domājam tās veidnes, kurām nav nepieciešamas īpašas rakstzīmes.

Pieņemsim, ka mūsu uzdevums ir aizstāt visus burtus "r" (mazos un lielos) ar latīņu lielo burtu "R" frāzē. Regulāras izteiksmes.

Izveidojiet veidni var reg=/р/ un, izmantojot metodi aizvietot mēs īstenojam savus plānus

var reg=/р/

document.write(rezultāts)

Rezultātā mēs iegūstam rindu - Regulāras izteiksmes, aizstāšana notika tikai pirmajā burta “p” gadījumā, ņemot vērā gadījumu.

Bet šis rezultāts neatbilst mūsu uzdevuma nosacījumiem... Šeit ir nepieciešami modifikatori “g” un “i”, kurus var lietot gan atsevišķi, gan kopā. Šie modifikatori tiek ievietoti regulārās izteiksmes modeļa beigās pēc slīpsvītras un ir sekojošām vērtībām:

modifikators "g" - iestata meklēšanu rindā kā "globālu", t.i. mūsu gadījumā aizstāšana notiks visiem burta “p” gadījumiem. Tagad veidne izskatās šādi: var reg=/р/g , aizstājot to mūsu kodā

var str="Regulāras izteiksmes"
var reg=/р/g
var rezultāts=str.replace(reg, "R")
document.write(rezultāts)

mēs iegūstam virkni - Regulāras izteiksmes.

modifikators "i" - norāda reģistrjutīgu meklēšanu virknē Pievienojot šo modifikatoru mūsu veidnei var reg=/р/gi, pēc skripta izpildes mēs iegūsim vēlamo mūsu uzdevuma rezultātu - regulāras izteiksmes.

Metarakstzīmes norāda meklētās virknes rakstzīmju veidu, veidu, kādā tekstā tiek ieskauta meklētā virkne, kā arī noteikta veida rakstzīmju skaitu skatītajā tekstā. Tāpēc metarakstzīmes var iedalīt trīs grupās:

• Metaraksti atbilstības meklēšanai.
• Kvantitatīvās metarakstzīmes.
• Metarakstzīmju pozicionēšana.

Tabulā "Atbilstības meklēšanas metarakstzīmes" norādītās rakstzīmes nedrīkst sajaukt ar atsoļa rakstzīmju secību, kas tiek izmantota virknēs, piemēram, \\t - tab, \\n - jaunrinda utt.

Katra rakstzīme, kas norādīta tabulā Kvantitatīvās metarakstzīmes, attiecas uz vienu iepriekšējo rakstzīmi vai metarakstzīmi regulārajā izteiksmē.

Pēdējā metarakstzīmju kopa ir paredzēta, lai norādītu, vai meklēt (ja tas ir svarīgi) apakšvirkni rindas sākumā vai beigās.

aizvietot - šī metode mēs to jau izmantojām pašā raksta sākumā, tas ir paredzēts, lai meklētu paraugu un aizstātu atrasto apakšvirkni ar jaunu apakšvirkni.

exec — šī metode veic virknes atbilstību veidnē norādītajam modelim. Ja modeļa saskaņošana neizdodas, tiek atgriezta nulle. Pretējā gadījumā rezultāts ir apakšvirkņu masīvs, kas atbilst dotajam modelim. /*Pirmais masīva elements būs vienāds ar sākotnējo virkni, kas atbilst dotajam modelim*/

Piemēram:

var reg=/(\d+).(\d+).(\d+)/
var arr=reg.exec("Esmu dzimis 1980. gada 15. septembrī")
document.write("Dzimšanas datums: ", arr, "< br>")
document.write("Dzimšanas diena: ", arr, "< br>")
document.write("Dzimšanas mēnesis: ", arr, "< br>")
document.write("Dzimšanas gads: ", arr, "< br>")

Rezultātā mēs iegūstam četras rindas:
Dzimšanas datums: 15.09.1980
Dzimšanas diena: 15
Dzimšanas mēnesis: 09
Dzimšanas gads: 1980. gads

Rakstā nav parādītas visas regulāro izteiksmju iespējas un prieks; lai padziļināti izpētītu šo jautājumu, iesaku izpētīt RegExp objektu. Vēlos arī vērst jūsu uzmanību uz to, ka regulāro izteiksmju sintakse neatšķiras gan JavaScript, gan PHP. Piemēram, lai pārbaudītu, vai e-pasts ir ievadīts pareizi, gan JavaScript, gan PHP regulārā izteiksme izskatīsies vienādi /+@+.(2,3)/i .