Expresii obisnuite - Aceasta este o limbă care descrie modele de rând bazate pe metasimymboli. Metasimwall este un simbol în expresie regulată, care descrie o clasă de caractere de caractere de clasă, indică poziția substringului, indică numărul de repetări sau caractere de grup într-un substring. De exemplu, metacimolul descrie numerele și $ denotă capătul șirului. În expresie regulată, pot exista personaje convenționale care se descriu ei înșiși. Setul și valoarea metasimvolilor în expresii regulate descrie standardul PCRE, majoritatea fiind susținută în JS.

Domeniul de aplicare regulat de aplicare

Exprimările regulate sunt utilizate, de regulă, pentru următoarele sarcini:

• Comparaţie. Scopul acestei sarcini va afla dacă expresia regulată specificată corespunde textului definit.
• Căutare. Cu ajutorul expresiilor regulate, este convenabil să găsiți substringul adecvat și să le extrageți din text.
• Înlocuire. Expresiile regulate ajută adesea să găsească numai, ci și să înlocuiască în textul unui substring corespunzător expresiei regulate.

În cele din urmă, cu expresii regulate, puteți, de exemplu:

• Verificați dacă datele personalizate completează formularul.
• Găsiți în linkul de text de intrare al utilizatorului către imagine pentru atașamentul automat ulterior la mesaj.
• Eliminați din textul etichetelor HTML.
• Verificați codul înainte de a compila prezența unor erori sintactice simple.

Caracteristicile expresiilor regulate în JS. Literali de expresii regulate

Caracteristica principală a expresiilor regulate în JS este că există un tip separat de literal pentru ei. Așa cum literale de șir sunt încadrate prin citate, literale de expresie regulate sunt încadrate de arcuri (/). Astfel, codul JS poate conține expresii formularului:

consola.log (TypeOf / Tcoder /); // Obiect.

De fapt, o expresie regulată care este determinată în șir

var modelat \u003d nou regexp ("tcoder");

Această metodă de creare este utilizată în mod obișnuit atunci când este necesar să se utilizeze variabile în expresie regulată sau să creeze dinamic o expresie regulată. În toate celelalte cazuri, literale ale expresiilor regulate sunt utilizate datorită sintaxei mai scurte și absenței nevoii de a proteja suplimentar câteva caractere.

Simboluri în expresii regulate

Toate caracterele alfanumerice în expresii regulate nu sunt metasimvol și se descrie singuri. Aceasta înseamnă că expresia regulată / tcoder / Acesta va corespunde unui tcoder substanting. În expresii regulate, este de asemenea posibil să se indice caracterele alfabetice, cum ar fi: traducerea șirului (\\ n), tabularea (\\ t) și așa mai departe. Toate aceste personaje corespund și ei înșiși. Slash inverse (\\) livrate înainte ca simbolul alfabetic să o facă un metacamir dacă există astfel de. De exemplu, simbolul alfabetic "D" va deveni un metacamir care descrie numerele dacă este prevăzut cu un strat (\\ d).

Clase de simboluri

Caracterele unice în expresii regulate pot fi grupate în clase folosind paranteze pătrate. Clasa creată în acest mod corespunde oricui dintre personajele incluse în el. De exemplu, expresie regulată // Literele "T", "C", "O", "D", "E", "R" vor corespunde.

În clasă, puteți seta și gama de caractere folosind o cratimă. De exemplu, clasa corespunde clasei. Rețineți că unele metasimwall-uri în expresii regulate descriu deja clasele de caractere. De exemplu, metacimolul este echivalent cu clasa. Rețineți că metacaracters care descriu clasele de caractere pot fi, de asemenea, incluse în clase. De exemplu, clasa [\\ DA-F] corespunde numerelor și literele "A", "B", "D", "E", "F", adică orice simbol hexazecimal.

Există, de asemenea, capacitatea de a descrie clasa de caractere, specificând caracterele care nu ar trebui să intre. Acest lucru se face folosind metasimvol ^. De exemplu, clasa [^ \\ d] va corespunde oricărui caracter, cu excepția numărului.

Repeta

Acum putem descrie, de exemplu, numărul zecimal al oricărei lungimi date, pur și simplu scriind atât de mult metasimvolol, câte numere în acest număr. Sunt de acord că această abordare nu este foarte convenabilă. În plus, nu putem descrie gama numărului necesar de repetări. De exemplu, nu putem descrie numărul de la una sau două cifre. Din fericire, în expresii regulate, este posibil să se descrie intervalele de repetare utilizând metasimvolii. Pentru a face acest lucru, după simbol, este suficient să specificați intervalul de repetare în paranteze curbate. De exemplu, expresie regulată / TCO (1, 3) der / Corzile "tcoder", "Tcooder" și "TcoooDer" vor corespunde. Dacă omiteți numărul maxim de repetări, lăsând virgulă și numărul minim de repetări, atunci puteți specifica numărul de repetări mai specifice. De exemplu, expresie regulată / Bo (2,) bs / Corzile "țâțe", "boobs", "boobs" vor corespunde și așa mai departe cu orice număr de litere "o" cel puțin două.

Dacă în paranteze Curly Omite și virgulă, pur și simplu specificând un număr, atunci va denota numărul exact de repetări. De exemplu, expresie regulată / \\ d (5) / Numerele de cinci cifre corespund.

Unele intervale de repetare sunt folosite destul de des și pentru denumirile lor există metele lor.

Repetiții lacomi

Sintaxa de mai sus descrie numărul maxim de repetiții, adică din toate cantitățile posibile de repetări, numărul care se află în intervalul specificat - este selectat maximul. Astfel de repetări sunt numite lacomi. Aceasta înseamnă că expresia regulată / \\ d + / în linie Da! 111 va corespunde subținerii "111", și nu "11" sau "1", deși metasimmolul "+" descrie aceleași repetări.

Dacă doriți să implementați o repetare neclară, atunci există un număr minim posibil de repetări din intervalul specificat, apoi puneți simplu simbolul "?" După intervalul de repetare. De exemplu, expresie regulată / \\ D +? / În rândul "Da! 111" va corespunde substringului "1" și expresiei regulate / \\ d (2,) / În aceeași linie va corespunde substringului "11".

Merită să acordăm atenție unei caracteristici importante a unei repetări neclare. Luați în considerare expresia regulată / Bo (2,)? Bs /. În linia "Îmi place Big Boooobs", se va potrivi, ca și în cazul unei repetări lacomi, substringul beoobs și nu sâni, așa cum a fost posibil să se gândească. Faptul este că o expresie regulată cu o comparație nu poate corespunde unor substring situați în locuri diferite ale șirului. Adică expresia noastră regulată nu se poate potrivi substringul "Boo" și "BS" lipit într-o singură linie.

Alternative

În expresii regulate, pot fi de asemenea utilizate alternative - pentru a descrie un set de rânduri care corespund uneia sau unei părți a unei expresii regulate. Astfel de părți sunt numite alternative și sunt împărțite pe o caracteristică verticală. De exemplu, expresie regulată / Două | de două ori | \\ 2 / Acesta poate corespunde fie la substituția "două", fie la substringul "de două ori" sau substringul "2". Lanțul alternativ este procesat la stânga la dreapta înainte de prima coincidență și poate corespunde numai substringului că o descrie doar o singură alternativă. De exemplu, expresie regulată / Java | Script / Linia "îmi place JavaScript" se va potrivi doar substringul "Java".

Gruparea

Pentru a lua în considerare mai multe caractere ca un singur întreg atunci când utilizați intervalele de repetare, clasele de simboluri și orice altceva, este suficient doar să le luați în paranteze. De exemplu, expresie regulată / Adevărat (coder)? / Corzile "true -coder" și "adevărat" vor corespunde.

Link-uri

În plus, parantezele rotunde combină simbolurile în expresia regulată într-un singur întreg, vă puteți referi la substringul adecvat, pur și simplu prin indicarea numărului suportului stâng de pereche de paranteze. Parantezele sunt numerotate de la stânga la dreapta de la unul. De exemplu, în termeni regulați / (Una (două) (patru) / \\ 1 se referă la unul, \\ 2 pe "două", \\ 3 pe "trei", \\ 4 pe "Patru". Ca exemplu de utilizare a unor astfel de link-uri, dăm o expresie regulată / (\\ d) \\ 1 /care corespunde numerelor de două cifre cu aceleași numere. O limitare importantă a utilizării backlink-urilor este imposibilitatea utilizării utilizării lor în clase, care este, de exemplu, descrie un număr de două cifre cu diferite cifre regulate / (\\ d) [^ \\ 1] / Este imposibil.

Demascarea paranteze

Adesea este necesar să grupați pur și simplu personajele, dar nu este nevoie să creați o legătură. În acest caz, puteți scrie imediat după consola de grupare din stânga?:. De exemplu, în termeni regulați / (Unu, doi, trei) / \\ 2 va indica la trei.

Astfel de paranteze sunt uneori numite non-prompte. Ei au o altă caracteristică importantă pe care o vom vorbi în următoarea lecție.

NOTĂ POZIȚIE

În expresii regulate, există și metasimwills care indică o anumită poziție în linie. Mai des decât toate simbolurile rămase ^, $ indicând începutul și sfârșitul liniei. De exemplu, expresie regulată /\..+$/ va corespunde expansiunii în numele fișierelor și expresia regulată / ^ \\ d / Prima cifră din șir, dacă există.

Verificări avansate și negative avansate

Cu expresii regulate, puteți descrie, de asemenea, substringul, urmat de substringul descris de un alt șablon. De exemplu, trebuie să găsim cuvântul Java numai dacă urmează "Script". Această sarcină poate fi rezolvată cu expresie regulată / Java (? \u003d script) /. Dacă trebuie să descriem substringul "Java" în spatele căruia scenariul nu trebuie utilizat de o expresie regulată / Java (?! Script) /.

Colectăm tot ce am vorbit mai sus într-o singură placă.

Simbol	Valoare
a | B.	Corespunde fie sau, fie.
(…)	Gruparea parantezelor. De asemenea, pe substring, se poate face referire modelul corespunzător în paranteze.
(?:…)	Gruparea numai, fără posibilitatea de a se referi.
\\ N.	Referință la un substring corespunzător șablonului N-M.
^	Începutul datelor de intrare sau începutul șirului.
$	Sfârșitul datelor de intrare sau sfârșitul șirului.
a (? \u003d b)	Respectă substringul care descrie șablonul A numai dacă urmează substringul descris de șablonul b.
a (?! B)	Corespunde substringului care descrie șablonul doar dacă acesta nu Rezultă substringul descris de șablonul b.

Steaguri

Și în cele din urmă, ultimul element al sintaxei expresiilor regulate. Steagurile stabilesc regulile de conformitate care aparțin întregii expresii regulate. Spre deosebire de toate celelalte elemente, sintaxa de expresii regulate sunt scrise imediat după expresia literală sau sunt transmise în linie ca al doilea parametru al constructorului de obiecte Regexp..

JavaScript există doar trei steaguri de expresii regulate:

i. - Când specificați acest steag, registrul nu este luat în considerare, adică, de exemplu, expresia regulată \\ javascript \\ i Corzile "JavaScript", "JavaScript", "JavaScript", "JavaScript", etc. va fi configurat etc.

m. - Acest steag include o căutare pe mai multe linii. Aceasta înseamnă că, dacă în text există simboluri de traducere de caractere și acest steag este livrat, caracterele ^ și $ în afară de începutul și sfârșitul întregului text vor corespunde, de asemenea, la începutul și la sfârșitul fiecărui rând din text. De exemplu, expresie regulată / Linii $ / m Respectă substringul "linia", atât în \u200b\u200blinia "Prima linie", cât și în linia One \\ NSECOND \\ ntwo.

g. - Include o căutare globală, adică o expresie regulată, dacă acest pavilion este activat, substringul a coincis cu acesta va corespunde și nu doar primul, ca și cum acest steag nu este.

Steagurile pot fi combinate într-o ordine arbitrară, adică \\ Tcoder \\ mig, \\ Tcoder \\ gim, \\ Tocder \\ gmi Etc., acest lucru este același. Ordinea steagurilor nu contează dacă sunt transmise în șir ca al doilea argument constructor de obiecte Regexp., adică noul Regexp ("Tcoder", "IM") și noul Regexp ("Tcoder", "IM") De asemenea, un lucru.

Zy.

Expresiile regulate sunt un instrument foarte puternic și convenabil pentru a lucra cu rânduri, permițând reducerea a sute de corzi de cod la o singură expresie. Din păcate, sintaxa lor este uneori prea complicată și greu și chiar dezvoltatorul cel mai experimentat poate uita că el a însemnat o expresie regulată destul de complicată, pe care a scris cu câteva zile în urmă, dacă nu a comentat. Din aceste motive, uneori merită să abandonim expresii regulate în favoarea metodelor convenționale de lucru cu linii.

Expresii obisnuite ( Regexp.) - Aceasta este o modalitate foarte eficientă de a lucra cu rânduri.

Maparea unei expresii regulate utilizând o sintaxă specială puteți:

• căutați text în linie
• Înlocuiți substringul în linie
• eliminați informațiile De la șir.

Aproape toate limbile de programare au expresii regulate. Există diferențe mici în implementare, dar conceptele generale sunt aplicate aproape peste tot.

Expresiile regulate se referă la anii 1950 când au fost formalizați ca un șablon de căutare conceptual pentru algoritmi de procesare a șirului.

Expresiile regulate implementate în Unix, cum ar fi GREP, SED și editorii de text populari, au început să câștige popularitate și au fost adăugate la limba de programare PERL și mai târziu în multe alte limbi.

JavaScript, împreună cu Perl, aceasta este una dintre limbile de programare în care susținerea expresiilor regulate este construită direct în limba.

Dificil, util

Newbies Expresiile regulate pot părea nonsens absolut, și adesea chiar dezvoltatori profesioniști, dacă nu să investească, este necesar pentru înțelegerea lor.

Expresii obisnuite e greu de scris, este greu de citit și dificil de întreținut / schimbare.

Dar uneori expresii regulate sunt singurul mod rezonabil Efectuați anumite manipulări deasupra rândurilor, deci sunt un instrument foarte valoros.

Acest ghid vizează cel mai simplu mod de a vă oferi o idee despre expresii regulate în JavaScript și să furnizați informații despre cum să citiți și să creați expresii regulate.

Regula empirică este aceea expresiile obișnuite simple sunt simple pentru citire și scriere., in timp ce expresiile regulate complexe se pot transforma rapid într-o mizerieDacă nu înțelegeți profund elementele de bază.

Cum arată expresii regulate

În JavaScript, expresii regulate sunt un obiect care poate fi definit în două moduri.

Prima modalitate este de a crea obiect nou REGEXP Cu ajutorul unui designer:

Const re1 \u003d nou regexp ("hei")

A doua modalitate este de a utiliza literali de expresii regulate:

Const re1 \u003d / hei /

Știi ce e în JavaScript acolo obiecte literale și literali masive? În el, de asemenea regexp literale.

În exemplul de mai sus, Hei este chemat șablon. În forma literală, este între două feluri și în cazul designerului obiectului, nu.

Aceasta este prima diferență importantă dintre cele două moduri de a defini expresii regulate, restul vom vedea mai târziu.

Cum funcționează?

Expresie regulată pe care am determinat-o mai sus ca Re1 este foarte simplă. Se caută un șir de hei fără limitări: Șirul poate conține o mulțime de text, iar cuvântul Hei este undeva în expresia mijlocie și regulată va funcționa. Șirul poate conține numai cuvântul Hei și în mod regulat va funcționa din nou.

Este destul de simplu.

Puteți încerca să testați expresia obișnuită utilizând metoda REGEXP.Test (șir) care returnează valoarea logică (booleană):

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

În exemplul de mai sus, am verificat pur și simplu modelul "Hei" al unei expresii regulate, care este stocată în RE1.

Este mai ușor decât simplu, dar știi deja multe despre expresii regulate.

Fixarea

/ Hei /

va funcționa independent de unde este Hei în interiorul șirului.

Dacă doriți să găsiți linii care încep cu Hei, utilizați operatorul ^:

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

Dacă doriți să găsiți rânduri care se termină pe Hei, apoi utilizați operatorul $:

/hey$/.test ("hei") // ✅ /hey$/.test ("bla hei") // ✅ /hey$/.test( "You") // ❌

Prin combinarea celor doi operatori anteriori, puteți găsi un șir care coincide complet cu HEY:

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

Pentru a găsi un șir de pornire cu un substring și puteți utiliza o confirmare de sfârșit. *, Care va coincide cu orice simbol care se repetă 0 sau de mai multe ori:

/^hey.rojoe$/.test ("hey joe") // ✅ / ^ hei. * Joe $ /. Test ("heyjoe") // ✅ /^hey.rooe$/.test( Cum vă aflați Joe ") // ✅ /^hey. jojoe$/.test( "hey joe!") // ❌

Elemente de căutare după gama

În loc să căutați un șir specific, puteți specifica intervalul de caractere, de exemplu:

// // A, B, C, ..., X, Y, Z / // A, B, C, ..., X, Y, Z // // A, B, C, C // / / 0, 1, 2, 3, ..., 8, 9

Aceste expresii regulate caută linii care conțin cel puțin un caracter din gama selectată:

//.a ") // ✅ //.test(a") // ❌ //.test(]) // ❌ /// .Test ("dc") // ✅

Intervalele pot fi combinate:

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

Căutați mai multe coincidențe ale elementului de interval

Puteți verifica dacă șirul conține un singur caracter din intervalul utilizând simbolul -:

/ ^ $ / / ^ $ / TEST ("a") // ✅ / ^$$/.test ("ab") // ❌

Inversiunea șablonului

Simbolul ^ la începutul șablonului leagă la începutul liniei.

Folosind acest simbol în interiorul intervalului inversează intervalul, deci:

/ [I-za-z0-9] /. Test ("a") // ❌ / [и ада-za-z0-9] /. Test ("1") // ❌ / [^ a-za - Z0-9] /. Test ("a") // ❌ / [и ада-za-z0-9] / Test ("@") // ✅

Metacteri

• \\ D coincide cu orice număr echivalent numeric
• \\ D coincide cu orice simbol care nu este un număr echivalent cu [^ 0-9]
• \\ W coincide cu orice simbol alfanumeric echivalent
• \\ W coincide cu orice simbol care nu este o valoare alfanumerică echivalentă cu [^ a-za-z0-9]
• \\ s coincide cu orice pictogramă spațială: spațiu, filă, simbol al unui nou rând și spații Unicode
• Este coincide cu orice simbol care nu este un gol
• \\ 0 coincide cu null
• \\ n coincide cu un simbol nou de linie
• \\ t coincide cu simbolul tab-ului
• \\ uxxxx coincide cu simbolul Unicode cu codul XXXX (eticheta U este necesară)
• . Coincide cu orice simbol, cu excepția unui nou simbol de șir (cum ar fi \\ n) (dacă nu utilizați steagul S, explicați mai târziu)
• [^] Coincide cu orice simbol, inclusiv un nou simbol șir. Utile când lucrați cu șiruri de caractere

Selecție în expresii regulate

Dacă doriți să alegeți una sau Alte șir, utilizați operatorul | .

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

Cuantificator

Imaginați-vă că aveți o expresie regulată care verifică șirul pentru a consta doar de la o singură cifră:

poți să folosești cuantificator ? care va face acest simbol opțional. În cazul nostru, cifra ar trebui să aibă loc 0 sau 1 timp:

dar dacă vrem ca expresia regulată să aibă câteva cifre?

Puteți să o faceți în 4 moduri folosind +, *, (n) și (n, m).

+

Coincide cu unul sau mai multe elemente (\u003e \u003d 1):

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

*

Coincide cu 0 sau mai multe elemente (\u003e \u003d 0):

/ ^ \\ d + $ / / ^ \\ / тест ("12) // ✅ / ^ \\ d.7 / .test (" 14 ") // ✅ / ^ \\ d * $ /. testul (" 144343 ") // ✅ / ^ \\ d * $ /. Test (" ") // ✅ / ^ /d.7/.test("1") // ❌

(N)

Coincide exact cu numărul de elemente:

/ ^ \\ d (3) $ / / //d(3) / ✅ / ^ \\ d (3) $ /. test ("12") // ❌ / ^ ^ D (3) $ /. TEST ("1234") // ❌ / ^ (3 )$/.test ("abc") // ✅

(N, m)

Coincide cu gama de la elementele N la M:

/ ^ \\ D (3.5) $ / ^ ^ d (3,5) $ / Test ("123") // ✅ / ^ \\ d (3,5) $ / Test ("21234") // ✅ / ^ \\ d (3,5) $ /.test( 12345 ") // ✅ / ^ \\ d (3,5) $ / Test (" 123456 ") // ❌

m pot fi omise și lasă a doua limită fără restricții, astfel încât să existe un nivel minim de n:

/ ^ \\ d (3,) $ / ^ \\ d (3,) $ / Test ("2) // ❌ / ^ \\ d (3,) $ / Test (" 123) // ✅ / ^ \\ D (3.12345 ") // ✅ / ^ \\ d (3,) $ / Test (" 123456789 ") // ✅

Elemente opționale

Elementul de semnare următor? , faceți-o opțională:

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

Grupuri

Folosind paranteze, puteți crea grupuri de simboluri (...).

Exemplul de mai jos caută o coincidență exactă de 3 cifre urmată de una sau mai multe caractere alfanumerice:

/ ^ (\\ d (3)) (\\ w +) $ /) (\\ d (3)) (\\ w +) $ / Test ("123) // ❌ / ^ (\\ d (3)) ( \\ W +) $ // Test ("123s") // ✅ / ^ (\\ d (3)) (\\ w +) $ / Test ("223something") // ✅ / ^ (\\ d (3)) (\\ W +) $ / Test ("1234") // ✅

Repetarea caracterelor care se găsesc după grupul de închidere a parantezelor aparțin întregului grup:

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

CAPTURE GROUP.

Până acum am văzut cum să testăm liniile și să verific dacă conțin un șablon specific.

Posibilitatea reci de expresii regulate este aceea capturați anumite părți ale liniei și puneți-le într-o matrice.

Puteți să o faceți cu ajutorul grupurilor sau mai degrabă cu cAPTURE GROUP..

În mod implicit, grupurile sunt capturate. Acum, în loc de a utiliza regexp.test (șir), care pur și simplu returnează o valoare logică, vom folosi una din următoarele metode:

• String.match (regexp)
• Regexp.exec (șir)

Ele sunt absolut aceleași și ambele returnează o matrice cu un șir condus ca primul element, cât și în celelalte elemente ale coincidenței pentru fiecare grup găsit.

Dacă nu au fost găsite coincidențe, acesta returnează nul.

"123S" .Match (/ ^ (\\ (\\ d (3)) (\\ w +) $ /) // Array ["123s", "123", "123s"] / ^ (\\ d (3)) (\\ W +) $ / exec ("123s") // Array ["123s", "123", "s"] "Hei" .Match (/ (Hei | HO) /) // Array ["Hei", "Hey"] /( (Hei ") // matrice [" Hei "," Hei "] / (Hei | ho) / exec (" ha! ") // null

Când grupul se potrivește de mai multe ori, atunci numai ultima valoare va fi adăugată la matricea returnată.

"123456789" .Match (/ (\\ d) + /) // matrice ["123456789", "9"]

Grupuri opționale

Grupurile de captură pot fi făcute opționale cu (...)? . Dacă nu se găsește nimic, elementul nedefinit va fi adăugat la matricea returnată:

/ ^ (\\ D (3))) () (\\ w +) $ /. Exec ("23 s") // matry ["123 s", "123", "," s "] / ^ ( \\ D (3)) (\\ s)? (\\ w +) $ // Exec ("123s") // Array ["123s", "123", nedefinit, "s"]

Legătura cu grupul găsit

Fiecare grup găsit este atribuit un număr. $ 1 se referă la primul element, $ 2 la al doilea, și așa mai departe. Acest lucru este util atunci când vom vorbi despre înlocuirea unei părți a liniei.

Numed CAPTURE GROUP.

Aceasta este o nouă caracteristică ES2018.

Grupul poate fi atribuit un nume, și nu doar un slot în matricea de întoarcere:

Const re \u003d / (? \\ D (4)) - (? \\ D (2)) - (? \\ D (2)) / const rezultat \u003d re.exec ("2015-01-02") // rezultat.Groups.year \u003d\u003d\u003d "2015"; // rezultat.Groups.month \u003d\u003d\u003d "01"; // rezultat.Groups.day \u003d\u003d\u003d "02";

Folosind meciul și exec fără grupuri

Există o diferență atunci când se utilizează meciul și exec fără grupuri: În primul element, matricea nu va fi găsită pe deplin, ci o coincidență directă:

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

Lipped Groups.

Deoarece grupurile implicite sunt capturate, avem nevoie de o modalitate de a ignora unele grupuri din matricea returnată. Acest lucru este posibil cu grupuri arsecare începe cu (?: ...).

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

Steaguri

Puteți utiliza următoarele steaguri cu privire la orice expresii regulate:

• g: Căutați coincidențe la nivel global
• i: face o expresie regulată care nu este sensibilă la înregistrare
• m: Include modul multi-linie. În acest mod, ^ și $ coincid cu începutul și sfârșitul întregului rând. Fără acest steag, cu șiruri de caractere, coincid cu începutul și sfârșitul fiecărui rând.
• u: include suport Unicode (adăugat la ES6 / ES2015)
• s: (Nou în ES2018) Reducerea de la "o singură linie", permite. Coincide cu simbolurile unei linii noi

Steagurile pot fi combinate, precum și sunt adăugate la sfârșitul liniei literale:

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

sau sunt transmise de al doilea parametru în constructorul de obiecte REGEXP:

Nou regexp ("Hei", "Ig"). Test ("Hei") // ✅

Inspectarea expresiilor regulate

Puteți inspecta proprietățile expresiilor regulate:

• sursă - linia de șablon
• multiline - Adevărat este luat dacă steagul M este setat
• valoarea globală - adevărată este acceptată dacă steagul G este setat
• ignorare - valoarea este adevărată dacă pavilionul I este setat
• lastIndex.

/ ^ (\\ w (3)) $ / i.source // "^ (\\\\ d (3)) (\\\\ w +) $" / ^ (\\ w (3)) $ / i.multiline // Fals / ^ (\\ W (3)) $ / i.lastindex // 0 / ^ (\\ w (3)) $ / i.ignorcase // true / d (\\ w (3)) $ / i.global / / FALSE.

Ecranul

Simboluri speciale:

Acestea sunt caractere speciale deoarece sunt caractere de control atunci când elaborează expresii regulate, deci dacă doriți să le utilizați pentru a căuta coincidențe în interiorul șablonului, atunci trebuie să le protejați folosind un simbol al slash-ului invers:

/ ^ \\\\ $ / / ^ \\ ^ $ / // / ^ \\ ^ Test ("^") ✅ / ^ \\ $ /. Test ("$") ✅

Frontiere de șir

\\ B și \\ B vă permit să determinați dacă șirul este la începutul cuvântului sau la sfârșitul cuvântului:

• \\ B coincide dacă setul de caractere este la începutul sau la sfârșitul cuvântului
• \\ B coincide dacă setul de caractere nu este la începutul sau la sfârșitul cuvântului

"Am văzut un urs" .Match (/ \\ bebear /) // Array ["urs"] "Am văzut o barbă" .Match (/ \\ bebear /// Array ["urs"] "Am văzut o barbă" .Match (/ \\ bbbear \\ b /) // null "cool_bear" .match (/ \\ bbbear \\ b /) // null

Înlocuirea cu expresii regulate

Am văzut deja cum să verificăm liniile pentru a se potrivi cu șablonul.

De asemenea, am văzut cum să extragem o parte din rândurile corespunzătoare șablonului într-o matrice.

Acum să ne uităm la cum Înlocuiți o parte a liniei Pe baza șablonului.

Obiectul șirului din JavaScript are o metodă de înlocuire () care poate fi utilizată fără expresii regulate pentru o înlocuire în linie:

"Bună ziua!". Înlocuiți ("Lumea", "câine") // Hello Dog! "Câinele meu este un câine bun!". Înlocuiți ("câine", "pisica") // pisica mea este un câine bun!

Această metodă poate primi, de asemenea, o expresie regulată ca argument:

"Bună ziua!" Înlocuiți (/ World /, "câine") // Hello Dog!

Folosind steagul g este - acest lucru singura cale Înlocuiți mai multe evenimente în rândul pe Vanilla JavaScript:

"Câinele meu este un câine bun!". Înlocuiți (/ câine / g, "pisică") // pisica mea este o pisică bună!

Grupurile ne permit să facem mai multe lucruri bizare, să schimbăm părți ale liniilor:

"Bună ziua, lumea!". Înlocuiți (/ (\\ W +), (\\ W +)! /, "$ 2: $ 1 !!!") // "Lumea: Bună ziua!"

În loc de un șir, puteți folosi funcția pentru a face lucruri și mai interesante. Acesta va fi transferat într-o serie de argumente, cum ar fi String.Match (Regexp) sau Regexp.exec (String) metode întoarce, unde numărul de argumente depinde de numărul de grupe:

"Bună, Lumea!". Înlocuiți (/ (\\ W +), (\\ W +)! /, (Matched, primul, secund) \u003d\u003e (consola.log (primul); consola.log (al doilea); returnare ` $ (second.touppercase ()): $ (primul) !!! `)) // "WORLD: Hello !!!"

Lăcomie

Se numesc expresii regulate lacom Mod implicit.

Ce înseamnă?

Luăm, de exemplu, este o expresie regulată:

/ \\ $ (. +)? /

Se presupune că trebuie să extragem suma în dolari de la linie:

/\\$(.+)'s?/.exec ("Acest lucru costă 100 $") // 0

dar dacă avem mai multe cuvinte după număr, distrage atenția

/ \\ $ (. +)) \\ s? /. Exec ("Acest lucru costă 100 $ și este mai mic de 200 $") // 100 și este mai mic de 200 de dolari

De ce? Deoarece expresia regulată după semnul $ coincide cu orice simbol. + Și nu se oprește până când ajunge la capătul liniei. Apoi se oprește, pentru că e? face ca spațiul final să fie opțional.

Pentru a remedia, trebuie să specificăm că expresia regulată ar trebui să fie leneş Și găsiți cel mai mic număr de coincidențe. Putem face acest lucru cu simbolul? După cuantificator:

/\\$(.++?) /S/.exec ("Acest lucru costă 100 $ și este mai mic de 200 USD) // 100

Deci, simbolul? poate însemna lucruri diferite în funcție de poziția sa, astfel încât acesta poate fi un cuantificator și un indicator leneş Mod.

Înainte: șir de potrivire în funcție de ceea ce urmează

Utilizarea? \u003d Pentru a căuta coincidențe într-un șir pentru care urmează un substring definit

/ Roger (? \u003d Waters) / / Roger (? \u003d Waters) /. Testul ( "Roger My Dog") // false / Roger (? \u003d Waters) /. Testul ( "Roger este câinele meu și Roger Waters este un Muzicianul celebru ") // Adevărat

Efectuează o operație inversă și găsește coincidențe în șirul pentru care nu Un substring clar urmează:

/ Roger (?! Waters) / / Roger (?! Ape) /. Test ("Roger este câinele meu") // Adevărat / Roger (?! Waters) / Celebrul muzician ") // FALSE

Retrospectivă: șir de potrivire în funcție de ceea ce îl precedă

Aceasta este o nouă caracteristică ES2018.

Înainte utilizează un simbol? \u003d. Retrospectivă utilizează?<= :

/(?<=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

Inversiunea retrospectivă utilizează?

/(?

Expresii regulate și unicode

Steagul U este obligatoriu atunci când lucrați cu șirurile Unicode, în special atunci când poate fi necesar să se proceseze linii în planurile astrale care nu sunt incluse în primele 1600 de caractere Unicode.

De exemplu, Emodi, dar numai ei.

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

Prin urmare, utilizați întotdeauna steagul u.

Unicode, precum și personaje obișnuite, pot procesa intervalele:

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

JavaScript verifică codurile de prezentare internă, deci?< ? < ? на самом деле \u1F436 < \u1F43A < \u1F98A . Посмотрите полный список эмодзи чтобы увидеть коды и узнать их порядок.

Proprietăți de screening Unicode.

Așa cum am spus mai sus, într-un șablon de expresie regulată, puteți utiliza \\ D pentru a găsi o coincidență pe orice cifre, \\ S pentru a găsi un meci pe orice caracter în afară de un spațiu, \\ W pentru a găsi o coincidență pe orice simbol alfanumeric etc.

Proprietățile de ecranare este unicode.Versiunile posibilitatea ES2018, care adaugă o funcție foarte rece, extinderea acestui concept pe toate caracterele unicode și adăugarea de \\ p () și \\ p ().

Orice simbol Unicode are un set de proprietăți. De exemplu, scriptul definește familia limbilor, ASCII este o valoare logică egală cu adevărat pentru caracterele ASCII etc. Puteți pune această proprietate în paranteze Curly și expresia regulată va verifica dacă valoarea sa a fost adevărată:

/ ^ / U_ascii) + $ /U.Test("abc ") // ✅ / ^ \\ p (ASCII) + $ / u.Test (" [E-mail protejat]") // ✅ / ^ \\ p (SCII) + $ /U.TEST (" ABC? ") / ❌

ASCII_HEX_DIGIT este o altă proprietate logică care verifică dacă șirul conține numai numere valide de înaltă alcalină:

/ ^ / P (Scii_Hex_Digit) + $ / u.Test ( "0123456789Abcdef") // ✅ / ^ \\ p_ascii_hex_digit) + $ / u.test ( "h")

Există multe alte proprietăți logice pe care le puteți verifica prin simpla adăugare de numele lor în acolade, inclusiv cu litere mari, LowerCase, White_Space, alfabetice, emoticonuri și altele:

/ ^ /U.Test("h ") // ✅ / ^ \\ p (majuscule) $ /U.Test("h") // ✅ / ^ \\ p (emoji) + $ / U.Test ( "H ") // ❌ / ^ \\ p (emoji) + $ / u.test (" ?? ") // ✅

În plus față de aceste proprietăți binare, puteți verifica orice proprietate a simbolului Unicode corespund unei anumite valori. În exemplul de mai jos, verific dacă șirul din alfabetul latin sau latin este înregistrat:

/ ^ Cro_script \u003d greacă) + $ / u.test ("ελληνικά") // ✅ / ^ \\ p (script \u003d latină) + $ / u.test ("hei") // ✅

Exemple

Extracția unui număr dintr-un șir

Să presupunem că există un șir care conține doar un număr care trebuie eliminat. / \\ d + / ar trebui să o facă:

"Testul 123123329" .Match (/ \\ d + /) // Array ["123123329"]

Căutați adrese de e-mail:

Cea mai simplă abordare este să verificați caracterele incredibile înainte și după semnul @, cu ajutorul lui:

/ (\\ S +) @ (\\ s +) \\ ((\\ s +) / / (@ s +) @ (\\ s +) \\. (\\ S +) /. Exec (" [E-mail protejat]") //["[E-mail protejat]"," Copesc "," Gmail "," COM "]

Cu toate acestea, acesta este un exemplu simplificat, deoarece există multe adrese de e-mail care nu sunt valabile în cadrul acesteia.

Capturați textul între ghilimele duble

Imaginați-vă că aveți un șir care conține prizonier de text în ghilimele duble și trebuie să extrageți acest text.

Cel mai bun mod de a face acest lucru este de a utiliza cAPTURE GROUP.Pentru că știm că coincidență noastră ar trebui să înceapă și se termină cu simbolul“, astfel încât să putem configura cu ușurință șablonul, dar, de asemenea, dorim sa eliminam aceste citate din rezultat.

Vom găsi ceea ce avem nevoie în rezultat:

Const hello \u003d "salut" floare frumos "" const rezultat \u003d / "([_" "*" /.eexec(hello) // Array ["\\" frumos floare \\ "", "floare frumos"]

Obținerea conținutului de la eticheta HTML

De exemplu, obțineți conținutul de la eticheta de span, permițând orice număr de argumente pentru etichetă:

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

Clasa Regexp din JavaScript este o expresie regulată - un obiect care descrie șablonul de caractere. Obiectele REGEXP sunt de obicei create folosind sintaxa specială a literalmentelor de mai jos, dar pot fi, de asemenea, create de Constructorul Regexp ().

Sintaxă

// Folosind o sintaxă literală specială var regex \u003d / model / steaguri; // cu designerul var regex \u003d nou regexp ("model", "steaguri"); var regex \u003d nou regexp (/ model /, "steaguri");

Valorile parametrilor:

Steaguri de expresii regulate

Steag	Descriere
g.	Vă permite să găsiți toate coincidențele și să nu vă opriți după prima coincidență ( flag Global Match.).
i.	Vă permite să comparați fără înregistrarea ( ignorați steagul casei).
m.	Maparea se face în mai multe rânduri. Procesarea caracterelor inițiale și finale (^ și $) se face în funcție de mai multe linii, adică cartografierea are loc cu începutul sau sfârșitul fiecărui rând (\\ n sau \\ r dividers), și nu numai cu începutul sau sfârșitul întregii linii ( flag multiline.).
u.	Șablonul va fi considerat ca o secvență de puncte de cod Unicode ( unicode pavilion.).
y.	Cartografia are loc în indexul la care indică proprietatea LastIndex a acestei expresii regulate, în timp ce cartografierea nu este făcută mai târziu sau indicele timpuriu ( steagul lipicios.).

Seturi de simboluri

Metacteri

Simbol	Descriere
.	Vă permite să găsiți un caracter, cu excepția simbolul unui nou șir de caractere, sau sfârșitul șirului (\\ n, \\ r, \\ u2028 sau \\ u2029).
\\ D.	Vă permite să găsiți un simbol al numerelor din alfabetul latin de bază. Echivalentine Utilizați setul de caractere.
\\ D.	Vă permite să găsiți orice caracter care nu este o cifră în alfabetul latin de bază. Echivalent cu un set de caractere [^ 0-9].
\\ S.	Vă permite să găsiți un singur simbol gol. Sub simbolul spațial este înțeleasă ca un spațiu, tabularea, traducerea paginii, traducerea șirului și a altor simboluri globulare ale Unicodului. Echivalent cu un set de caractere [\\ f \\ n \\ r \\ t \\ v \\ u00a0 \\ u1680 \\ u180e \\ u2000 \\ u2001 \\ u2002 \\ u2003 \\ u2004 \\ u2005 \\ u2006 \\ u2007 \\ u2008 \\ u2009 \\ u2008 \\ u2009 \\ u2008 \\ U2028 \\ u2029 \\ u202f \\ u205f \\ u3000].
\\ S.	Vă permite să găsiți un singur simbol care nu este un gol. Sub simbolul spațial este înțeleasă ca un spațiu, tabularea, traducerea paginii, traducerea șirului și a altor simboluri globulare ale Unicodului. Echivalent cu un set de caractere [^ \\ u00A0 \\ u1680 \\ u001 \\ u2000 \\ u2001 \\ u2008 \\ u2006 \\ u2007 \\ u2008 \\ u2009 \\ u2008 \\ u2009 \\ u2008 \\ U2028 \\ u2029 \\ u202f \\ u205f \\ u3000].
[\\ b]	Vă permite să găsiți simbolul backspace (simbol special \\ b, u + 0008).
\0	Vă permite să găsiți un simbol 0 (zero).
\\ N.	Vă permite să găsiți un nou simbol șir.
\\ F.	Vă permite să găsiți un simbol de traducere a paginii.
\\ R.	Vă permite să găsiți un simbol de returnare a căruciorului.
\\ T.	Vă permite să găsiți un simbol al filei orizontale.
\\ V.	Vă permite să găsiți un simbol al filei verticale.
\\ W.	Vă permite să găsiți orice simbol alfanumeric al alfabetului latin de bază, inclusiv sublinierea. Echivalentă cu un set de caractere.
\\ W.	Vă permite să găsiți orice caracter care nu este un simbol din alfabetul latin de bază. Echivalent cu un set de caractere [^ a-za-z0-9_].
\\ Cx.	Vă permite să găsiți un simbol de control în șir. În cazul în care X este litera de la A la Z., de exemplu, / \\ cm / denotă simbolul Ctrl-M.
\\ Xhh.	Vă permite să găsiți un simbol folosind valoarea hexazecimală (HH este o valoare hexazecimală din două cifre).
\\ uhhhh.	Vă permite să găsiți un simbol utilizând codarea UTF-16 (valoarea hexazecimală HHHH - patru cifre).
\\ U (hhhh) sau \\ U (hhhhh)	Vă permite să găsiți un simbol cu \u200b\u200bvaloarea Unicode U + HHHH sau U + HHHHH (hexazecimal). Numai când este specificat pavilionul U.
\	Indică faptul că următorul caracter este special și nu ar trebui interpretat literalmente. Pentru simboluri, care sunt de obicei interpretate într-un mod special, indică faptul că următorul caracter nu este special și trebuie interpretat literal.

Restricții

Cuantificator

Simbol	Descriere
n *	Mișcarea are loc cu orice șir care conține zero sau mai multe apariții ale simbolului n..
n +.	Mosiul are loc cu orice șir care conține cel puțin un caracter n..
n?	Mișcarea are loc cu orice șir cu un element anterior n. Zero sau o dată.
n (x)	Corespunde oricărui rând care conține o secvență de caractere n. Un anumit număr de ori x.. X.
n (x,)	x. Expoziții ale elementului anterior n.. X. Trebuie să existe un număr întreg pozitiv.
n (x, y)	Corespunde oricărui rând care conține cel puțin x.dar nu mai mult decât în \u200b\u200bcazul în care y. Intrările elementului precedent n.. X. și y. Trebuie să existe numere pozitive întregi.
n *? N +? N ?? n (x)? n (x,)? n (x, y)?	Mișcarea are loc prin analogie cu cuantificatorii *, +,? și (...) Cu toate acestea, în timp ce căutarea merge o comparație minimă posibilă. Implicit este modul "lacom"? La sfârșitul cuantificatorului vă permite să specificați modul "Unjone" la care repetarea comparației are loc numărul minim de câte ori.
x (? \u003d y)	Vă permite să comparați x.Numai dacă pentru x. urma y..
x Y)	Vă permite să comparați x.Numai dacă pentru x. nu o face y..
x | y.	Comparația are loc cu oricare dintre alternativele indicate.

Gruparea și backlink-uri

Simbol	Descriere
(X)	Vă permite să găsiți un simbol x. și amintiți rezultatul comparației ("paranteze incitante"). Un substring comparativ poate fi cauzat de elementele de matrice care rezultă ..., [n], sau din proprietățile obiectului Regexp predefinite de $ 1 ..., $ 9.
(?: X)	Vă permite să găsiți un simbol x.Dar nu să memoreze rezultatul comparației ("paranteze non-lipsă"). Un substring compilat nu poate fi cauzat de elementele matricei rezultate ..., [N] sau de la proprietățile obiectului regexp predexat $ 1 ..., $ 9.
\\ N.	Link-ul opus ultimului înlocuitorului, care coincide cu N-o, într-un cont în paranteze în termeni regulate (numerotarea parantezele se duce la stânga la dreapta). n. Trebuie să existe un număr întreg pozitiv.

Expresii obisnuite Permiteți o căutare flexibilă a cuvintelor și a expresiilor în texte pentru a le elimina, a le extrage sau a le înlocui.

Sintaxă:

// prima opțiune pentru crearea unei expresii regulate var regexp \u003d nou regexp ( șablon,modificatori.); // a doua versiune a creării unei expresii regulate var regexp \u003d / șablon/modificatori.;

șablon Vă permite să setați șablonul de caractere pentru căutare.

modificatori. Permiteți-vă să configurați comportamentul de căutare:

• i. - căutarea fără înregistrarea cazului de scrisori;
• g. - Căutarea globală (toate coincidențele vor fi găsite în document, și nu doar pe primul);
• m. - Căutare multi-line.

Căutați cuvinte și expresii

Cea mai simplă utilizare a expresiilor regulate este găsirea unor cuvinte și expresii în diferite texte.

Să dăm un exemplu de utilizare a căutării folosind modificatori:

// setați expresia regulată RV1 RV1 \u003d / Rusia /; // setați expresia regulată RV2 RV2 \u003d / Rusia / g; // setați expresia regulată Rv3 RV3 \u003d / Rusia / IG; // Este alocat un font îndrăzneț, unde coincidențele vor fi găsite în text atunci când se utilizează // expresii Rv1: Rusia este cea mai mare stare din lume. Rusia se învecinează cu 18 țări. Rusia este continuitul de stat al URSS. // Este alocat un font îndrăzneț, unde coincidențele vor fi găsite în text atunci când sunt utilizate // expresii Rv2: Rusia este cea mai mare stare din lume. Rusia se învecinează cu 18 țări. Rusia este statul-continuatorul URSS „; // Fat Font alocat, în cazul în care coincidențe vor fi găsite în text atunci când se utilizează // Expresii RV3:. Rusia este cel mai mare stat al lumii frontierelor Rusia cu 18 tari Rusia.. este un stat - succesorul URSS ".

Simboluri speciale

În plus față de caracterele convenționale în șabloanele de expresie regulate pot fi utilizate simboluri speciale (Metacteri). Caracterele speciale cu descrieri sunt prezentate în tabelul de mai jos:

Simbol special	Descriere
.	Coincide cu orice simbol, cu excepția simbolului capătului de la șir.
\\ W.	Coincide cu orice simbol alfabetic.
\\ W.	Coincide cu orice simbol al alfabetic.
\\ D.	Coincide cu caracterele care sunt numere.
\\ D.	Coincide cu caractere care nu sunt numere.
\\ S.	Coincide cu simbolurile lamei.
\\ S.	Coincide cu simbolurile spațiale.
\\ B.	Coincidențele vor fi căutate numai la limitele cuvintelor (la început sau la sfârșit).
\\ B.	Coincidențele vor fi distorsionate doar nu la limitele cuvintelor.
\\ N.	Coincide cu un simbol de traducere rând.

/ * Expression Reg1 va găsi toate cuvintele care încep cu două scrisori arbitrare și terminând cu "veterinar". Deoarece cuvintele din propunere sunt împărțite de un spațiu, apoi la început și la sfârșitul anului vom adăuga specialsimol \\ s) * / reg1 \u003d / / s .. s / g; TXT \u003d "Hello Legământ Velvetet"; Document.write (txt.match (reg1) + "
"); "
"); TXT1 \u003d" pe player Oh High Pret "; / * expresie reg3 va găsi toate cuvintele care încep pe" cu "în care urmează apoi 1 cifră și se termină pe" Vet "* / var reg3 \u003d / cu \\ DVL / G ; Documentul .write (txt1.match (Reg3) + "
"); // expresie REG4 va găsi toate numerele din textul var reg4 \u003d / \\ d / g; txt2 \u003d" 5 ani de studiu, 3 ani de înot, de 9 ani de fotografiere. "Document.Write (TXT2.match (Reg4) + "
");

Vizualizare rapidă

Simboluri în paranteze pătrate

Folosind paranteze pătrate [Kayu] Puteți specifica un grup de caractere pe care trebuie să le produceți.

Simbol ^ în fața unui grup de caractere în paranteze pătrate [^ qd] Aceasta sugerează că este necesar să căutați toate caracterele alfabetului, altele decât cele specificate.

Folosind linia (-) între simbolurile din paranteze pătrate [AA] Puteți seta gama de caractere, pe care doriți să o produceți.

Cu ajutorul parantezelor pătrate, puteți căuta și numere.

// setați expresia regulată reg1 Reg1 \u003d / \\ sco [TDM] \\ s / g; // setați șirul textului TXT1 TXT1 \u003d "Codul de scuipat Cat Kom Kommersant"; // Produceți utilizând expresia regulată REG1 Căutare pe linia TXT1 Document.Write (Txt1.match (Reg1) + "
"); Reg 2 \u003d / \\ slo [^ tg] / g; txt2 \u003d" slot slot slot "; document.write (txt2.match (reg2) +"
"); Reg 3 \u003d // g; TXT3 \u003d" 5 ani de studiu, 3 ani de înot, de 9 ani de fotografiere "; document.write (txt3.match (REG3));

Vizualizare rapidă

Cuantificator

Cuantificator - Acest design vă permite să setați de câte ori simbolul care a precedat-o sau un grup de caractere ar trebui să se întâlnească într-o coincidență.

Sintaxă:

// simbolul precedent ar trebui să îndeplinească x - ori (X) // simbolul precedent ar trebui să se întâlnească de la x la un timp incluziv (X y) // simbolul precedent trebuie să îndeplinească cel puțin x ori (X,) // indică faptul că simbolul precedent trebuie să aibă loc 0 sau de mai multe ori * // indică faptul că simbolul precedent ar trebui să se întâlnească de 1 sau mai multe ori + // indică faptul că simbolul precedent trebuie să apară 0 sau 1 ori ?

// Setați expresia regulată RV1 RV1 \u003d / Co. (5) WAT / G // Setați expresia regulată RV2 RV2 \u003d / KO (3) WATDER / G // Setați expresia regulată RV3 RV3 \u003d / Co + WAT / G // Setare expresie regulată RV4 RV4 \u003d / ko apă / G // Setați expresia regulată RV5 RV5 \u003d / KO * WATDER / G // prezintă caractere aldine în cazul în care coincidențe vor fi găsite în text folosind expresii // RV1?: Cushka Cat Kooshka Cat Antrenorul Koooooh Co -oooooooooooooooooooooooo // arată cu caractere aldine în cazul în care textul va fi găsit în text atunci când se utilizează // Expresiile RV2: Cash Cat Cat koo-doooooooooooookhop Cooooooooookh Coooooooohokha // Font Bold arată unde coincidențele vor fi găsite în text atunci când se utilizează // expresii Rv3: Cushka cat Kooshka Coooshop Coooookhoko KoooooooOoOoooHka // arată cu caractere îngroșate în cazul în care textul va fi găsite în text atunci când se utilizează // expresiilor RV4: Cash Cat Kooshop COOOOOKHOK COOOOOOKHOKA COOOO -OOOKHOP COOOOOOHKA // Bold font arată în cazul în care textul va fi găsite în text folosind expresii // RV5: casca Cat Cat Kooshka Kooooooooooooooooooooooooooooooooooooooo

Notă: Dacă doriți să utilizați orice simbol special (cum ar fi. * +? Sau ()) modul în care obișnuitul trebuie să puneți în fața lui \\.

Folosind paranteze rotunde

Introducând o parte din șablonul de expresie obișnuit în paranteze, specificați expresia pentru a vă aminti coincidența, găsită de această parte a șablonului. Coincidența salvată poate fi utilizată mai târziu în codul dvs.

De exemplu, expresia regulată / (Dmitry) \\ Svasiliev / va găsi linia "Dmitri Vasilyev" și va aminti substringul "Dmitri".

În exemplul de mai jos, folosim metoda Înlocuire () pentru a schimba ordinea cuvântului din text. Pentru a face apel la coincidența salvată, folosim $ 1 și $ 2.

Var regexp \u003d / (dmiry) \\ s (vasilyev) /; Var Text \u003d "Dmitri Vasilyev"; Var NewText \u003d text.Replace (REGEXP, $ 2 $ 1); Document.write (NewText);

Vizualizare rapidă

Parantezele rotunde pot fi folosite pentru a grupa caractere înainte de cuantificator.

Unii oameni, cu care se confruntă o problemă, cred că: "Oh, și folosesc expresii regulate". Acum au două probleme.
Jamie Runovsky.

Yuan-Ma a spus: "Este nevoie de multă putere pentru a tăia un copac peste structura lemnului. O mulțime de coduri este necesară pentru a programa prăbușirea problemei.
Master of Yuan-Ma, "Carte de programare"

Instrumentele și tehnicile de programare supraviețuiesc și distribuite de un mod haotic-evolutiv. Uneori supraviețuiesc nu sunt frumoase și ingenioase, ci pur și simplu celor care lucrează destul de bine în domeniul lor - de exemplu, dacă sunt integrați într-o altă tehnologie de succes.

În acest capitol, vom discuta acest instrument - expresii regulate. Aceasta este o modalitate de a descrie șabloanele în datele de șir. Ele creează o mică limbă separată care este inclusă în JavaScript și în multe alte limbi și unelte.

Regularitățile regulate sunt foarte ciudate și extrem de utile. Sintaxa lor este misterioasă, iar interfața de program din JavaScript este stângace. Dar acesta este un instrument puternic pentru procesarea cercetării și a rândurilor. După ce ați înțeles cu ei, veți deveni un programator mai eficient.

Creați expresie regulată

Regulat este tipul de obiect. Acesta poate fi creat prin apelarea constructorului Regexp sau prin scrierea modelului dorit, înconjurat de strițe.

Var re1 \u003d nou regexp ("abc"); Var re2 \u003d / abc /;

Ambele expresii regulate reprezintă un șablon: simbolul "A" urmat de simbolul "B" urmat de simbolul "C".

Dacă utilizați constructorul REGEXP, atunci șablonul este scris ca un șir regulat, astfel încât toate regulile sunt relativ la straturile inverse.

A doua intrare, în care șablonul este între întârziere, procesează în mod diferit accidentele inverse. În primul rând, deoarece modelul se termină cu o pistă dreaptă, atunci trebuie să puneți o inversă în fața plăcii directe pe care vrem să le includem în șablonul nostru. În plus, accidentele inverse care nu fac parte din caracterele speciale ale tipului \\ n vor fi salvate (și nu sunt ignorate, ca în linii) și să schimbe semnificația șablonului. Unele caractere, cum ar fi un semn de întrebare sau un plus, sunt de o importanță deosebită în regularitățile obișnuite, iar dacă trebuie să găsiți un astfel de simbol, ar trebui să pregătiți și piesa inversă.

Varice optsprezece \u003d / optsprezece \\ /;

Pentru a afla care caractere aveți nevoie pentru a preveni o slash, trebuie să învățați o listă cu toate caracterele speciale în mod regulat. În timp ce este nerealist, astfel încât, în caz de îndoială, puneți exact inversa în fața oricărui simbol care nu este o literă, număr sau spațiu.

Verificați coincidența

Autoritățile de reglementare au mai multe metode. Cel mai simplu - testul. Dacă îi dați un șir, acesta va returna valoarea booleană, raportând dacă linia conține înregistrarea șablonului specificat.

Consola.log (/abc/.test ("abcde")); // → True Console.log (/abc/.test ("abxde")); // → falsă

Regular, constând doar din caractere non-speciale, reprezintă pur și simplu secvența acestor caractere. Dacă ABC este undeva în linia pe care o verificăm (nu numai la început), testul va reveni la adevărat.

Căutăm un set de caractere

Pentru a afla dacă șirul ABC conține, ar fi posibil cu indexarea. Vă permit în mod regulat să mergeți mai departe și să faceți modele mai complexe.

Să presupunem că trebuie să găsim orice număr. Când setăm setul de caractere în paranteze pătrate în paranteze obișnuite, aceasta înseamnă că această parte a expresiei coincide cu oricare dintre caracterele din paranteze.

Ambele expresii sunt în liniile care conțin cifra.

Consola.log (//. Testul ("în 1992")); // → True Console.Log (//. Testul ("în 1992")); // → adevărat.

În paranteze pătrate, linia între două caractere este utilizată pentru a specifica intervalul de caractere, unde secvența este setată la codarea Unicode. Simbolurile de la 0 la 9 există pur și simplu într-un rând (coduri de la 48 la 57), astfel încât le captează pe toate și coincide cu orice cifră.

Mai multe grupuri de caractere au propriile reduceri încorporate.

\\ D orice cifră
\\ w simbol alfanumeric
\\ s simbol pătură (spațiu, fila, traducere rând, etc.)
Nu o cifră
\\ W nu este un simbol alfanumeric
Nu este un simbol gol
. Orice simbol, cu excepția liniei de traducere

În acest fel, puteți întreba formatul și formatul de timp cum ar fi 30-01-2003 15:20 prin următoarea expresie:

Vary datetime \u003d / \\ d \\ d- \\ d \\ d \\ d \\ d \\ d \\ d \\ d \\ d \\ d \\ d: Consola.log (datetime.test ("30-01-2003 15:20")); // → True Console.Log (DateTime.Test ("30-Jan-2003 15:20")); // → falsă

Pare teribil, nu? Prea multe straturi inverse, ceea ce face dificilă înțelegerea șablonului. Mai târziu, o vom îmbunătăți ușor.

Accidentele inverse pot fi de asemenea utilizate în paranteze pătrate. De exemplu, [\\ d] înseamnă orice cifră sau punct. Rețineți că punctul din interiorul parantezelor pătrate își pierde valoarea specială și se întoarce pur și simplu până la punct. Același lucru este valabil și pentru alte caractere speciale, tip +.

Inversați un set de caractere - adică să spuneți că aveți nevoie pentru a găsi orice caracter, cu excepția celor din set - puteți, punerea unui semn ^ imediat după suportul pătratului de deschidere.

Var notbinary \u003d / [^ 01] /; Consola.log (Notbinary.test ("1100100010100110")); // → Console false.log (Notbinary.test ("1100100010200110")); // → adevărat.

Repetăm \u200b\u200bpărți ale șablonului

Știm cum să găsim o singură cifră. Și dacă trebuie să găsim numărul în întregime - o secvență de una sau mai multe cifre?

Dacă puneți după ceva în semnul regulat +, acesta va însemna că acest element poate fi repetat de mai multe ori. / \\ d + / înseamnă una sau mai multe cifre.

Consola.log (/ "\\ d +" /. Test ("" 123 "")); // → True Console.Log (/ "\\ d +" /. Test ("" "" ")); // → Console false.Log (/ "\\ d *" /. Test ("" 123 "")); // → True Console.Log (/ "\\ d *" /. Test ("" "" ")); // → adevărat.

În stele * Valoarea este aproape aceeași, dar permite șablonul să participe la zero ori. Dacă după ceva stă stelele, atunci nu împiedică niciodată șablonul să găsească șablonul în șir - este pur și simplu de zero.

Marcajul de întrebare face parte din șablon opțional, adică se poate întâlni zero sau o dată. În exemplul următor, se poate produce simbolul U, dar șablonul coincide când nu este.

Var Vecin \u003d / Vecinii? R /; Consola.log (vecinul (vecin ")); // → Consola True.log (vecinul "(vecin")); // → adevărat.

Pentru a stabili un număr exact de momente pe care șablonul trebuie să le îndeplinească, sunt utilizate paranteze curată. (4) După ce elementul înseamnă că ar trebui să se întâlnească în linie de 4 ori. De asemenea, puteți seta decalajul: (2.4) înseamnă că elementul trebuie să îndeplinească cel puțin 2 și nu mai mult de 4 ori.

O altă versiune a datei și a timpului, unde sunt permise zile, luni și două cifre de la una sau două cifre. Și ea este mai lizibilă.

Vary datetime \u003d / \\ d (1,2) - \\ d (1,2) - \\ d (4) \\ d (1,2): \\ d (2) /; Consola.log (datetime.test ("30-1-2003 8:45")); // → adevărat.

Puteți utiliza intervalele cu un capăt deschis, coborând unul dintre numere. (5) înseamnă că șablonul se poate întâlni de la zero la cinci ori și (5,) - de la cinci sau mai mult.

Gruparea unui abonament

Pentru a utiliza operatorii * sau + pe mai multe elemente imediat, puteți utiliza paranteze. O parte din paranteze regulate, închise, este considerată un element din punctul de vedere al operatorilor.

Var cartooncrying \u003d / boo + (hoo +) + / i; Consola.log (cartooncrying.test ("boohoooohooooooo")); // → adevărat.

Primul și al doilea avantaj includ doar a doua litere despre cuvintele lui Boo și Hoo. Al treilea + se referă la un grup întreg (HOO +), găsind una sau mai multe astfel de secvențe.

Scrisoarea I la sfârșitul expresiei face ca insensibilul periodic la registrul de simbol - astfel încât B coincide cu b.

Coincidențe și grupuri

Metoda de testare este cea mai ușoară metodă de verificare a regulatorilor. El raportează doar dacă a fost găsită o coincidență sau nu. Autoritățile de reglementare au o altă metodă exec, care va reveni null dacă nu a fost găsită nimic și altfel obiectul va reveni cu informații despre coincidență.

VAR MATCH \u003d /\\D+/.exec ("unu doi 100); Consola.log (meci); // → ["100"] consola.log (meci.index); // → 8.

Un obiect EXEC returnat are o proprietate index, care conține numărul de caractere din care sa întâmplat coincidența. În general, obiectul arată ca o serie de corzi, unde primul element este un șir care a fost verificat într-o coincidență. În exemplul nostru, va fi secvența cifrelor pe care le căutăm.

Corzile au o metodă de potrivire care funcționează la fel.

Consola.log ("unu doi 100" (/ \\ d + /)); // → ["100"]

Când conține în mod regulat o depunență grupată de paranteze rotunde, textul care a coincis cu aceste grupuri va apărea și în matrice. Primul element este întotdeauna o coincidență întreagă. Cea de-a doua este o parte care a coincis cu primul grup (cel care a avut paranteze rotunde mai devreme decât toate), apoi cu al doilea grup și așa mai departe.

Var citatext \u003d / "([^"] *) "/; console.log (citatext.exec (" ea a spus "salut" ")); // → [" salut "", "salut"]

Când grupul nu a fost găsit deloc (de exemplu, dacă semnul de întrebare este în spatele ei), poziția sa în matrice conține nedefinit. Dacă grupul a coincis de mai multe ori, atunci în matrice va fi doar ultima coincidență.

Consola.log (/ rău (ly)? /. Exec ("rău")); // → ["rău", nedefinit] consolă.log (/ (/ d) + /. Exec ("123")); // → ["123", "3"]

Grupurile sunt utile pentru extragerea pieselor parțiale. Dacă nu trebuie doar să verificăm dacă linia de date este în linie și să o eliminați și să creați un obiect reprezentând data, putem intra într-un număr de numere în paranteze și selectați o dată de la Exec.

Dar pentru a începe cu o ușoară scădere în care învățăm modul preferat de stocare a datei și a timpului în JavaScript.

Tipul de dată.

JavaScript are un tip standard de obiect pentru date - sau mai degrabă, momente în timp. Se numește data. Dacă creați doar un obiect de dată prin New, veți primi data și aplicația curentă.

Consola.log (data nouă (); // → soare noiembrie 09 2014 00:07:57 gmt + 0300 (CET)

De asemenea, puteți crea un obiect care conține ora specificată.

Consola.log (nouă dată (2015, 9, 21)); // → căsătorie 21 octombrie 2015 00:00:00 GMT + 0300 (CET) console. Log (noua dată (2009, 11, 9, 12, 59, 59, 999)); // → căsătorie 09 2009 12:59:59 GMT + 0300 (CET)

JavaScript utilizează un acord în care numerele încep cu zgârieturile și numărul de zile de la unitate. Este prost și ridicol. Dute sus.

Ultimele patru argumente (ore, minute, secunde și milisecunde) sunt opționale și în absența egală cu zero.

Etichetele de timp sunt stocate ca număr de milisecunde care au trecut de la începutul anilor 1970. Pentru moment până în 1970 se utilizează numere negative (acest lucru se datorează acordului de timp UNIX, care a fost creat la aproximativ). Metoda de obținere a obiectului de dată returnează acest număr. Este în mod natural mare.
Consola.log (noua dată (2013, 11, 19) .gettime ()); // → 1387407600000 consola.log (noua dată (1387407600000)); // → thu 19 2013 00:00:00 GMT + 0100 (CET)

Dacă specificați o dată, un argument, este perceput ca un număr de milisecunde. Puteți obține valoarea actuală milisecundă prin crearea obiectului de dată și apelarea metodei GetTime sau apelând la funcția Data.now.

Obiectul de dată pentru a extrage componentele sale are grijă, getmonth, getdate, getours, getminute și getsescuni. Există, de asemenea, o metodă de getyear care returnează un cod de două cifre destul de inutil, tipul 93 sau 14.

Prin încheierea părților necesare ale șablonului în paranteze, putem crea un obiect de dată direct de la șir.

FUNCȚIA FINDDATE (String) (Var Datetime \u003d / (\\ D (1,2)) - (\\ d (4)) /; var "\u003d datetime.exec (șir); returnare Data nouă (numărul (meciul), numărul (meciul) - 1, numărul (meciul));) consola.log (Findate ("30-1-2003")); // → → Jan 30 2003 00:00:00 GMT + 0100 (CET)

Frontiere ale cuvântului și a rândului

Din păcate, Finddate, de asemenea, elimină cu bucurie o dată fără sens 00-1-3000 de la linia "100-1-30000". Coincidența se poate întâmpla oriunde în linie, deci în acest caz va începe doar de la al doilea simbol și terminat pe penultimă.

Dacă trebuie să forțăm o coincidență pentru a lua întreaga linie a întregului, folosim etichete ^ și $. ^ coincide cu începutul liniei și $ cu sfârșitul. Prin urmare, / ^ \\ d + $ / coincide cu un șir constând din doar una sau mai multe cifre, / ^! / Coincide cu partenerul începând cu o marcă de exclamare și / x ^ / nu se potrivesc cu nici o linie (înainte de a începe linia nu poate fi x).

Dacă, pe de altă parte, trebuie doar să ne asigurăm că data începe și se termină la marginea cuvântului, folosim eticheta \\ b. Limita cuvântului poate fi începutul sau sfârșitul șirului sau orice loc al liniei, unde, pe de o parte, este simbolul alfanumeric-digital \\ w și pe celălalt - nu alfanumeric.

Consola.log (/cat/.test ("concatenat")); // → True Console.Log (/ \\ bcat \\ b / .test (concatenate ")); // → falsă

Rețineți că eticheta de frontieră nu este un simbol. Este doar o limitare care indică faptul că coincidența are loc numai dacă se efectuează o anumită stare.

Șabloane cu alegeri

Să presupunem că este necesar să aflați dacă textul nu conține doar un număr și numărul urmat de porc, vacă sau de pui într-un singur număr sau mai multe.

Ar fi posibil să scrieți trei în mod regulat și să le verificați la rândul său, dar există o modalitate mai bună. Simbol | Indică alegerea între șabloanele din stânga și la dreapta. Și putem spune următoarele:

Var un animal-animal \u003d / \\ b \\ d + (porc | vacă | pui) s? \\ B /; Consola.log (animalcount.test ("15 porci")); // → True Console.Log (animalCount.Test (15 Pigchickens)); // → falsă

Parantezele limită a șablonului la care |, și puteți pune o mulțime de astfel de operatori unul cu celălalt pentru a desemna alegerea a mai mult de două opțiuni.

Mecanismul de căutare

Expresiile regulate pot fi considerate ca fiind deficiențe. Următoarea diagramă descrie ultimul cod animal.

Expresia coincide cu șirul dacă puteți găsi calea din partea stângă a diagramei spre dreapta. Ne amintim poziția curentă a rândului și de fiecare dată, trecând un dreptunghi, verificați acea parte a liniei imediat în spatele poziției noastre, coincide cu conținutul dreptunghiului.

Deci, verificarea coincidenței regularității noastre regulate în linia "Cei 3 porci" atunci când trecerea pe diagrama bloc pare a fi:

În poziția 4 există o graniță a cuvântului și trecem primul dreptunghi
- Începând cu 4 poziții găsim o cifră și trecem al doilea dreptunghi
- În poziția 5, o singură cale se închide în fața celui de-al doilea dreptunghi, iar al doilea se întoarce la dreptunghi cu un spațiu. Avem un spațiu, nu o cifră și alegem al doilea mod.
- Acum suntem în poziția 6, începutul "porcilor" și despre ramificarea triplă a căilor. Nu există nicio linie "vacă" sau "pui", dar există un "porc", așa că alegem această cale.
- În poziția 9 după o ramificație triplă, o singură cale de bypass și se îndreaptă spre ultimul dreptunghi cu limita cuvântului, iar al doilea trece prin "S". Avem "S", așa că mergem acolo.
- Pe poziția 10, noi la sfârșitul liniei, și coincidența poate doar la granița cuvântului. Sfârșitul liniei este considerat limita și trecem prin ultimul dreptunghi. Și așa am găsit cu succes șablonul nostru.

În principiu, expresii regulate funcționează după cum urmează: algoritmul începe la începutul liniei și încearcă să găsească o coincidență acolo. În cazul nostru, există o graniță a Cuvântului, așa că trece primul dreptunghi - dar nu există numere, așa că el se împiedică pe cel de-al doilea dreptunghi. Apoi se mută la al doilea simbol în linie și încearcă să găsească o coincidență acolo ... și așa mai departe până când găsește o coincidență sau nu ajunge la sfârșitul liniei, caz în care se găsește coincidența.

Kickbacks.

Regular / \\ b (+ b | \\ d + | [\\ da-f] h) \\ b / coincide fie cu un număr binar, urmat de B sau cu un număr zecimal fără sufix sau hexazecimal (numere de la 0 la 9 sau simboluri de la A la H), urmată de h. Diagrama relevantă:

În căutarea coincidenței, se poate întâmpla ca algoritmul a mers pe calea de sus (numărul binar), chiar dacă nu există un astfel de număr în linie. Dacă există un șir "103", de exemplu, este clar că numai algoritmul Figurilor 3 va înțelege că este pe calea greșită. În general, linia coincide cu regulile, doar nu în această ramură.

Apoi algoritmul face o răsturnare. Pe furculiță, își amintește poziția curentă (în cazul nostru, este începutul liniei, imediat după limita cuvântului), astfel încât să puteți reveni și să încercați un alt mod dacă selectați nu funcționează. Pentru un șir "103" După întâlnirea cu primele trei, el se va întoarce și va încerca să treacă calea pentru numere zecimale. Va funcționa, deci coincidența va fi găsită.

Algoritmul se oprește de îndată ce va găsi coincidența completă. Aceasta înseamnă că, chiar dacă mai multe opțiuni se pot aborda, este utilizată doar una dintre ele (în ordinea în care acestea apar în regulat).

Rolurile apar atunci când se utilizează operatori de repetare, cum ar fi + și *. Dacă sunteți în căutarea pentru / ^ *. * / În șirul abcxe, parte a regulilor. * Încearcă să absoarbă întreaga linie. Algoritmul va da seama apoi de faptul că avea nevoie de "x". Deoarece nu "x" după sfârșitul liniei nu este, algoritmul va încerca să caute o coincidență, aruncându-se la un caracter. După ABCX, nu există și x, apoi el din nou se rotește, deja la substringul ABC. Și după linie, el găsește X și raportează despre o coincidență reușită, în poziții de la 0 la 4.

Puteți scrie în mod regulat, ceea ce va duce la revoluții multiple. O astfel de problemă apare atunci când șablonul poate coincide cu setul de date de intrare de metode diferite. De exemplu, dacă facem o greșeală atunci când scriem în mod regulat pentru numerele binare, putem scrie accidental ceva de genul / (+) + b /.

Dacă algoritmul va căuta un astfel de șablon într-un rând lung de neoluri și unități care nu conține la sfârșitul "B", va trece mai întâi prin bucla interioară până când se termină numerele. Apoi, el va observa că la capăt nu există nici un "B", va face o rambursare pentru o singură poziție, va avea loc pe bucla exterioară, va renunța din nou, încercați să reluați înapoi la o altă poziție pe bucla interioară .. . Și va fi în continuare să caute calea, ciclism ambele balamale. Adică, cantitatea de lucru cu fiecare simbol rând se va dubla. Chiar și pentru câteva duzini de caractere, căutarea de coincidență va dura foarte mult timp.

Înlocuiți metoda

Corzile au o metodă de înlocuire care poate înlocui o parte a liniei unui alt șir.

Consola.log ("tată". Înapoi ("p", "m")); // → Mapa.

Primul argument poate fi regulat, caz în care se înlocuiește cu prima intrare a regularității regulate în șir. Când se adaugă opțiunea "G" (Global, Universal) în mod regulat, toate intrările sunt înlocuite și nu doar primele

Consola.log ("borobudur". Accept (// "a")); // → Barobudur Console.Log ("Borobudur" .Replace (// G, "A")); // → Barabadar.

Ar avea sens să transmită opțiunea "Înlocuiți toate" printr-un argument separat sau printr-o metodă separată înlocuită. Dar, din păcate, opțiunea este transmisă prin intermediul în mod regulat.

Toate regulatoarele de alimentare sunt dezvăluite atunci când folosim referințe la cele găsite în șirul de grup setat în mod regulat. De exemplu, avem un șir care conține numele de oameni, un nume pe linie, în formatul "prenume, nume". Dacă trebuie să le schimbăm în locuri și să eliminăm virgulă, astfel încât numele numelui este "Nume", scriem următoarele:

Consola.log ("Hopper, Grace \\ NmcCarthy, John \\ nritchie, Dennis" .Ră (([\\ w] +), ([w w] +) / g, "$ 2 $ 1")); // → Hopper Grace // John McCarthy // Dennis Ritchie

$ 1 și $ 2 în linia de înlocuire se referă la grupuri de caractere închise în paranteze. $ 1 se înlocuiește cu textul care a coincis cu primul grup, $ 2 - cu al doilea grup și așa mai departe, până la 9 dolari. Întreaga coincidență este conținută în $ &.

De asemenea, puteți transfera atât un al doilea argument ca al doilea argument. Pentru fiecare înlocuitor, va fi cauzată o funcție, argumentele care sunt găsite grupuri (și întreaga coincidență a întregii linii), iar rezultatul său va fi introdus într-un șir nou.

Simplu exemplu:

Var S \u003d "CIA și FBI"; Consola.log (s.replace (/ \\ b (FBI | cia) \\ b / g, funcție (retur Str.touppercase ();))); // → CIA și FBI

Dar mai interesant:

Var stoch \u003d "1 lămâie, 2 varză și 101 ouă"; Funcție minusonă (potrivire, cantitate, unitate) (cantitate \u003d număr (cantitate) - 1; dacă (suma \u003d\u003d 1) // numai unul a rămas, ștergeți "S" la capătul unității \u003d unitate.Slover (0, unitate .Lentalități - 1); , minus unu)); // → nici o lămâie, 1 varză și 100 de ouă

Codul ia șirul, găsește toată intrarea numerelor, urmată de cuvânt și returnează linia în care fiecare număr este redus cu unul.

Grupul (\\ d +) se încadrează în argumentul cantității, A (\\ W +) - în unitate. Funcția convertește cantitatea la numărul - și funcționează întotdeauna, deoarece șablonul nostru este doar \\ D +. Și apoi face schimbări în cuvânt, în cazul în care doar 1 element rămâne.

Lăcomie

Este ușor să înlocuiți pentru a scrie o funcție care elimină toate comentariile din codul JavaScript. Iată prima încercare:

Funcția de stripturi (cod) (cod de returnare.Replace (/ \\ / \\ / ** | \\ / \\ * [g, "");) Console.log (strâmtoarea ("1 + / * 2 * / 3 ")); // → 1 + 3 console.log (strâmtoarea ("x \u003d 10 // zece!"); // → x \u003d 10; Consola.log (strâmtoarea ("1 / * a * / + / * b * / 1")); // → 1 1

Partea din fața operatorului "sau" coincide cu două feluri, urmată de orice număr de caractere, cu excepția simbolului traducerii rând. O piesă care elimină comentariile multi-line este mai complexă. Folosim [^], adică Orice caracter care nu este gol ca o modalitate de a găsi orice caracter. Nu putem folosi punctul, deoarece comentariile blocului continuă pe noua linie, iar simbolul de traducere de linie nu se potrivește cu punctul.

Dar ieșirea exemplului anterior este incorectă. De ce?

Partea [^] * Încercați mai întâi să capturați cât mai multe personaje. Dacă, din acest motiv, următoarea parte a celor regulate nu găsește coincidențe, se va întoarce la un singur caracter și va încerca din nou. În exemplu, algoritmul încearcă să captureze întregul șir și apoi se rotește înapoi. Falling la 4 caractere în urmă, el va găsi în linie * / - și asta nu este ceea ce am realizat. Am vrut să capturăm doar un singur comentariu și să nu trecem prin linie și să găsim comentariul final.

Din acest motiv, spunem că operatorii repetați (+, *, și ()) lacomi, adică, mai întâi captează cât pot, apoi se întorc. Dacă puneți o întrebare după un astfel de operator (+?, *?, (), ()?), Acestea se vor transforma în mod nejustificat și vor începe să găsească cele mai mici intrări posibile.

Și asta avem nevoie. Forțând stelele să găsească coincidențe în cel mai mic număr posibil de simboluri de cusături, absorb doar un bloc de comentarii și nimic mai mult.

Funcția de stripturi (cod) (cod de returnare.Replace (/ \\ //.*** \\ / \\ * [g, "");) console.log (strâmtoarea ("1 / * A * / + / * B * / 1 ")); // → 1 + 1

Multe erori apar atunci când se utilizează operatori lacomi în loc de nejustificare. Când utilizați operatorul de repetare, primiți întotdeauna opțiunea unui operator Unjudene.

Dynamic Crearea obiectelor Regexp

În unele cazuri, șablonul exact este necunoscut în timp ce scrie codul. De exemplu, va trebui să căutați numele de utilizator în text și să îl introduceți într-un accent. Deoarece veți afla numai după începerea programului, nu puteți utiliza înregistrarea cu stivuitul.

Dar puteți construi un șir și puteți utiliza constructorul REGEXP. Iată un exemplu:

Numele Var \u003d "Harry"; Var text \u003d "și Harry pe cicatricea frunții."; var regexp \u003d nou regexp ("\\\\ b (" + nume + ") \\\\ b", "gi"); consola.log (text.replace (regexp, "$ 1_")); // → și la _ggarry_ pe cicatricea frunții.

La crearea limitelor, cuvântul trebuie să folosească straturi duble, deoarece le scriem într-o linie normală și nu în mod regulat cu scări drepte. Al doilea argument pentru REGEXP conține opțiuni pentru autoritățile de reglementare - în cazul nostru "GI", adică Global și independent de înregistrare.

Dar dacă numele este "DEA + HLRD" (dacă utilizatorul nostru este Kulkhazker)? Ca rezultat, vom obține în mod regulat fără sens, ceea ce nu va găsi în linia de coincidențe.

Putem adăuga reacția la orice simbol pe care nu-l place. Nu putem adăuga lovituri inverse în fața literelor, deoarece \\ b sau \\ n este un amestec special. Dar puteți adăuga cu ușurință blocați în fața oricăror simboluri digitale alfabetic.

Var nume \u003d "DEA + HLRD"; Var Text \u003d "Această DEA + HLRD a primit toată lumea."; var a scăpat \u003d name.replace (/ [^ ^ ^ \\ s] / g, "\\\\ $ &"); var regexp \u003d nou regexp ("\\\\ b (" + a scăpat + ") \\\\ b", "gi"); consola.log (text.replace (regexp, "$ 1_")); // → acest _dea + hlrd_ a primit toată lumea.

Metoda de căutare.

Metoda indexului nu poate fi utilizată cu regulile regulate. Dar există o metodă de căutare care așteaptă doar regulate. Ca și indexarea, aceasta returnează indicele primei intrări sau -1, dacă nu sa întâmplat.

Consola.log ("cuvânt" .Cazar (/ s /)); // → 2 console.log (".Cazar (/ s /)); // → → -1.

Din păcate, este imposibil să se stabilească metoda de căutare a unei coincidență, începând cu o compensare specifică (așa cum se poate face cu indexarea). Ar fi util.

Proprietate LastIndex.

EXEC Metoda nu permite o modalitate convenabilă de a începe să căutați dintr-o poziție dată în șir. Dar o modalitate incomodă dă.

Regulatoarele de obiecte au proprietăți. Unul dintre ele este o sursă care conține un șir. Un altul este LastIux, care controlează, în unele condiții în care va începe următoarea căutare a evenimentelor.

Aceste condiții includ necesitatea prezenței opțiunii Globale G și faptul că căutarea ar trebui să utilizeze metoda EXEC. O soluție mai rezonabilă ar fi pur și simplu permisă să permită un argument suplimentar de transmitere a executării, dar raționalitatea nu este o caracteristică fundamentală în interfața de reglementare JavaScript.

Var 0 \u003d / y / g; Model.LastIndex \u003d 3; Var meci \u003d modelul.exec ("xyzzy"); Consola.log (meci.Index); // → 4 console.log (model.lasindex); // → 5.

Dacă căutarea a avut succes, apelul EXEC actualizează proprietatea LastIndEx, astfel încât să indice o poziție după intrarea găsită. Dacă nu a existat niciun succes, LastIudex este instalat în zero - precum și LastIndEx în obiectul Doar creat.

Când utilizați variabila globală regulată și mai multiplă EXEC, aceste actualizări automate LastIndex pot duce la probleme. În mod regulat poate începe o căutare din poziția rămasă din apelul anterior.

Var digit \u003d / \\ d / g; Consola.log (digit.exec (aici este: 1 ")); // → ["1"] consolă.log (digit.exec ("și acum: 1")); // → null.

Un alt efect interesant al opțiunii G este că modifică activitatea metodei de potrivire. Când se numește această opțiune, în loc să returneze o matrice, asemănătoare cu rezultatul de lucru EXEC, acesta găsește toată intrarea șablonului în șir și returnează o matrice de la substringul găsit.

Consola.log ("banană" .Match (/ en / g)); // → ["un", "un"]

Atât de atent cu variabilele globale. În cazurile în care sunt necesare - apelurile înlocuiesc sau locurile în care utilizați în mod specific LastIndex - poate toate cazurile în care acestea ar trebui aplicate.

Cicluri introducând

O sarcină tipică este să treceți prin toate intrările șablonului din șir, astfel încât să aveți acces la obiectul de meci în corpul ciclului utilizând LastErindex și Exec.

Var input \u003d "cusatura cu 3 numere in ea ... 42 si 88."; VAR Numărul \u003d / \\ b (\\ d +) \\ b / g; Var meci; În timp ce (meciul \u003d numără.exec (intrare)) consolă.log ("găsit", se potrivesc, "pe", meci.index); // → găsit 3 până la 14 // găsite 42-33 // găsite 88-40

Faptul că atribuirea valorii este atribuită valorii. Folosind designul de meci \u003d re.exec (intrare) ca o condiție în timp, producem o căutare la începutul fiecărei iterații, salvăm rezultatul într-o variabilă și terminând ciclul când se găsesc toate coincidențele.

Audierea fișierelor INI.

În încheierea capitolului, luați în considerare sarcina utilizând autoritățile de reglementare. Imaginați-vă că scriem un program care colectează informații despre dușmanii noștri prin Internet în modul automat. (Nu voi scrie întregul program, numai partea care citește fișierul cu setările. SORRY.) Fișierul arată astfel:

SEARCHENGINE \u003d http: //www.google.com/search? Q \u003d $ 1 Spite Fitefulfulfulfie \u003d 9.7; Înainte de comentarii, este plasat punctul; Fiecare secțiune se aplică unui inamic separat Fullname \u003d Larry Doe Type \u003d bychar de la site-ul de grădiniță \u003d http: //www.geocities.com/capecanaveral/11451 FullName \u003d Gargamel Tip \u003d Angry Wizard Outputdir \u003d / Home / Marijn / Gargamel

Formatul exact al fișierului (care este utilizat foarte mult și este de obicei numit INI), următoarele:

Șirurile goale începând cu un punct și virgulă sunt ignorate
- rândurile închise în paranteze pătrate încep o nouă secțiune
- Rânduri care conțin identificatorul alfanumeric, urmate de \u003d, adăugați setări în această secțiune.

Orice altceva este date incorecte.

Sarcina noastră este de a converti un astfel de șir într-o serie de obiecte, fiecare cu proprietatea numelui și gama de setări. Pentru fiecare secțiune, aveți nevoie de un obiect și încă o dată - pentru setările globale din partea de sus a fișierului.

Deoarece fișierul ar trebui să fie dezasamblat linia, nu este rău să începeți cu ruperea fișierului în șir. Pentru a face acest lucru, în capitolul 6 am folosit șir.split ("\\ n"). Unele operațiuni sunt utilizate pentru a transfera linia nu a unui caracter \\ n și două - \\ r \\ n. Deoarece metoda divizată ia în mod regulat ca argument, putem împărți linia utilizând o expresie / \\ r? \\ N /, permițând și un singur \\ n și \\ r \\ n între rânduri.

Funcție parseini (șir) (// porniți de la un obiect care conține setări de nivel superior VAR CRINDERSECING \u003d (Nume: Null, câmpuri :); Var certificări \u003d; string.split (/ \\ r? \\ N /). FOREACH (FUNCTION (FUNCTION (FUNCTION ( Linie) (VAR Match; dacă (/ \\ ^ / s * (;;. *)? $ / TEST (LINE)) (retur)) ) $$ /)) (Codingsection \u003d (nume: meci, câmpuri :); categorii.push (Codingsection);) altfel dacă (meci \u003d line.match (/ ^ (\\ w +) \u003d (. *) $ /) ) (CurrentSection. Fields.push ((nume: meci, valoare: meci));) altceva (aruncați o eroare nouă ("Stitch" + linia + "" conține date incorecte ");)))))))

Codul trece toate liniile prin actualizarea secțiunii curente "Secțiunea curentă". La început verifică dacă este posibil să ignori linia, cu ajutorul regulate / \\ ^ (;; *)? $ /. Luați în considerare modul în care funcționează? O parte dintre paranteze coincide cu comentariile, EH? Acest lucru coincide în mod regulat cu liniile constând din unele spații.

Dacă șirul nu este un comentariu, codul verifică dacă începe o nouă secțiune. Dacă da, creează un obiect nou pentru secțiunea curentă la care se adaugă setările ulterioare.

Ultima caracteristică semnificativă este un rând este o configurație normală, iar în acest caz se adaugă obiectul curent.

Dacă nu a funcționat nici o opțiune, funcția oferă o eroare.

Observați cât de frecventă folosește și $ se îngrijește de faptul că expresia coincide cu întregul șir al întregului și nu cu o parte. Dacă nu le folosiți, codul în ansamblu va funcționa, dar uneori vor exista rezultate ciudate, iar această eroare va fi dificil de urmărit.

Designul IF (Match \u003d String.match (...)) este similar cu un truc care utilizează alocarea ca o condiție în ciclul de timp. Adesea, nu știți că apelul de potrivire va avea succes, astfel încât să puteți accesa obiectul rezultat numai în interiorul blocului dacă verificați. Pentru a nu rupe un lanț frumos dacă verificați, atribuim rezultatul căutării variabilei și folosim imediat această sarcină ca o verificare.

Simboluri internaționale

Datorită implementării inițial simple a limbii și fixarea ulterioară a acestei implementări "în granit", JavaScript în mod regulat prost cu simboluri care nu apar în limba engleză. De exemplu, simbolul "scrisorilor" din punct de vedere al regulatorilor JavaScript poate fi una dintre cele 26 de litere ale alfabetului englez și, din anumite motive, chiar accentuează. Literele de tip é sau β, în mod unic au fost scrise, nu coincid cu \\ W (și coincid cu \\ W, adică, cu o literă).

Conform unei coincidență ciudată, istoric (spațiu) coincide cu toate personajele care sunt considerate a fi glibble, incluzând astfel de lucruri ca un spațiu indispensabil sau un separator de vocală mongol.

În unele implementări, autoritățile de reglementare din alte limbi au o sintaxă specială pentru a căuta categorii speciale de caractere Unicode, cum ar fi "toate literele majuscule", "toate semnele de punctuație" sau "caracterele de control". Există planuri de adăugare a unor astfel de categorii în JavaScript, dar par să fie implementate în curând.

Rezultat

Regularitățile regulate sunt obiecte reprezentând modele de căutare în linii. Ei folosesc sintaxa lor pentru a exprima aceste șabloane.

/ secvența ABC / Simbol
// orice simbol din listă
/ [^ Abc] / orice caracter, cu excepția caracterelor din listă
// orice simbol al decalajului
/ x + / una sau mai multe apariții de șablon x
/ x +? / unul sau mai multe apariții, undead
/ x * / zero sau mai multe apariții
/ x / zero sau o intrare
/ x (2.4) / de la două la patru apariții
/ (Abc) / grup
/ A | b | c / oricare dintre mai multe șabloane
/ \\ d / orice cifră
/ \\ w / orice simbol alfanumeric ("Letter")
/ \\ s / orice simbol gol
/./ Orice simbol, cu excepția rândului de traducere
/ \\ b / cuvântul frontieră
/ ^ / Linia de start
/ $ / Linia de sfârșit

Regular are o metodă de testare, pentru a verifica dacă există un model într-un șir. Există o metodă EXEC care returnează o matrice care conține toate grupurile găsite. Masivul are o proprietate index, unde numărul de caractere din care sa întâmplat coincidența.

Corzile au o metodă de potrivire pentru a căuta șabloane, iar metoda de căutare returnează numai poziția inițială de intrare. Metoda Înlocuire poate înlocui intrarea șablonului la un alt șir. În plus, puteți trece funcția în înlocuire care va construi o linie de înlocuire bazată pe șablon și grupuri găsite.

Regulatoarele au setări care sunt scrise după o lovitură de închidere. Opțiunea I fac un regulat dependent de caz, iar opțiunea G G o face globală, care, printre altele, face ca metoda înlocuită să înlocuiască toate lucrurile găsite și nu doar la prima.

Regexp Designer poate fi folosit pentru a crea rânduri regulate.

Regular - un instrument ascuțit cu un mâner incomod. Ei simplifică foarte mult unele sarcini și pot deveni incontrolabile în rezolvarea altor sarcini complexe. O parte din capacitatea de a folosi regularitatea regulată este de a putea rezista tentației de a face lucrurile în ele sarcina pentru care nu sunt intenționate.

Exerciții

În mod inevitabil, atunci când rezolvați sarcinile, veți avea cazuri incomprehensibile și puteți uneori disperarea, văzând comportamentul imprevizibil al unor autorități de reglementare. Uneori vă ajută să explorați comportamentul în mod regulat prin serviciul online al Debuggex.com, unde puteți vedea vizualizarea și comparați cu efectul dorit.

Golf regulat

"Golf" în cod se numește jocul în care trebuie să exprimați un anumit program cu un număr minim de caractere. Golful regulat este un exercițiu practic privind scrierea celor mai mici autorități de reglementare pentru a căuta un anumit șablon și numai ea.

Pentru fiecare substrat, scrieți regulat pentru a le verifica în rând. În mod regulat trebuie să găsească aceste substring specifice. Nu vă faceți griji cu privire la limitele cuvintelor, dacă nu sunt menționate mai ales. Când obțineți o lucrare obișnuită, încercați să o reduceți.

Masina si pisica.
- Pop și Prop
- Ferret, Ferry și Ferrari
- Orice cuvânt care se termină cu iOS
- spațiu, urmat de un punct, virgulă, colon sau virgulă.
- lungimea cuvintelor șase litere
- cuvânt fără litere e

// introduceți vermiy-ul obișnuit (/.../, ["mașina mea", "pisici rele"], ["camper", "Arta ridicată"]); Verificați (/.../, ["cultura pop", "Props Mad"], ["Plop"]; Verificați (/.../, ["ferret", "Ferry", "Ferrari"], ["Ferrum", "transfer a"]); Verificați (/.../, ["Cât de delicios", "camera spațioasă"], ["ruinoasă", "conștiința"]); Verificați (/.../, ["Punctuația rea"], ["Escape The Dot"]); Verificați (/.../, ["Hottentotențialtenen"], ["Nu", "Hotten Totten Tenten"]); Verificați (/.../, ["roșu platypus", "cuibul wobbling"], ["patul pământului", "învățarea maimuței"]); Funcție Verificați (regexp, da, nu) (// ignora exerciții nefinisate dacă (regexp.source \u003d\u003d "...") retur; da.Foreceh (funcția (funcțiile) (dacă (! Regexp.test (s)) consola .log ("nu a fost găsit" "+ S +" "");))); "" ");)); Nr.Fore (funcția (funcțiile) (regexp.test (e)) consolă.log (" intrare neașteptată "+ s +" "") ;);)

Citate în text

Să presupunem că ați scris o poveste și peste tot pentru desemnarea dialogurilor folosite citate unice. Acum doriți să înlocuiți citatele de dialoguri pentru a duble și lăsați un singur în abrevieri ale tipului nu sunt.

Vino cu un șablon care distinge două dintre aceste citate și scriu un apel la metoda de înlocuire care înlocuiește.

Din nou numerele

Secvențele de numere pot fi găsite simple regulate / \\ d + /.

Scrieți o expresie care găsește numai numerele înregistrate în stilul JavaScript. Ar trebui să mențină un posibil minus sau plus înaintea numărului, zecimal și înregistrarea exponențială 5E-3 sau 1E10 - din nou cu un posibil plus sau minus. De asemenea, rețineți că, înainte sau după punct, nu supuneți neapărat numerele, dar numărul nu poate fi alcătuit dintr-un punct. Adică .5 sau 5. - numerele admise și un punct de la sine - nr.

// Introduceți regulile regulate. Var Număr \u003d / \u003d ... $ / // Teste: ["1", "-1", "+15", "1.55", "5.", "1.3E2", "1E-4", "1E + 12"] .Fore (Funcția (funcțiile) (dacă (! Număr.test (s)) consolă.log ("nu a găsit" + s + "");)); ["1a", "+ -1", "1.2.3", "1 + 1", "1E4.5", ".5", "1f5", ""] FOREACH (Funcția (funcțiile) (Dacă (numărs.test (e)) consolă.log ("acceptat incorect" "+ S +" ");));