Greitas ir paprastas „JavaScript“ įprastų išraiškų vadovas

Norite sužinoti „JavaScript“? Gaukite nemokamą el. Knygą svetainėje jshandbook.com

Įvadas į įprastas išraiškas

Reguliari išraiška (trumpai dar vadinama regex) yra greitas būdas dirbti su teksto eilutėmis.

Suformuluodami reguliariąją išraišką su specialia sintaksė, galite:

  • ieškoti teksto eilutėje
  • pakeisti eilutes eilutėje
  • ir ištraukite informaciją iš eilutės

Beveik kiekvienoje programavimo kalboje yra įprastų išraiškų įgyvendinimas. Tarp kiekvieno diegimo yra nedideli skirtumai, tačiau bendrosios sąvokos galioja beveik visur.

Reguliarios išraiškos datuojamos šeštajame dešimtmetyje, kai jos buvo įformintos kaip konceptualus eilutės apdorojimo algoritmų paieškos modelis.

Įdiegtos UNIX priemonėse, tokiose kaip grep, sed, ir populiariuose teksto redaktoriuose, regexes populiarėjo. Jie buvo įvesti į „Perl“ programavimo kalbą, o vėliau ir į daugelį kitų.

„JavaScript“ kartu su „Perl“ yra viena iš programavimo kalbų, palaikančių įprastas išraiškas, tiesiogiai įmontuotas į kalbą.

Sunkus, bet naudingas

Reguliarūs posakiai gali atrodyti kaip absoliuti nesąmonė pradedančiajam ir daug kartų ir profesionaliam kūrėjui, jei neinvestuojate laiko, reikalingo jiems suprasti.

Kriptines reguliariąsias išraiškas sunku rašyti, sunku perskaityti ir sunku išlaikyti / modifikuoti.

Bet kartais reguliari išraiška yra vienintelis protingas būdas atlikti tam tikrus veiksmus su stygomis, todėl tai yra labai vertingas įrankis jūsų kišenėje.

Šia instrukcija siekiama supažindinti jus su „JavaScript“ įprastomis išraiškomis paprastu būdu ir suteikti jums visą informaciją skaityti ir kurti įprastas išraiškas.

Nykščio taisyklė yra ta, kad paprastas įprastas išraiškas lengva skaityti ir rašyti, tuo tarpu sudėtingos įprastos išraiškos gali greitai virsti netvarka, jei giliai nesuprantate pagrindų.

Kaip atrodo įprastinė išraiška?

„JavaScript“ kalboje reguliari išraiška yra objektas, kurį galima apibrėžti dviem būdais.

Pirmasis yra paspartinant naują „RegExp“ objektą naudojant konstruktorių:

const re1 = naujas „RegExp“ („ei“)

Antrasis yra įprastinės išraiškos pažodinės formos naudojimas:

const re1 = / ei /

Ar žinote, kad „JavaScript“ turi objekto ir masyvo rašmenis? Jame taip pat yra regex literatūros.

Aukščiau pateiktame pavyzdyje hey vadinamas modeliu. Pažodžiui jis yra apibrėžtas brūkšniais į priekį, o objekto konstruktoriaus atveju - ne.

Tai yra pirmas svarbus skirtumas tarp dviejų formų, bet kitas pamatysime vėliau.

Kaip tai veikia?

Reguliari išraiška, kurią aukščiau apibrėžėme kaip re1, yra labai paprasta. Ieškoma eilutės ei, be jokių apribojimų. Eilutėje gali būti daug teksto, o viduryje - ei, o regex yra patenkinta. Jame taip pat gali būti tiesiog ei, o regex taip pat bus patenkintas.

Tai gana paprasta.

Galite išbandyti regex naudodami „RegExp.test“ (eilutė), kuri pateikia faktinę vertę:

re1.test ('ei') // 
re1.test ('blablabla hey blablabla') // 
re1.test ('jis') // 
re1.test ('blablabla') // 

Aukščiau pateiktame pavyzdyje mes tiesiog patikrinome, ar „hey“ patenkina reguliariosios išraiškos modelį, saugomą re1.

Tai paprasčiausias gali būti, bet dabar jūs jau žinote daug sąvokų apie regexes.

Tvirtinimas

/ Ei

nesutampa su virve.

Jei norite suderinti stygas, prasidedančias hey, naudokite ^ operatorių:

/^hey/.test('hey ') // 
/^hey/.test('bla hey ') // 

Jei norite suderinti eilutes, kurios baigiasi hey, naudokite operatorių $:

/hey$/.test('hey ') // 
/hey$/.test('bla hey ') // 
/ hey$/.test('hey you ') // 

Sujunkite tas ir suderinkite stygas, kurios tiksliai atitinka ei, ir tik tą eilutę:

/^hey$/.test('hey ') // 

Norėdami suderinti eilutę, kuri prasideda po eilute ir baigiasi kita, galite naudoti. *, Kuris atitinka bet kurį ženklą, pakartotą 0 ar daugiau kartų:

/^hey.*joe$/.test('hey joe ') // 
/^hey.*joe$/.test('heyjoe ') // 
/^ hey.*joe$/.test('hey how are you joe ') // 
/^hey.*joe$/.test('hey joe! ') // 

Suderinkite elementus diapazonuose

Užuot suderinę tam tikrą eilutę, galite pasirinkti suderinti bet kurį diapazono simbolį, pvz .:

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

Šie reksai atitinka stygas, kuriose yra bent vienas iš tų diapazonų simbolių:

/[a-z / /.test('a ') // 
/[a-z / /.test('1 ') // 
/[a-z / /.test('A ') // 
/[a-c]/.test('d ') // 
/[a-c]/.test('dc ') // 

Diapazonas gali būti derinamas:

/ [A-Za-z0-9] /
/[A-Za-z0-99/.test('a ') // 
/[A-Za-z0-99/.test('1 ') // 
/[A-Za-z0-99/.test('A ') // 

Atitikimas asortimento elementui kelis kartus

Galite patikrinti, ar eilutėje yra tik vienas simbolis iš diapazono, naudodami - char:

/ ^ [A-Za-z0-9] $ /
/^[A-Za-z0-9 $ $ /.test ('A ') // 
/^[A-Za-z0-9] $$/.test('Ab ') // 

Neigiamas modelis

Rašmens pradžioje esantis simbolis ^ įtvirtina jį eilutės pradžioje.

Naudojamas diapazone, jis jį paneigia, todėl:

/[^A-Za-z0-9>/.test('a ') // 
/[^A-Za-z0-9]/.test('1 ') // 
/[^A-Za-z0-9]/.test('A ') // 
/[^A-Za-z0-9>/.test('@ ') // 
  • \ d atitinka bet kurį skaitmenį, lygų [0–9]
  • \ D atitinka bet kokį simbolį, kuris nėra skaitmuo, lygus [^ 0-9]
  • \ w atitinka bet kurį raidinį ir skaitmeninį simbolį, lygų [A-Za-z0-9]
  • \ W atitinka bet kokį nesuskaičiuojamą simbolį, lygų [^ A-Za-z0-9]
  • \ s atitinka bet kokį tarpo simbolį: tarpus, skirtukus, naujas eilutes ir „Unicode“ tarpus
  • \ S atitinka bet kurį simbolį, kuris nėra tarpas
  • \ 0 atitikmenų negalioja
  • \ n atitinka naujos eilutės simbolį
  • neatitinka skirtuko simbolio
  • \ uXXXX suderina unikodo ženklą su kodu XXXX (reikalinga u vėliava)
  • . atitinka bet kurį simbolį, kuris nėra naujos eilutės ženklas (pvz., \ n) (nebent naudojate s vėliavą, paaiškintą vėliau)
  • [^] atitinka bet kurį simbolį, įskaitant naujos eilutės simbolius. Tai naudinga daugialypėms eilutėms.

Reguliarios išraiškos pasirinkimas

Jei norite ieškoti vienos ar kitos eilutės, naudokite | operatorius.

/ hey|ho/.test('hey ') // 
/ hey|ho/.test('ho ') // 

Kiekybiniai rodikliai

Tarkime, kad turite šią regex, kuri patikrina, ar eilutėje yra vienas skaitmuo, ir nieko daugiau:

/ ^ \ d $ /

Galite naudoti? kiekybinį rodiklį, kad jis būtų pasirenkamas, taigi reikalingas nulis arba vienas:

/ ^ \ d? $ /

bet kas, jei norite atitikti kelis skaitmenis?

Tai galite padaryti 4 būdais, naudodami +, *, {n} ir {n, m}. Pažvelkime į šiuos po vieną.

+

Suderinkite vieną ar daugiau (> = 1) elementų

/ ^ \ d + $ /
/^\d+$/.test('12 ') // 
/^\d+$/.test('14 ') // 
/^\d+$/.test('144343 ') // 
/ ^ \ d + $ /. testas ('') // 
/^\d+$/.test('1a ') // 

*

Atitikite 0 ar daugiau (> = 0) elementų

/ ^ \ d + $ /
/^\d*$/.test('12 ') // 
/^\d*$/.test('14 ') // 
/^\d*$/.test('144343 ') // 
/ ^ \ d * $ /. testas ('') // 
/^\d*$/.test('1a ') // 

{n}

Tiksliai suderinkite n elementus

/ ^ \ d {3} $ /
/^\d{3}$/.test('123 ') // 
/^\d{3}$/.test('12 ') // 
/^\d{3}$/.test('1234 ') // 
/^[A-Za-z0-9]{3}$/.test('Abc ') // 

{n, m}

Atitikimas tarp n ir m kartų:

/ ^ \ d {3,5} $ /
/^\d{3,5}$/.test('123 ') // 
/^\d{3,5}$/.test('1234 ') // 
/^\d{3,5}$/.test('12345 ') // 
/^\d{3,5}$/.test('123456 ') // 

m gali būti praleistas, kad galų gale būtų atvira pabaiga, taigi jūs turite bent n elementus:

/ ^ \ d {3,} $ /
/^\d{3,}$/.test('12 ') // 
/^\d{3,}$/.test('123 ') // 
/^\d{3,}$/.test('12345 ') // 
/^\d{3,}$/.test('123456789 ') // 

Neprivalomi elementai

Sekate elementą su? daro jį neprivalomą:

/ ^ \ d {3} \ w? $ /
/^\d{3}\w?$/.test('123 ') // 
/^\d{3}\w?$/.test('123a ') // 
/^\d{3}\w?$/.test('123ab ') // 

Grupės

Naudodami skliaustelius, galite sudaryti ženklų grupes: (...)

Šis pavyzdys tiksliai atitinka 3 skaitmenis, po kurių eina vienas ar keli raidiniai skaitmeniniai ženklai:

/ ^ (\ d {3}) (\ w +) $ /
/^(\d{3})(\w+)$/.test('123 ') // 
/^(\d{3})(\w+)$/.test('123s ') // 
/^(\d{3})(\w+)$/.test((123something ') // 
/^(\d{3})(\w+)$/.test('1234 ') // 

Kartojimo ženklai, sudėti po grupės skliausteliuose, nurodo visą grupę:

/ ^ (\ d {2}) + $ /
/^(\d{2})+$/.test('12 ') // 
/^(\d{2})+$/.test('123 ') // 
/^(\d{2})+$/.test('1234 ') // 

Grupių gaudymas

Iki šiol matėme, kaip išbandyti stygas ir patikrinti, ar jose yra tam tikras raštas.

Labai šaunus įprastų išraiškų bruožas yra galimybė užfiksuoti stygos dalis ir sudėti jas į masyvą.

Tai galite padaryti naudodamiesi Grupėmis, ypač Grupių fiksavimu.

Pagal numatytuosius nustatymus grupė yra užfiksuojanti grupė. Dabar, užuot naudoję RegExp.test (String), kuris tik grąžina faktinę vertę, jei modelis patenkintas, naudojame String.match (RegExp) arba RegExp.exec (String).

Jie yra visiškai vienodi ir grąžina masyvą su visa suderinta eilute pirmame elemente, tada kiekviena atitiko grupės turinį.

Jei atitikties nėra, tai grąžina nulį:

'123s'.match (/ ^ (\ d {3}) (\ w +) $ /)
// Masyvas ["123s", "123", "s"]
/^(\d{3})(\w+)$/.exec('123s ')
// Masyvas ["123s", "123", "s"]
'hey'.match (/ (ei | ho) /)
// Masyvas ["hey", "hey"]
/(hey|ho)/.exec('hey ')
// Masyvas ["hey", "hey"]
/(hey|ho)/.exec('ha! ')
// niekinis

Kai grupė derinama kelis kartus, į rezultatų masyvą įtraukiamos tik paskutinės rungtynės:

'123456789'.match (/ (\ d) +/)
// Masyvas ["123456789", "9"]

Neprivalomos grupės

Fiksuojančią grupę galima padaryti neprivalomą naudojant (...) ?. Jei jis nerastas, gautame masyvo lizde bus neapibrėžta:

/^(\d{3})(\s)?(\w+)$/.exec('123 s ')
// Masyvas ["123 s", "123", "", "s"]
/^(\d{3})(\s)?(\w+)$/.exec('123s ')
// Masyvas ["123s", "123", neapibrėžtas, "s"]

Pamatinės grupės

Kiekvienai suderintai grupei suteikiamas numeris. 1 USD reiškia pirmąjį, 2 USD - antrąjį ir t. T. Tai bus naudinga, kai vėliau kalbėsime apie stygos dalių pakeitimą.

Pavadintos gaudymo grupėmis

Tai yra nauja ES2018 funkcija.

Grupę galima priskirti vardui, o ne tik priskirti atsiradusio masyvo angą:

const re = / (?  \ d {4}) - (?  \ d {2}) - (?  \ d {2}) /
const rezultatas = re.exec („2015-01-02“)
// rezultatas.grupės.metas === '2015';
// rezultatas.grupės.mėnuo === '01';
// rezultatas.grupės. diena === '02';

„Match“ ir „Exe“ vartojimas be grupių

Yra skirtumas tarp atitikties ir vykdymo be grupių naudojimo: pirmasis masyvo elementas yra ne visa suderinta eilutė, o atitiktis tiesiogiai:

/ hey|ho/.exec('hey ')
// [„ei“]
/(hey).(ho)/.exec('hey ho ')
// [„hey ho“, „hey ho“, „ho“]

Nefiksuojančios grupės

Kadangi pagal numatytuosius nustatymus grupės yra „Grupių gaudymas“, jums reikia būdo, kaip nepaisyti kai kurių grupių gautame masyve. Tai įmanoma naudojant nefiksuojančias grupes, kurios prasideda raide (?: ...)

'123s'.match (/ ^ (\ d {3}) (?: \ S) (\ w +) $ /)
// niekinis
'123 s'.match (/ ^ (\ d {3}) (?: \ S) (\ w +) $ /)
// Masyvas ["123 s", "123", "s"]

Vėliavos

Bet kurią įprastą išraišką galite naudoti šias vėliavas:

  • g: kelis kartus atitinka modelį
  • i: daro regex raidę nejautrią
  • m: įgalinamas kelių eilučių režimas. Šiame režime ^ ir $ atitinka visos eilutės pradžią ir pabaigą. Be to, su daugialypėmis eilutėmis jie sutampa su kiekvienos eilutės pradžia ir pabaiga.
  • u: įgalina unikodo palaikymą (įvesta ES6 / ES2015)
  • s: (nauja ES2018 programoje), nesusijusi su viena eilute, sukelia. kad atitiktų ir naujus eilutės simbolius.

Vėliavas galima sujungti, o jos pridedamos eilutės pabaigoje pagal regekso rašmenis:

/ hey/ig.test('HEy ') // 

arba kaip antrąjį parametrą naudojant „RegExp“ objektų konstruktorius:

naujas „RegExp“ („Ei“, „Ig“) .testas („Ei“) // 

Apžiūrima regex

Atsižvelgiant į regex, galite patikrinti jo savybes:

  • šaltinis modelio eilutę
  • daugialypė tiesa su m vėliava
  • visuotinė tiesa su g vėliava
  • ignoreCase true su „i“ vėliava
  • „lastIndex“
/^(\w{3})$/i.source // "^ (\\ d {3}) (\\ w +) $"
/^(\w{3})$/i.multiline // false
/^(\w{3})$/i.lastIndex // 0
/^(\w{3})$/i.ignoreCase // tiesa
/^(\w{3})$/i.global // netikras

Pabėgti

Šie simboliai yra ypatingi:

  • \
  • /
  • []
  • ()
  • {}
  • ?
  • +
  • *
  • |
  • .
  • ^
  • Dolerių

Jie yra ypatingi, nes yra kontroliniai simboliai, turintys prasmę įprastos išraiškos šablone. Jei norite naudoti juos modelio viduje kaip suderinamus simbolius, turite jų išvengti, iš anksto paspausdami posūkio kampą:

/ ^ \\ $ /
/ ^ \ ^ $ / // /^\^$/.test('^ ') 
/ ^ \ $$ / // /^\$$/.test('$ ') 

Styginių ribos

\ b ir \ B leidžia jums patikrinti, ar eilutė yra žodžio pradžioje ar pabaigoje:

  • \ b atitinka žodžių rinkinį žodžio pradžioje arba pabaigoje
  • \ B atitinka simbolių rinkinį, kuris nėra žodžio pradžioje ar pabaigoje

Pavyzdys:

'Aš mačiau mešką' .match (/ \ bbear /) // Masyvas ["meška"]
'Aš mačiau barzdą' .match (/ \ bbear /) // Masyvas ["lokys"]
'Aš mačiau barzdą' .match (/ \ bbear \ b /) // nulis
'cool_bear'.match (/ \ bbear \ b /) // nulis

Pakeiskite naudodami įprastas išraiškas

Jau matėme, kaip patikrinti, ar eilutėje yra raštas.

Mes taip pat matėme, kaip ištraukti eilutės dalis į masyvą, suderinant modelį.

Pažiūrėkime, kaip pakeisti eilutės dalis pagal modelį.

Objekto „String“ objektas „JavaScript“ turi pakeisti () metodą, kurį galima naudoti be įprastų išraiškų, norint vieną kartą pakeisti eilutę:

"Sveikas pasaulis!". Pakeiskite ('pasaulis', 'šuo')
// Sveikas šuo!
"Mano šuo yra geras šuo!". Pakeisti ('šuo', 'katė')
// Mano katė yra geras šuo!

Šis metodas taip pat priima taisyklingą išraišką kaip argumentą:

"Sveikas pasaulis!". Pakeiskite (/ pasaulis /, 'šuo') // Sveikas šuo!

„G“ žymos naudojimas yra vienintelis būdas pakeisti kelis pasikartojimus eilutėje vanilės „JavaScript“:

"Mano šuo yra geras šuo!". Pakeisti (/ šuo / g, 'katė')
// Mano katė yra gera katė!

Grupės leiskite mums atlikti daugiau išgalvotų dalykų, pavyzdžiui, judėti stygos dalimis:

„Labas, pasaulis!“. Pakeiskite (/ (\ w +), (\ w +)! /, „2 USD: 1 USD !!!“)
// "pasaulis: labas !!!"

Užuot naudodami eilutę, galite naudoti funkciją, kad atliktumėte net nuobodžius dalykus. Jis gaus daugybę argumentų, pvz., Tą, kurį grąžino „String.match“ („RegExp“) arba „RegExp.exec“ („stygos“), su keliais argumentais, kurie priklauso nuo grupių skaičiaus:

„Sveiki, pasaulis!“ .Pakeiskite (/ (\ w +), (\ w +)! /, („MatchedString“, pirma, antra) => {
  console.log (pirma);
  console.log (antra);
  grįžti „$ {second.toUpperCase ()}: $ {first} !!!“
})
// "PASAULIS: Sveiki !!!"

Godumas

Sakoma, kad įprastos išraiškos yra gobšios.

Ką tai reiškia?

Paimkite šią regex:

/\$(.+)\s?/

Manoma, kad iš stygos bus galima išgauti dolerio sumą:

/\$(.+)\s?/.exec('Tai kainuoja 100 USD ') [1]
// 100

bet jei po skaičiaus turime daugiau žodžių, jis atsibosta:

/\$(.+)\s?/.exec('Tai kainuoja 100 USD ir yra mažesnė nei 200 USD ') [1] // 100 ir yra mažesnė nei 200 USD

Kodėl? Kadangi regex po ženklu $ atitinka bet kurį simbolį su. +, Ir jis nesustos, kol nepasieks eilutės pabaigos. Tada jis baigiamas, nes? pabaigos taškas pasirenkamas.

Norėdami tai išspręsti, turime pasakyti, kad regex yra tingus, ir atlikti kuo mažiau suderinimų. Mes galime tai padaryti naudodami? simbolis po kiekybinio rodiklio:

/\$(.+?)\s/.exec('Tai kainuoja 100 USD ir yra mažiau nei 200 USD ') [1]
// 100
Aš pašalinau? po \ s. Kitu atveju jis atitiko tik pirmąjį numerį, nes tarpas nebuvo pasirenkamas

Taigi? reiškia skirtingus dalykus, atsižvelgiant į jo poziciją, nes tai gali būti ir kiekybinis, ir tinginio režimo indikatorius.

„Lookaheads“: suderinkite eilutę priklausomai nuo to, kas po jos seka

Naudokite? =, Kad atitiktumėte eilutę, po kurios eina konkreti eilutė:

/ Rogeris (? = Vandenys) /
/ Rodžeris (? = Vandeniai) /. Testas ('Rodžeris yra mano šuo') // klaidingas
/ Roger (? = Waters) /. Testas ('Roger yra mano šuo, o Roger Waters yra garsus muzikantas')
//tiesa

?! atlieka atvirkštinę operaciją, suderindama, jei eilutės neseka konkreti eilutė:

/ Rogeris (?! Vandenys) /
/ Rodžeris (?! Vandenys) /. Testas ('Rodžeris yra mano šuo') // tiesa
/ Roger (?! Waters) /. Testas ('Roger Waters yra garsus muzikantas')
// melagingas

Žvilgsniai: priderinkite eilutę priklausomai nuo to, kas buvo prieš ją

Tai yra ES2018 funkcija.

„Lookaheads“ naudoja simbolį? =. Panaudojimas? <=.

/ (? <= Roger) vandenys /
/ (? <= Rogeris) Vandenys / .test ('Rožiniai vandenys yra mano šuo')
// melagingas
/ (? <= Rogeris) Waters / .test („Rodžeris yra mano šuo, o Rodžeris Watersas yra garsus muzikantas“)
//tiesa

Panašu, kad žvilgsnis atgal neigiamas?

/ (? 
/ (? 
/ (? 

Reguliarios išraiškos ir „Unicode“

U vėliava yra privaloma dirbant su „Unicode“ stygomis. Visų pirma, tai taikoma, kai gali tekti tvarkyti ženklus astralinėse plokštumose (tuos, kurie neįtraukti į pirmuosius 1600 „Unicode“ simbolių).

Emocijos yra geras pavyzdys, tačiau jos nėra vienintelės.

Jei nepridėsite šios vėliavos, šis paprastas regex, kuris turėtų atitikti vieną simbolį, neveiks, nes „JavaScript“ šiai emocijai vidinę reikšmę sudaro 2 simboliai (žr. „Unicode“ JavaScript):

/^.$/.test('a ') // 
/^.$/.test(' ') // 
/^.$/u.test(' ') // 

Taigi, visada naudokite u vėliavą.

„Unicode“, kaip ir normalūs simboliai, tvarko diapazonus:

/[a-z / /.test('a ') // 
/[1-9]/.test('1 ') // 
/[-/u.test(' ') // 
/[-/u.test(' ') // 

„JavaScript“ tikrina vidinio kodo vaizdavimą, taigi < <, nes \ u1F436 <\ u1F43A <\ u1F98A. Patikrinkite visą jaustukų sąrašą, kad gautumėte tuos kodus ir išsiaiškintumėte tvarką (patarimas: „macOS“ jaustukų rinkinyje yra keletas jaustukų mišria tvarka, todėl nesiskaitykite).

„Unicode“ turtas pabėga

Kaip matėme aukščiau, įprastos išraiškos schemoje galite naudoti \ d, kad atitiktumėte bet kurį skaitmenį, \ s, kad atitiktumėte bet kokį simbolį, kuris nėra baltas tarpas, \ w, kad atitiktumėte bet kurį raidinį ir skaitmeninį simbolį ir pan.

„Unicode“ nuosavybė pabėga yra ES2018 savybė, pristatanti labai šaunią funkciją, išplėtus šią sąvoką visiems „Unicode“ simboliams, pristatantiems \ p {} ir jo neigimą \ P {}.

Bet kuris „Unicode“ simbolis turi savybių rinkinį. Pavyzdžiui, scenarijus nustato kalbų šeimą, ASCII yra loginė reikšmė, teisinga ASCII simboliams ir pan. Galite įrašyti šią savybę į grafiko skliaustus ir regex patikrins, ar ji teisinga:

/^\p{ASCII}+$/u.test('abc ') // 
/^\p{ASCII}+$/u.test('ABC@ ') // 
/^\p{ASCII}+$/u.test('ABC ') // 

ASCII_Hex_Digit yra dar viena boolean ypatybė, kuri patikrina, ar eilutėje yra tik galiojantys šešioliktainiai skaitmenys:

/^\p{ASCII_Hex_Digit}+$/u.test('0123456789ABCDEF ') //  /^\p{ASCII_Hex_Digit}+$/u.test('h') // 

Yra daugybė kitų loginių ypatybių, kurias tiesiog patikrinate pridėję jų pavadinimą grafiko skliaustuose, įskaitant didžiąsias, mažąsias, „White_Space“, abėcėlę, jaustukus ir dar daugiau:

/^\p{Lowercase}$/u.test('h ') // 
/^\p{Uppercase}$/u.test('H ') // 
/^\p{Emoji}+$/u.test('H ') // 
/^\p{Emoji}+$/u.test(' ') // 

Be šių dvejetainių savybių, galite patikrinti bet kurias unikodo simbolių savybes, kad jos atitiktų konkrečią vertę. Šiame pavyzdyje patikrinu, ar eilutė parašyta graikų ar lotynų abėcėlėmis:

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

Skaitykite daugiau apie visas savybes, kuriomis galite tiesiogiai naudotis pasiūlyme.

Pavyzdžiai

Tarkime, kad eilutėje yra tik vienas skaičius, kurį jums reikia išgauti, / \ d + / turėtų tai padaryti:

„Test 123123329“ .match (/ \ d + /)
// Masyvas ["123123329"]

Suderinkite el. Pašto adresą

Paprastas būdas yra patikrinti tarpus be simbolių prieš ir po @ ženklu, naudojant \ S:

/(\S+)@(\S+)\.(\S+)/
/(\S+)@(\S+)\.(\S+)/.exec('copesc@gmail.com ')
//["copesc@gmail.com “,„ copesc “,„ gmail “,„ com “]

Tačiau tai yra supaprastintas pavyzdys, nes daugelis netinkamų el. Laiškų tebėra patenkinti šia regex.

Fiksuokite tekstą tarp dvigubų kabučių

Tarkime, kad turite eilutę, kurioje yra kažkas kabutėse, ir norite išgauti tą turinį.

Geriausias būdas tai padaryti yra naudojant užfiksuojančią grupę, nes mes žinome, kad rungtynės prasideda ir baigiasi “, ir galime lengvai į jas nukreipti, tačiau mes taip pat norime pašalinti šias citatas iš savo rezultato.

Rezultate rasime tai, ko mums reikia [1]:

const hello = 'Sveiki, „graži gėlė“'
bendras rezultatas = /"([^'**)"/.exec(hello)
// Masyvas ["\" graži gėlė \ "", "graži gėlė"]

Gaukite HTML žymos turinį

Pvz., Gaukite turinį standartinės žymos viduje, kad žymoje būtų galima pateikti daugybę argumentų:

/←*>(.*?)<\/span>/
/←*>(.*?)<\/span>/.exec('test ')
// niekinis
/←*>(.*?)<\/span>/.exec('test  ')
// [" testas ", "testas"]
/←*>(.*?)<\/span>/.exec(' test  ')
// [" testas ", "testas"]
Norite sužinoti „JavaScript“? Gaukite nemokamą el. Knygą svetainėje jshandbook.com