RegEx: 20 maikling hakbang upang makabisado ang mga regular na expression. Bahagi 3

RegEx: 20 maikling hakbang upang makabisado ang mga regular na expression. Bahagi 1. RegEx: 20 maikling hakbang upang makabisado ang mga regular na expression. Bahagi 2: Sa bahaging ito ay lilipat tayo sa mga bagay na medyo mas kumplikado. Ngunit ang pag-master sa kanila, tulad ng dati, ay hindi magiging mahirap. Inuulit ko na ang RegEx ay talagang mas madali kaysa sa tila sa una, at hindi mo kailangang maging isang rocket scientist upang makabisado ito at simulan ang paggamit nito sa pagsasanay. Ang orihinal na Ingles ng artikulong ito ay narito .

Hakbang 11: Mga Panaklong ()bilang Mga Grupo sa Pagkuha

Sa huling problema, naghanap kami ng iba't ibang uri ng integer values ​​at floating point (tuldok) numeric value. Ngunit ang regular na expression engine ay hindi naiiba sa pagitan ng dalawang uri ng mga halaga, dahil ang lahat ay nakuha sa isang malaking regular na expression. Maaari naming sabihin sa regular na expression engine na mag-iba sa pagitan ng iba't ibang uri ng mga tugma kung ilalagay namin ang aming mga mini-pattern sa mga panaklong:

pattern: ([AZ])|([az]) 
string:   Ang kasalukuyang Pangulo ng Bolivia ay si Evo Morales .
mga tugma: ^^^ ^^^^^^^ ^^^^^^^^^ ^^ ^^^^^^^ ^^ ^^^ ^^^^^^^ 
pangkat:    122 2222222 122222222 22 1222222 22 122 1222222  

( Halimbawa ) Ang regular na expression sa itaas ay tumutukoy sa dalawang pangkat ng pagkuha na na-index simula sa 1. Ang unang pangkat ng pagkuha ay tumutugma sa anumang solong malalaking titik, at ang pangalawang pangkat ng pagkuha ay tumutugma sa anumang solong maliit na titik. Sa pamamagitan ng paggamit ng sign na 'o' |at mga panaklong ()bilang isang grupong kumukuha, maaari nating tukuyin ang isang regular na expression na tumutugma sa maraming uri ng mga string. Kung ilalapat namin ito sa aming long/float search regex mula sa nakaraang bahagi ng artikulo, kukunin ng regex engine ang mga kaukulang tugma sa naaangkop na mga grupo. Sa pamamagitan ng pagsuri kung aling grupo ang tumutugma sa isang substring, matutukoy namin kaagad kung ito ay isang float value o isang mahabang halaga:

pattern: (\d*\.\d+[fF]|\d+\.\d*[fF]|\d+[fF])|(\d+[lL]) 
string:   42L 12 x 3.4f 6l 3.3 0F LF .2F 0.
mga tugma: ^^^ ^^^^ ^^ ^^ ^^^ 
pangkat:    222 1111 22 11 111  

( Halimbawa ) Ang regular na expression na ito ay medyo kumplikado, at para mas maunawaan ito, paghiwa-hiwalayin natin ito at tingnan ang bawat isa sa mga pattern na ito:

( // tumutugma sa anumang "float" substring
  \d*\.\d+[fF]
  |
  \d+\.\d*[fF]
  |
  \d+[fF]
)
| // O
( // tumutugma sa anumang "mahabang" substring
  \d+[lL]
)

Ang pag-sign |at pagkuha ng mga grupo sa mga panaklong ()ay nagbibigay-daan sa amin na tumugma sa iba't ibang uri ng mga substring. Sa kasong ito, tinutugma namin ang alinman sa mga floating point na numero na "float" o mahabang integer na "mahaba".

(
  \d*\.\d+[fF] // 1+ digit sa kanan ng decimal point
  |
  \d+\.\d*[fF] // 1+ digit sa kaliwa ng decimal point
  |
  \d+[fF] // walang tuldok, 1+ digit lang
)
|
(
  \d+[lL] // walang tuldok, 1+ digit lang
)

Sa "float" capture group, mayroon kaming tatlong opsyon: mga numerong may hindi bababa sa 1 digit sa kanan ng decimal point, mga numerong may hindi bababa sa 1 digit sa kaliwa ng decimal point, at mga numerong walang decimal point. Alinman sa mga ito ay "float" basta't may mga letrang "f" o "F" na nakadugtong sa dulo. Sa loob ng "long" capture group mayroon lang kaming isang opsyon - dapat ay mayroon kaming 1 o higit pang mga digit na sinusundan ng character na "l" o "L". Hahanapin ng regular na expression engine ang mga substring na ito sa isang partikular na string at i-index ang mga ito sa naaangkop na pangkat ng pagkuha. talana hindi kami tumutugma sa alinman sa mga numero na walang anumang "l", "L", "f" o "F" na idinagdag sa kanila. Paano dapat iuri ang mga numerong ito? Well, kung mayroon silang isang decimal point, ang wika ng Java ay nagde-default sa "doble". Kung hindi, dapat silang "int".

Pagsama-samahin natin ang natutunan natin sa ilang puzzle:

Magdagdag ng dalawa pang pangkat ng pagkuha sa regex sa itaas upang ma-classify din nito ang doble o int na mga numero. (Ito ay isa pang nakakalito na tanong, huwag masiraan ng loob kung magtatagal ito, bilang huling paraan, tingnan ang aking solusyon.)

pattern:
string:   42L 12 x 3.4f 6l 3.3 0F LF .2F 0. 
mga tugma: ^^^ ^^ ^^^^ ^^ ^^^ ^^ ^^^ ^^ 
pangkat:    333 44 1111 33 222 11 111 22

( Solusyon ) Ang susunod na problema ay medyo mas simple. Gumamit ng mga naka-bracket na pangkat ng pagkuha (), ang 'o' sign, |at mga hanay ng character upang pag-uri-uriin ang mga sumusunod na edad: "legal na inumin sa US." (>= 21) at "hindi pinapayagang uminom sa USA" (<21):

pattern:
string:   7 10 17 18 19 20 21 22 23 24 30 40 100 120 
mga tugma: ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ 
pangkat:    2 22 22 22 22 22 11 11 11 11 11 11 11 111 111 

( Solusyon )

Hakbang 12: Tukuyin Una ang Higit pang Mga Tukoy na Tugma

Maaaring nagkaroon ka ng ilang problema sa huling gawain kung sinubukan mong tukuyin ang "mga legal na umiinom" bilang ang unang grupo ng pagkuha sa halip na ang pangalawa. Upang maunawaan kung bakit, tingnan natin ang isa pang halimbawa. Ipagpalagay na gusto naming itala ang magkahiwalay na mga apelyido na naglalaman ng mas mababa sa 4 na mga character at mga apelyido na naglalaman ng 4 o higit pang mga character. Bigyan natin ng mas maiikling pangalan ang unang pangkat ng pagkuha at tingnan kung ano ang mangyayari:

pattern: ([AZ][az]?[az]?)|([AZ][az][az][az]+) 
string:   Kim Job s Xu Clo yd Moh r Ngo Roc k.
mga tugma: ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^^ 
pangkat:    111 111 11 111 111 111 111   

( Halimbawa ) Bilang default, karamihan sa mga regular na expression engine ay gumagamit ng matakaw na pagtutugma laban sa mga pangunahing character na nakita natin sa ngayon. Nangangahulugan ito na kukunin ng regular na expression engine ang pinakamahabang pangkat na tinukoy nang maaga hangga't maaari sa ibinigay na regular na expression. Kaya kahit na ang pangalawang pangkat sa itaas ay maaaring makakuha ng higit pang mga character sa mga pangalan tulad ng "Mga Trabaho" at "Cloyd" halimbawa, ngunit dahil ang unang tatlong mga character ng mga pangalan ay nakuha na ng unang grupo ng pagkuha, hindi na sila maaaring makuha muli ng pangalawa. . Ngayon ay gumawa tayo ng isang maliit na pagwawasto - baguhin lamang ang pagkakasunud-sunod ng mga grupo ng pagkuha, ilagay muna ang mas tiyak (mas mahabang) grupo:

pattern: ([AZ][az][az][az]+)|([AZ][az]?[az]?) 
string:   Kim Jobs Xu Cloyd Mohr Ngo Rock .
mga tugma: ^^^ ^^^^ ^^ ^^^^^ ^^^^ ^^^ ^^^^ 
pangkat:    222 1111 22 11111 1111 222 1111    

( Halimbawa )

Gawain... this time isa na lang :)

Ang isang "mas tiyak" na pattern ay halos palaging nangangahulugang "mas mahaba". Sabihin nating gusto nating makahanap ng dalawang uri ng "mga salita": una ang mga nagsisimula sa mga patinig (mas partikular), pagkatapos ay ang mga hindi nagsisimula sa mga patinig (anumang ibang salita). Subukang magsulat ng isang regular na expression upang makuha at matukoy ang mga string na tumutugma sa dalawang pangkat na ito. (Ang mga pangkat sa ibaba ay may titik sa halip na bilang. Dapat mong tukuyin kung aling grupo ang dapat tumugma sa una at alin sa pangalawa.)

pattern:
string:   pds6f uub 24r2gp ewqrty l ui_op 
matches: ^^^^^ ^^^ ^^^^^^ ^^^^^^ ^ ^^^^^ 
pangkat:    NNNNN VVV NNNNNN VVVVVV N VVVVV

( Solusyon ) Sa pangkalahatan, kung mas tumpak ang iyong regular na expression, mas matatapos ito. At kung mas tumpak ito, mas maliit ang posibilidad na makuha mo ang isang bagay na hindi mo kailangan. Kaya't habang sila ay mukhang nakakatakot, mas mahahabang regexes ~= mas mahusay na regexes. Sa kasamaang palad .

Hakbang 13: Mga kulot na braces {}para sa isang tiyak na bilang ng mga pag-uulit

Sa halimbawa na may mga apelyido mula sa nakaraang hakbang, mayroon kaming 2 halos paulit-ulit na grupo sa isang pattern:

pattern: ([AZ][az][az][az]+)|([AZ][az]?[az]?) 
string:   Kim Jobs Xu Cloyd Mohr Ngo Rock .
mga tugma: ^^^ ^^^^ ^^ ^^^^^ ^^^^ ^^^ ^^^^ 
pangkat:    222 1111 22 11111 1111 222 1111    

Para sa unang grupo, kailangan namin ng mga apelyido na may apat o higit pang titik. Ang pangalawang grupo ay kailangang kumuha ng mga apelyido na may tatlo o mas kaunting mga titik. Mayroon bang anumang mas madaling paraan upang isulat ito kaysa sa paulit- ulit na paulit [a-z]-ulit na mga grupong ito? Umiiral kung gumamit ka ng mga kulot na braces para dito {}. Binibigyang-daan kami ng mga kulot na brace {}na tukuyin ang minimum at (opsyonal) maximum na bilang ng mga tugma ng nakaraang karakter o pangkat ng pagkuha. Mayroong tatlong mga kaso ng paggamit {}:

{X} // tumutugma nang eksakto X beses
{X,} // tugma >= X beses
{X,Y} // tugma >= X at <= Y beses

Narito ang mga halimbawa ng tatlong magkakaibang syntax na ito:

pattern: [az]{11} 
string:   humuhumunuk unukuapua'a.
mga tugma: ^^^^^^^^^^^^   

( Halimbawa )

pattern: [az]{18,} 
string:   humuhumunukunukuapua 'a.
mga tugma: ^^^^^^^^^^^^^^^^^^^^^^^^^    

( Halimbawa )

pattern: [az]{11,18} 
string:   humuhumunukunukukap ua'a.
mga tugma: ^^^^^^^^^^^^^^^^^^^^    

( Halimbawa ) Mayroong ilang mga punto na dapat tandaan sa mga halimbawa sa itaas.tandaan:. Una, gamit ang {X} notation, ang nakaraang character o pangkat ay eksaktong tutugma sa bilang (X) na beses. Kung mayroong higit pang mga character sa "salita" (kaysa sa numero X) na maaaring tumugma sa pattern (tulad ng ipinapakita sa unang halimbawa), hindi sila isasama sa tugma. Kung ang bilang ng mga character ay mas mababa sa X, ang buong tugma ay mabibigo (subukang baguhin ang 11 hanggang 99 sa unang halimbawa). Pangalawa, ang mga notasyong {X,} at {X,Y} ay matakaw. Susubukan nilang tumugma sa pinakamaraming character hangga't maaari habang natutugunan pa rin ang ibinigay na regular na expression. Kung tutukuyin mo ang {3,7} pagkatapos ay 3 hanggang 7 character ang maaaring itugma at kung ang susunod na 7 character ay wasto, ang lahat ng 7 character ay maitutugma. Kung tinukoy mo ang {1,} at lahat ng susunod na 14,000 character ay tumutugma, ang lahat ng 14,000 ng mga character na iyon ay isasama sa kaukulang string. Paano natin magagamit ang kaalamang ito upang muling isulat ang ating ekspresyon sa itaas? Ang pinakasimpleng pagpapabuti ay maaaring palitan ang mga kalapit na grupo [a-z]ng [a-z]{N}, kung saan ang N ay napili nang naaayon:

pattern: ([AZ][az]{2}[az]+)|([AZ][az]?[az]?)  

...ngunit hindi iyon nagpapaganda ng mga bagay. Tingnan ang unang pangkat ng pagkuha: mayroon kaming [a-z]{2}(na eksaktong tumutugma sa 2 maliliit na titik) na sinusundan ng [a-z]+(na tumutugma sa 1 o higit pang maliliit na titik). Mapapasimple natin ito sa pamamagitan ng paghingi ng 3 o higit pang maliliit na titik gamit ang mga kulot na brace:

pattern: ([AZ][az]{3,})|([AZ][az]?[az]?) 

Iba ang pangalawang grupo ng pagkuha. Kailangan namin ng hindi hihigit sa tatlong character sa mga apelyido na ito, na nangangahulugang mayroon kaming pinakamataas na limitasyon, ngunit ang aming mas mababang limitasyon ay zero:

pattern: ([AZ][az]{3,})|([AZ][az]{0,2}) 

Palaging mas mahusay ang pagtitiyak kapag gumagamit ng mga regular na expression, kaya makabubuting huminto doon, ngunit hindi ko maiwasang mapansin na ang dalawang hanay ng character na ito ( [AZ]at [az]) sa tabi ng bawat isa ay halos parang isang klase ng "katauhan ng salita", \w( [A-Za-z0-9_]) . Kung kami ay tiwala na ang aming data ay naglalaman lamang ng mahusay na na-format na mga apelyido, maaari naming pasimplehin ang aming regular na expression at magsulat ng simple:

pattern: (\w{4,})|(\w{1,3}) 

Kinukuha ng unang pangkat ang anumang pagkakasunud-sunod ng 4 o higit pang "mga character ng salita" ( [A-Za-z0-9_]), at ang pangalawang pangkat ay kumukuha ng anumang pagkakasunud-sunod mula 1 hanggang 3 "mga character ng salita" (kasama). Gagana ba ito?

pattern: (\w{4,})|(\w{1,3}) 
string:   Kim Jobs Xu Cloyd Mohr Ngo Rock .
mga tugma: ^^^ ^^^^ ^^ ^^^^^ ^^^^ ^^^ ^^^^ 
pangkat:    222 1111 22 11111 1111 222 1111    

( Halimbawa ) Ito ay gumana! Paano ang diskarteng ito? At ito ay mas malinis kaysa sa aming nakaraang halimbawa. Dahil ang unang pangkat ng pagkuha ay tumutugma sa lahat ng mga apelyido na may apat o higit pang mga character, maaari pa nating baguhin ang pangalawang pangkat ng pagkuha sa simpleng \w+, dahil ito ay magbibigay-daan sa amin upang makuha ang lahat ng natitirang mga apelyido (na may 1, 2, o 3 character):

pattern: (\w{4,})|(\w+) 
string:   Kim Jobs Xu Cloyd Mohr Ngo Rock .
mga tugma: ^^^ ^^^^ ^^ ^^^^^ ^^^^ ^^^ ^^^^ 
pangkat:    222 1111 22 11111 1111 222 1111    

( Halimbawa )

Tulungan natin ang utak na matutunan ito at malutas ang sumusunod na 2 problema:

Gumamit ng mga kulot na brace {}upang muling isulat ang regular na expression ng paghahanap ng social security number mula sa hakbang 7:

pattern:
string: 113-25=1902 182-82-0192 H23-_3-9982 1I1-O0-E38B
mga tugma:              ^^^^^^^^^^^^

( Solusyon ) Ipagpalagay na ang tagasuri ng lakas ng password ng website ay nangangailangan ng mga password ng user na nasa pagitan ng 6 at 12 character. Sumulat ng regular na expression na nagba-flag ng mga di-wastong password sa listahan sa ibaba. Ang bawat password ay nakapaloob sa mga panaklong ()para sa madaling pagtutugma, kaya siguraduhin na ang regular na expression ay nagsisimula at nagtatapos sa literal (at )simbolikong mga character. Pahiwatig: tiyaking hindi mo pinapayagan ang mga literal na panaklong sa mga password na may [^()]o katulad, kung hindi, matutugma ka sa buong string!

pattern:
string:   (12345) (my password) (Xanadu.2112) (su_do) (OfSalesmen!)
mga tugma: ^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^  

( Solusyon )

Hakbang 14: \bZero Width Border Symbol

Ang huling gawain ay medyo mahirap. Ngunit paano kung ginawa namin itong medyo mas kumplikado sa pamamagitan ng paglalagay ng mga password sa mga quote ""sa halip na mga panaklong ()? Maaari ba tayong sumulat ng katulad na solusyon sa pamamagitan lamang ng pagpapalit ng lahat ng mga character na panaklong ng mga character na quote?

pattern: \"[^"]{0.5}\"|\"[^"]+\s[^"]*\" 
string:   "12345" "my password" "Xanadu.2112 " " su_do" " OfSalesmen! "
mga tugma: ^^^^^^^ ^^^^^^^^^^^^^^^ ^^^ ^^^  

( Halimbawa ) Hindi ito naging kahanga-hanga. Nahulaan mo na ba kung bakit? Ang problema ay naghahanap kami ng mga maling password dito. Ang "Xanadu.2112" ay isang magandang password, kaya kapag napagtanto ng regex na ang sequence na ito ay hindi naglalaman ng mga puwang o literal na mga character ", magbubunga ito bago ang character "na kwalipikado sa password sa kanang bahagi. (Dahil tinukoy namin na ang mga character "ay hindi mahahanap sa loob ng mga password gamit ang [^"].) Kapag ang regular na expression engine ay nasiyahan na ang mga character na iyon ay hindi tumutugma sa isang partikular na regular na expression, ito ay tatakbo muli, kung saan mismo ito tumigil - kung saan ang character ay ". na naglilimita sa " Xanadu.2112" sa kanan. Mula doon nakikita niya ang isang karakter sa espasyo, at isa pang karakter "- para sa kanya ito ang maling password! Karaniwan, nahanap niya ang pagkakasunud-sunod na ito " "at nagpapatuloy. Hindi ito ang gusto nating makuha... Magiging mahusay kung maaari nating tukuyin na ang unang character ng password ay hindi dapat isang puwang. Mayroon bang paraan upang gawin ito? (Sa ngayon, malamang na napagtanto mo na ang sagot sa lahat ng aking mga retorika na tanong ay "oo.") Oo! May ganyang paraan! Maraming mga regular na expression engine ang nagbibigay ng escape sequence gaya ng "word boundary" \b. Ang "Word boundary" \bay isang zero-width escape sequence na, kakaiba, tumutugma sa isang word boundary. Tandaan na kapag sinabi namin ang "salita", ang ibig naming sabihin ay alinman sa anumang pagkakasunud-sunod ng mga character sa klase \wo [A-Za-z0-9_]. Ang tugma ng hangganan ng salita ay nangangahulugan na ang karakter kaagad bago o kaagad pagkatapos ng pagkakasunud-sunod \bay dapat na неisang character na salita. Gayunpaman, kapag tumutugma, hindi namin isinasama ang character na ito sa aming nakunan na substring. Ito ay zero na lapad. Upang makita kung paano ito gumagana, tingnan natin ang isang maliit na halimbawa:

pattern: \b[^ ]+\b 
string:   May pera ka pa rin , Lebowski .
mga tugma: ^^ ^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^  

( Halimbawa ) Ang sequence [^ ]ay dapat tumugma sa anumang character na hindi literal na space character. Kaya bakit hindi ito tumutugma sa kuwit ,pagkatapos ng pera o sa tuldok na " .pagkatapos ng Lebowski? Ito ay dahil ang kuwit ,at tuldok .ay hindi mga character ng salita, kaya ang mga hangganan ay nilikha sa pagitan ng mga character ng salita at mga character na hindi salita. Lumilitaw ang mga ito sa pagitan yng dulo ng salitang pera at ang kuwit ,na kasunod nito. at sa pagitan ing " salitang Lebowski at ng tuldok .(full stop/period) na kasunod nito. Ang regular na expression ay tumutugma sa mga hangganan ng mga salitang ito (ngunit hindi sa mga hindi salita na character na tumutulong lamang na tukuyin ang mga ito). Ngunit ano ang mangyayari kung hindi namin isama ang pagkakapare-pareho \bsa aming template?

pattern: [^ ]+ 
string:   May pera ka pa rin, Lebowski. 
mga tugma: ^^ ^^^^^ ^^^^ ^^ ^^^^^^ ^^^^^^^^^  

( Halimbawa ) Oo, ngayon ay nakita na rin namin ang mga bantas na ito. Ngayon, gamitin natin ang mga hangganan ng salita upang ayusin ang regex para sa mga naka-quote na password:

pattern: \"\b[^"]{0.5}\b\"|\"\b[^"]+\s[^"]*\b\" 
string:   "12345" "my password" " Xanadu. 2112" "su_do" "OfSalesmen!"
mga tugma: ^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^  

( Halimbawa ) Sa pamamagitan ng paglalagay ng mga hangganan ng salita sa loob ng mga panipi ("\b ... \b"), epektibo naming sinasabi na ang una at huling mga character ng magkatugmang mga password ay dapat na "mga character ng salita". Kaya ito ay gumagana nang maayos dito, ngunit hindi rin gagana kung ang una o huling character ng password ng user ay hindi isang character na salita:

pattern: \"\b[^"]{0.5}\b\"|\"\b[^"]+\s[^"]*\b\"
string: "thefollowingpasswordistooshort" "C++"
mga tugma:   

( Halimbawa ) Tingnan kung paano hindi minarkahan ang pangalawang password bilang "di-wasto" kahit na ito ay malinaw na masyadong maikli. Ikaw ay dapatingatna may mga pagkakasunud - sunod \b, dahil tumutugma lamang sila sa mga hangganan sa pagitan ng mga character \wat hindi \w. Sa halimbawa sa itaas, dahil pinahintulutan namin ang mga character na hindi , sa mga password \w, ang hangganan sa pagitan \at ang una/huling character ng password ay hindi garantisadong maging hangganan ng salita \b.

Upang makumpleto ang hakbang na ito, malulutas lamang namin ang isang simpleng problema:

Ang mga hangganan ng salita ay kapaki-pakinabang sa syntax na pag-highlight ng mga engine kapag gusto naming tumugma sa isang partikular na pagkakasunud-sunod ng mga character, ngunit nais na tiyakin na nangyayari lamang ang mga ito sa simula o dulo ng isang salita (o sa kanilang sarili). Sabihin nating nagsusulat kami ng syntax highlighting at gusto naming i-highlight ang salitang var, ngunit kapag ito ay lilitaw sa sarili nitong (nang hindi hinahawakan ang iba pang mga character sa salita). Maaari ka bang magsulat ng isang regular na expression para dito? Syempre kaya mo, napakasimpleng gawain ;)

pattern:
string:   var varx _var ( var j) barvarcar * var var -> { var }
mga tugma: ^^^ ^^^ ^^^ ^^^ ^^^  

( Solusyon )

Hakbang 15: "caret" ^bilang "simula ng linya" at dollar sign $bilang "katapusan ng linya"

Ang salitang boundary sequence \b(mula sa huling hakbang ng nakaraang bahagi ng artikulo) ay hindi lamang ang espesyal na zero-width na sequence na magagamit para sa mga regular na expression. Ang dalawang pinakasikat ay ang "caret" ^- "simula ng linya" at dollar sign $- "end of line". Ang pagsasama ng isa sa mga ito sa iyong mga regular na expression ay nangangahulugan na ang tugma ay dapat na lumitaw sa simula o dulo ng source string:

pattern: ^start|end$ 
string:   start end start end start end start end 
tugma: ^^^^^ ^^^  

( Halimbawa ) Kung ang iyong string ay naglalaman ng mga line break, ^starttutugma ito sa sequence na "start" sa simula ng anumang linya, at end$tutugma sa sequence na "end" sa dulo ng anumang linya (bagama't mahirap itong ipakita dito). Ang mga simbolo na ito ay lalong kapaki-pakinabang kapag nagtatrabaho sa data na naglalaman ng mga delimiter. Bumalik tayo sa isyu na "laki ng file" mula sa hakbang 9 gamit ang ^"simula ng linya". Sa halimbawang ito, ang aming mga laki ng file ay pinaghihiwalay ng mga puwang na " ". Kaya gusto naming magsimula ang bawat laki ng file sa isang numero, na nauuna sa isang character na espasyo o simula ng isang linya:

pattern: (^| )(\d+|\d+\.\d+)[KMGT]B 
string:   6.6KB 1..3KB 12KB 5G 3.3MB KB .6.2TB 9MB .
mga tugma: ^^^^^ ^^^^^ ^^^^^^ ^^^^ 
pangkat:    222 122 1222 12    

( Halimbawa ) Napakalapit na namin sa layunin! Ngunit maaari mong mapansin na mayroon pa rin kaming isang maliit na problema: tinutugma namin ang space character bago ang wastong laki ng file. Ngayon ay maaari na lang nating balewalain ang grupong ito sa pagkuha (1) kapag nahanap ito ng ating regular na expression engine, o maaari tayong gumamit ng isang pangkat na hindi kumukuha, na makikita natin sa susunod na hakbang.

Pansamantala, lutasin natin ang 2 pang problema para sa tono:

Sa pagpapatuloy sa aming halimbawa ng pag-highlight ng syntax mula sa huling hakbang, mamarkahan ng ilang pag-highlight ng syntax ang mga trailing space, iyon ay, anumang mga puwang na nasa pagitan ng isang character na hindi whitespace at sa dulo ng linya. Maaari ka bang magsulat ng regex upang i-highlight lamang ang mga trailing space?

pattern:
string: myvec <- c(1, 2, 3, 4, 5)  
mga tugma:                          ^^^^^^  

( Solusyon ) Ang isang simpleng comma-separated value (CSV) parser ay maghahanap ng "mga token" na pinaghihiwalay ng mga kuwit. Sa pangkalahatan, walang kahulugan ang espasyo maliban kung ito ay nakapaloob sa mga panipi "". Sumulat ng isang simpleng CSV parsing regular expression na tumutugma sa mga token sa pagitan ng mga kuwit, ngunit binabalewala (hindi kumukuha) puting espasyo na wala sa pagitan ng mga quote.

pattern:
string:   a, "b", "c d",e,f, "g h", dfgi,, k, "", l 
mga tugma: ^^ ^^^^ ^^^^^^^^^^ ^^^ ^^^ ^^^^^^ ^^ ^^^ ^ 
pangkat:    21 2221 2222212121 222221 222211 21 221 2    

( Solusyon ) RegEx: 20 maikling hakbang para makabisado ang mga regular na expression. Bahagi 4.