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

RegEx: 20 maikling hakbang upang makabisado ang mga regular na expression. Bahagi 1 RegEx: 20 maiikling hakbang upang makabisado ang mga regular na expression. Bahagi 2 20 maikling hakbang para makabisado ang mga regular na expression. Bahagi 3 Ang huling bahaging ito, sa gitna, ay tutugon sa mga bagay na pangunahing ginagamit ng mga regular na expression masters. Ngunit ang materyal mula sa mga nakaraang bahagi ay madali para sa iyo, tama ba? Nangangahulugan ito na maaari mong pangasiwaan ang materyal na ito sa parehong kadalian! Orihinal dito <h2>Hakbang 16: mga grupo nang hindi kumukuha (?:)</h2> Sa dalawang halimbawa sa nakaraang hakbang, kinukuha namin ang teksto na hindi namin talaga kailangan. Sa gawaing Mga Laki ng File, nakuha namin ang mga puwang bago ang unang digit ng mga laki ng file, at sa gawaing CSV, nakuha namin ang mga kuwit sa pagitan ng bawat token. Hindi namin kailangang kunin ang mga character na ito, ngunit kailangan naming gamitin ang mga ito upang buuin ang aming regular na expression. Ang mga ito ay mainam na opsyon para sa paggamit ng isang grupo nang hindi kumukuha, (?:). Ginagawa ng isang hindi nakakakuha na grupo kung ano mismo ang tunog nito - pinapayagan nito ang mga character na mapangkat at magamit sa mga regular na expression, ngunit hindi nakukuha ang mga ito sa isang pangkat na may bilang:

pattern: (?:")([^"]+)(?:") 
string: Gusto ko lang "ang text sa loob ng mga quotes na ito" .
mga tugma:             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
pangkat:                 11111111111111111111111111111    

( Halimbawa ) Ang regular na expression ay tumutugma na ngayon sa sinipi na teksto pati na rin sa mga quote character mismo, ngunit nakuha lamang ng grupong kumukuha ang sinipi na teksto. Bakit natin ito gagawin? Ang punto ay ang karamihan sa mga regular na expression engine ay nagbibigay-daan sa iyo na mabawi ang teksto mula sa mga grupo ng pagkuha na tinukoy sa iyong mga regular na expression. Kung maaari naming i-trim ang mga karagdagang character na hindi namin kailangan nang hindi kasama ang mga ito sa aming mga grupo ng pagkuha, gagawin nitong mas madaling i-parse at manipulahin ang teksto sa ibang pagkakataon. Narito kung paano linisin ang CSV parser mula sa nakaraang hakbang:

pattern: (?:^|,)\s*(?:\"([^",]*)\"|([^", ]*)) 
string:   a , " b ", " cd ", e , f , " gh ", dfgi ,, k , "", l 
mga tugma: ^ ^ ^^^ ^ ^ ^^^ ^^^^ ^ ^ 
pangkat:    2 1 111 2 2 111 2222 2 2    

( Halimbawa ) Mayroong ilang bagay na <markahan>pansinin dito:</mark> Una, hindi na kami kumukuha ng mga kuwit mula noong binago namin ang grupong kumukuha (^|,)sa isang pangkat na hindi kumukuha (?:^|,). Pangalawa, nilagyan namin ang pangkat ng pagkuha sa loob ng pangkat na hindi nakuha. Ito ay kapaki-pakinabang kapag, halimbawa, kailangan mo ng isang pangkat ng mga character upang lumitaw sa isang partikular na pagkakasunud-sunod, ngunit mahalaga ka lamang sa isang subset ng mga character na iyon. Sa aming kaso, kailangan namin ng mga hindi quote na character at hindi mga kuwit [^",]*upang lumabas sa mga quote, ngunit hindi namin talaga kailangan ang mga quote character mismo, kaya hindi na nila kailangang makuha. Panghuli, <mark>tandaan</mark> na sa halimbawa sa itaas ay mayroon ding zero-length na tugma sa pagitan ng mga character kat l. Ang mga quote ""ay ang hinanap na substring, ngunit walang mga character sa pagitan ng mga quote, kaya ang katugmang substring ay walang mga character (zero ang haba). <h3>Pagsasamahin ba natin ang ating kaalaman? Narito ang dalawa at kalahating gawain na tutulong sa amin dito:</h3> Gamit ang mga hindi kumukuha na grupo (at kumukuha ng mga grupo, at mga klase ng character, atbp.), magsulat ng isang regular na expression na kumukuha lamang ng wastong na-format na mga laki ng file sa linya sa ibaba:

pattern:
string:   6.6KB 1..3KB 12KB 5G 3.3MB KB .6.2TB 9MB .
mga tugma: ^^^^^ ^^^^^ ^^^^^^ ^^^^ 
pangkat:    11111 1111 11111 111    

( Solusyon ) Ang mga pambungad na tag ng HTML ay nagsisimula sa <at nagtatapos sa >. Nagsisimula ang mga tag ng pagsasara ng HTML sa isang pagkakasunod-sunod ng mga character </at nagtatapos sa character >. Ang pangalan ng tag ay nasa pagitan ng mga character na ito. Maaari ka bang magsulat ng isang regular na expression upang makuha lamang ang mga pangalan sa mga sumusunod na tag? (Maaaring malutas mo ang problemang ito nang hindi gumagamit ng mga hindi kumukuha na grupo. Subukang lutasin ang dalawang paraan na ito! Minsan kasama ang mga grupo at minsan ay wala.)

pattern:
string:   <p> </span> <div> </kbd> <link> 
mga tugma: ^^^ ^^^^^^ ^^^^^ ^^^^^^ ^^^^^^ 
pangkat:    1 1111 111 111 1111    

( Solusyon gamit ang mga grupong hindi kumukuha ) ( Solusyon nang hindi gumagamit ng mga grupong hindi kumukuha ) <h2>Hakbang 17: Mga backlink \Nat pinangalanang mga grupong kumukuha</h2> Bagama't binalaan kita sa panimula na kadalasang sinusubukang lumikha ng HTML parser gamit ang mga regular na expression humahantong sa sakit sa puso, ang huling halimbawang ito ay isang magandang segue sa isa pang (minsan) kapaki-pakinabang na tampok ng karamihan sa mga regular na expression: backreferences. Ang mga backlink ay parang paulit-ulit na mga grupo kung saan maaari mong subukang makuha ang parehong teksto nang dalawang beses. Ngunit naiiba sila sa isang mahalagang aspeto - kukuha lamang sila ng parehong teksto, karakter sa karakter. Habang ang paulit-ulit na grupo ay magbibigay-daan sa amin na makuha ang isang bagay na tulad nito:

pattern: (he(?:[az])+) 
string:   heyabcdefg hey heyo heyellow heyyyyyyyyy 
mga tugma: ^^^^^^^^^^ ^^^ ^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ 
pangkat:    1111111111 111 1111 11111111 11111111111    

( Halimbawa ) ...kung gayon ang backlink ay tutugma lamang dito:

pattern: (he([az])(\2+)) 
string: heyabcdefg hey heyo heyellow heyyyyyyyyy 
mga tugma:                              ^^^^^^^^^^^ 
pangkat:                                 11233333333    

( Halimbawa ) Ang mga paulit-ulit na grupo ng pagkuha ay kapaki-pakinabang kapag gusto mong itugma ang parehong pattern nang paulit-ulit, samantalang ang mga backlink ay mabuti kapag gusto mong itugma ang parehong teksto. Halimbawa, maaari kaming gumamit ng backlink upang subukang maghanap ng magkatugmang pambungad at pagsasara ng mga HTML na tag:

pattern: <(\w+)[^>]*>[^<]+<\/\1> 
string:   <span style="color: red">hey</span> 
mga tugma: ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
pangkat:    1111    

( Halimbawa ) <mark>Pakitandaan</mark> na ito ay isang napakasimpleng halimbawa at lubos kong inirerekomenda na huwag mong subukang magsulat ng isang regular na expression na nakabatay sa HTML parser. Ito ay napakakomplikadong syntax at malamang na magdudulot sa iyo ng sakit. Ang mga pinangalanang pangkat ng pagkuha ay halos kapareho sa mga backlink, kaya't tatalakayin ko ang mga ito sa madaling sabi dito. Ang pagkakaiba lang sa pagitan ng mga backreference at isang pinangalanang pangkat ng pagkuha ay... ang isang pinangalanang pangkat ng pagkuha ay may pangalan:

pattern: <(?<tag>\w+)[^>]*>[^<]+<\/(?P=tag)></tag> 
string:   <span style="color: red">hoy< /span> 
mga tugma: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
pangkat:    1111    

( Halimbawa ) Maaari kang lumikha ng isang pinangalanang grupo ng pagkuha gamit ang (?<pangalan>...) o (?'pangalan'...) syntax (.NET-compatible na regular na expression) o gamit ang syntax na ito (?P<name>. ..) o (?P'name'...) (Python-compatible regular expression). Dahil gumagamit kami ng PCRE (Perl Compatible Regular Expression) na sumusuporta sa parehong bersyon, maaari naming gamitin ang alinman dito. (Kinopya ng Java 7 ang .NET syntax, ngunit ang bersyon lamang ng mga bracket ng anggulo. Tala ng tagasalin) Upang ulitin ang isang pinangalanang pangkat ng pagkuha sa ibang pagkakataon sa isang regular na expression, ginagamit namin ang \<kname> o \k'name' (.NET) o (? P= pangalan) (Python). Muli, sinusuportahan ng PCRE ang lahat ng iba't ibang opsyong ito. Maaari kang magbasa nang higit pa tungkol sa mga pinangalanang pangkat ng pagkuha dito , ngunit ito ang karamihan sa kung ano ang talagang kailangan mong malaman tungkol sa kanila. <h3>Gawain upang tulungan kami:</h3> Gumamit ng mga backlink upang matulungan akong matandaan... ummm... ang pangalan ng taong ito.

pattern:
string: "Hi my name's Joe." [mamaya] "Ano ang pangalan ng lalaking iyon? Joe ?"
mga tugma:        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
pangkat:                  111    

( Solusyon ) <h2>Hakbang 18: tumingin sa unahan at tumingin sa likod</h2> Ngayon ay susuriin natin ang ilan sa mga advanced na feature ng mga regular na expression. Ginagamit ko ang lahat hanggang sa hakbang 16 nang madalas. Ngunit ang mga huling hakbang na ito ay para lamang sa mga taong sineseryoso ang paggamit ng regex upang tumugma sa napakakumplikadong mga expression. Sa madaling salita, mga masters ng mga regular na expression. Ang "Looking Forward" at "Looking Back" ay maaaring mukhang medyo kumplikado, ngunit talagang hindi sila masyadong kumplikado. Pinahihintulutan ka nilang gumawa ng isang bagay na katulad ng ginawa namin sa mga hindi kumukuha na grupo kanina - tingnan kung mayroong anumang teksto kaagad bago o kaagad pagkatapos ng aktwal na teksto na gusto naming itugma. Halimbawa, ipagpalagay na gusto lang nating itugma ang mga pangalan ng mga bagay na gusto ng mga tao, ngunit kung sila ay masigasig tungkol dito (kung tatapusin lang nila ang kanilang pangungusap sa isang tandang padamdam). Maaari tayong gumawa ng isang bagay tulad ng:

pattern: (\w+)(?=!) 
string: Gusto ko ng desk. Pinahahalagahan ko ang stapler. Mahal ko ang lampara !
mga tugma:                                           ^^^^ 
pangkat:                                              1111    

( Halimbawa ) Makikita mo kung paano tumutugma lamang sa salitang lampara ang pangkat ng pagkuha sa itaas (\w+), na karaniwang tumutugma sa alinman sa mga salita sa sipi. Nangangahulugan ang positibong pagtingin sa unahan (?=!)na maaari lamang nating itugma ang mga pagkakasunud-sunod na nagtatapos !ngunit hindi talaga tayo tumutugma sa karakter ng tandang padamdam. Ito ay isang mahalagang pagkakaiba dahil sa mga pangkat na hindi kumukuha ay tinutugma namin ang karakter ngunit hindi ito nakukuha. Sa lookaheads at lookabacks, gumagamit kami ng isang character upang buuin ang aming regular na expression, ngunit pagkatapos ay hindi namin ito itinutugma laban sa kanyang sarili. Maaari naming itugma ito mamaya sa aming regular na expression. May apat na uri ng lookaheads at lookaheads: positive lookahead (?=...), negative lookahead (?!...), positive lookahead (?<=...) at negative lookahead (?<!. ..) . Ginagawa nila kung ano ang kanilang tunog - positibong tumingin sa unahan at tumingin sa likod ay nagbibigay-daan sa regular na expression engine na magpatuloy sa pagtutugma lamang kapag ang tekstong nilalaman sa lookahead/lookaback ay talagang tumutugma. Kabaligtaran ang ginagawa ng negatibong lookahead at lookaback - pinapayagan nila ang regex na tumugma lamang kapag hindi tumugma ang text na nasa lookahead/lookaback. Halimbawa, gusto naming itugma ang mga pangalan ng pamamaraan sa isang hanay ng mga pagkakasunud-sunod ng pamamaraan, hindi ang bagay na pinapatakbo nila. Sa kasong ito, ang bawat pangalan ng pamamaraan ay dapat na unahan ng isang .. Ang isang regular na expression gamit ang isang simpleng pagbabalik tanaw ay makakatulong dito:

pattern: (?<=\.)(\w+) 
string: myArray. flatMap.aggregate.summarise.print !
mga tugma:         ^^^^^^^ ^^^^^^^^^ ^^^^^^^^^ ^^^^^ 
pangkat:            1111111 111111111 111111111 11111    

( Halimbawa ) Sa teksto sa itaas, tinutugma namin ang anumang pagkakasunud-sunod ng mga character ng salita \w+, ngunit kung mauunahan lang sila ng character .. Maaari kaming makamit ang isang katulad na bagay gamit ang mga hindi nakakakuha na grupo, ngunit ang resulta ay medyo magulo:

pattern: (?:\.)(\w+) 
string: myArray .flatMap.aggregate.summarise.print !
mga tugma:        ^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^ ^^^^^ 
pangkat:            1111111 111111111 111111111 11111    

( Halimbawa ) Kahit na mas maikli, tumutugma ito sa mga character na hindi natin kailangan. Bagama't ang halimbawang ito ay tila walang halaga, ang mga tingin sa unahan at pagtingin sa likod ay talagang makakatulong sa atin na linisin ang ating mga regular na ekspresyon. <h3>Kaunti na lang ang natitira hanggang sa matapos! Ang sumusunod na 2 gawain ay magdadala sa amin ng 1 hakbang na mas malapit dito:</h3> Ang negatibong pagtingin sa likod (?<!...) ay nagbibigay-daan sa regular na expression engine na patuloy na subukang maghanap ng tugma kung ang text na nilalaman sa loob ng negatibong lookbehind ay hindi ipinapakita hanggang sa natitirang bahagi ng teksto , kung saan kailangan mong maghanap ng tugma. Halimbawa, maaari kaming gumamit ng regular na expression upang tumugma lamang sa mga apelyido ng mga babaeng dumadalo sa isang kumperensya. Upang gawin ito, nais naming tiyakin na ang apelyido ng tao ay hindi pinangungunahan ng isang Mr.. Maaari ka bang magsulat ng isang regular na expression para dito? (Ang mga apelyido ay maaaring ipagpalagay na hindi bababa sa apat na character ang haba.)

pattern:
string: Mr. Brown, Ms. Smith , Gng. Jones , Miss Daisy , Mr. Berde
mga tugma:                ^^^^^ ^^^^^ ^^^^^ 
pangkat:                   11111 11111 11111    

( Solusyon ) Sabihin nating nililinis namin ang isang database at mayroon kaming column ng impormasyon na kumakatawan sa mga porsyento. Sa kasamaang palad, ang ilang mga tao ay nagsulat ng mga numero bilang mga decimal na halaga sa hanay [0.0, 1.0], habang ang iba ay sumulat ng mga porsyento sa hanay [0.0%, 100.0%], at ang iba ay sumulat ng mga halaga ng porsyento. ngunit nakalimutan ang literal na porsyentong tanda %. Gamit ang negatibong lookahead (?!...), maaari mo bang markahan lamang ang mga halagang iyon na dapat ay mga porsyento ngunit nawawalang mga digit %? Ang mga ito ay dapat na mga halaga na mas mataas sa 1.00, ngunit walang kasunod %. (Walang numero ang maaaring maglaman ng higit sa dalawang digit bago o pagkatapos ng decimal point.) <mark>Tandaan</mark> na ang solusyong ito ay lubhang mahirap . Kung malulutas mo ang problemang ito nang hindi tinitingnan ang aking sagot, kung gayon mayroon ka nang malalaking kasanayan sa mga regular na expression!

pattern:
string: 0.32 100.00 5.6 0.27 98% 12.2% 1.01 0.99% 0.99 13.13 1.10 
mga tugma:      ^^^^^^ ^^^ ^^^^ ^^^^^ ^^^^ 
pangkat:         111111 111 1111    

( Solusyon ) <h2>Hakbang 19: Mga Kundisyon sa Mga Regular na Ekspresyon</h2> Naabot na namin ngayon ang punto kung saan karamihan sa mga tao ay hindi na gagamit ng mga regular na expression. Nasaklaw na namin ang malamang na 95% ng mga kaso ng paggamit para sa mga simpleng regular na expression, at lahat ng ginagawa sa hakbang 19 at 20 ay karaniwang ginagawa ng isang mas buong tampok na wika sa pagmamanipula ng teksto tulad ng awk o sed (o isang pangkalahatang layunin na programming language). Sabi nga, magpatuloy tayo, para lang malaman mo kung ano talaga ang nagagawa ng regular expression. Bagama't hindi kumpleto ang Turing ng mga regular na expression , nag-aalok ang ilang regular na expression engine ng mga feature na halos kapareho sa isang kumpletong programming language. Ang isang ganoong tampok ay "kondisyon". Ang mga kondisyon ng regex ay nagpapahintulot sa mga pahayag na if-then-else, kung saan ang napiling sangay ay tinutukoy ng alinman sa "look forward" o "look back" na natutunan namin sa nakaraang hakbang. Halimbawa, maaaring gusto mong itugma lamang ang mga wastong entry sa isang listahan ng mga petsa:

pattern: (?<=Peb )([1-2][0-9])|(?<=Mar )([1-2][0-9]|3[0-1]) 
string: Mga petsang nagtrabaho : Peb 28 , Peb 29 , Peb 30 , Mar 30 , Mar 31  
mga tugma:                   ^^ ^^ ^^ ^^ 
pangkat:                      11 11 22 22    

( Halimbawa ) <mark>Tandaan</mark> na ang mga pangkat sa itaas ay ini-index din ayon sa buwan. Maaari kaming magsulat ng isang regular na expression para sa lahat ng 12 buwan at makuha lamang ang mga wastong petsa, na pagkatapos ay isasama sa mga pangkat na na-index ayon sa buwan ng taon. Ang nasa itaas ay gumagamit ng isang uri ng kung-tulad ng istraktura na maghahanap lamang ng mga tugma sa unang pangkat kung ang "Peb" ay nauuna sa isang numero (at katulad din para sa pangalawa). Ngunit paano kung nais lamang naming gumamit ng espesyal na pagproseso para sa Pebrero? Isang bagay na tulad ng "kung ang numero ay nauunahan ng "Peb", gawin ito, kung hindi, gawin itong ibang bagay." Narito kung paano ito ginagawa ng mga kondisyon:

pattern: (?(?<=Peb )([1-2][0-9])|([1-2][0-9]|3[0-1])) 
string: Mga petsang nagtrabaho: Peb 28 , Peb 29 , Peb 30, Mar 30 , Mar 31  
mga laban:                   ^^ ^^ ^^ ^^ 
pangkat:                      11 11 22 22    

( Halimbawa ) Ang istrakturang kung-pagkatapos ay parang (?(If)then|else), kung saan ang (if) ay pinapalitan ng "look forward" o "look back". Sa halimbawa sa itaas, (kung) ay nakasulat bilang (?<=Feb). Makikita mong nagtugma kami ng mga petsang higit sa 29, ngunit kung hindi sila sumunod sa "Peb." Ang paggamit ng lookbehinds sa mga conditional na expression ay kapaki-pakinabang kung gusto mong tiyakin na ang tugma ay nauunahan ng ilang teksto. Maaaring nakakalito ang mga positibong lookahead na kondisyon dahil ang kundisyon mismo ay hindi tumutugma sa anumang text. Kaya't kung nais mong magkaroon ng halaga ang kundisyon kung, dapat itong maihambing sa pagtingin sa unahan tulad ng nasa ibaba:

pattern: (?(?=eksakto)eksakto|iba pa)wo 
string: eksaktong iba eksaktowo elsewo  
tugma:            ^^^^^^^ ^^^^^^

( Halimbawa ) Nangangahulugan ito na walang silbi ang mga kondisyong positibong tumingin sa unahan. Tinitingnan mo kung nasa unahan ang text na iyon at pagkatapos ay magbibigay ng katugmang pattern na susundan kung kailan. Ang conditional expression ay hindi nakakatulong sa amin dito. Maaari mo ring palitan ang nasa itaas ng isang mas simpleng regular na expression:

pattern: (?:exact|else)wo 
string: exact else exactwo else  
tugma:            ^^^^^^^ ^^^^^^

( Halimbawa ) Kaya, ang panuntunan ng thumb para sa mga conditional na expression ay: pagsubok, pagsubok, at pagsubok muli. Kung hindi, ang mga solusyon na sa tingin mo ay halata ay mabibigo sa pinakakapana-panabik at hindi inaasahang mga paraan :) <h3>Narito na tayo sa huling bloke ng mga gawain na naghihiwalay sa atin mula sa panghuling, ika-20 hakbang:</h3> Sumulat ng isang regular na expression na gumagamit ng negatibong lookahead conditional expression upang subukan kung ang susunod na salita ay nagsisimula sa malaking titik. Kung gayon, kumuha lamang ng isang malaking titik at pagkatapos ay ang mga maliliit na titik. Kung hindi, kunin ang anumang mga character ng salita.

pattern:
string:   Jones Smith 9sfjn Hobbes 23r4tgr9h CSV Csv vVv 
na mga tugma: ^^^^^ ^^^^^ ^^^^^ ^^^^^^ ^^^^^^^^^ ^^^ ^^^ 
pangkat:    22222 22222 11111 222222 111111111 222 111    

( Solusyon ) Sumulat ng negatibong pagtingin sa likod ng conditional na expression na kumukuha ownslamang ng teksto kung hindi ito nangunguna sa teksto cl, at kumukuha oudslamang ng teksto kapag naunahan ito ng teksto cl. (Medyo isang ginawang halimbawa, ngunit ano ang magagawa mo...)

pattern:
string: Ang mga clown na iyon ay nagmamay-ari ng ilang cl ouds . ouds.
mga tugma:              ^^^^ ^^^^   

( Solusyon ) <h2>Hakbang 20: Recursion at Karagdagang Pag-aaral</h2> Sa katunayan, marami ang maaaring maipit sa 20-hakbang na pagpapakilala sa anumang paksa, at ang mga regular na expression ay walang pagbubukod. Maraming iba't ibang pagpapatupad at pamantayan para sa mga regular na expression na makikita sa Internet. Kung gusto mong matuto nang higit pa, iminumungkahi kong tingnan mo ang magandang site na regularexpressions.info , ito ay isang kamangha-manghang sanggunian at tiyak na marami akong natutunan tungkol sa mga regular na expression mula doon. Lubos kong inirerekomenda ito, pati na rin ang regex101.com para sa pagsubok at pag-publish ng iyong mga nilikha. Sa huling hakbang na ito, bibigyan kita ng kaunting kaalaman tungkol sa mga regular na expression, lalo na kung paano magsulat ng mga recursive na expression. Ang mga simpleng recursion ay medyo simple, ngunit isipin natin kung ano ang ibig sabihin nito sa konteksto ng isang regular na expression. Ang syntax para sa simpleng recursion sa isang regular na expression ay nakasulat tulad nito: (?R)?. Ngunit, siyempre, ang syntax na ito ay dapat na lumitaw sa loob mismo ng expression. Ang gagawin natin ay ilagay ang ekspresyon sa loob ng sarili nito, isang arbitrary na dami ng beses. Halimbawa:

pattern: (hey(?R)?oh) 
string:   heyoh heyyoh heyheyohoh hey oh heyhey hey heyheyohoh  
mga tugma: ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ 
grupo:    11111 1111111111 1111111111    

( Halimbawa ) Dahil ang nested expression ay opsyonal ( (?R)sinundan ?), ang pinakasimpleng tugma ay ang ganap na huwag pansinin ang recursion. Kaya, hey, at pagkatapos ohay tumutugma sa ( heyoh). Upang tumugma sa anumang mas kumplikadong expression kaysa dito, dapat nating makita na ang pagtutugma ng substring ay naka-nested sa loob mismo sa punto sa expression kung saan namin ipinasok (?R)ang sequence. Sa madaling salita, mahahanap natin ang heyheyohoh o heyheyheyohohoh, at iba pa. Ang isa sa mga magagandang bagay tungkol sa mga nested na expression na ito ay, hindi tulad ng mga backreference at pinangalanang mga grupo ng pagkuha, hindi ka nila nililimitahan sa eksaktong teksto na iyong itinugma dati, character ayon sa karakter. Halimbawa:

pattern: ([Hh][Ee][Yy](?R)?oh) 
string:   heyoh heyyoh hEyHeYohoh hey oh heyhey hEyHeYHEyohohoh  
mga tugma: ^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^ 
pangkat:    11111 1111111111 1111111111111111    

( Halimbawa ) Maaari mong isipin na ang regular na expression engine ay literal na kinokopya at i-paste ang iyong regular na expression sa sarili nito ng arbitrary na dami ng beses. Siyempre, nangangahulugan ito na kung minsan ay maaaring hindi nito magawa ang inaasahan mo:

pattern: ((?:\(\*)[^*)]*(?R)?(?:\*\))) 
string: (* komento (* nested *) hindi *)
mga tugma:            ^^^^^^^^^^^^ 
pangkat:               111111111111    

( Halimbawa ) Masasabi mo ba kung bakit ang naka-nest na komento lang ang nakuha ng regex na ito at hindi ang panlabas na komento? Isang bagay ang sigurado: kapag nagsusulat ng mga kumplikadong regular na expression, palaging subukan ang mga ito upang matiyak na gumagana ang mga ito sa paraang inaakala mong gagawin nila. Ang high-speed rally na ito sa mga kalsada ng mga regular na expression ay natapos na. Sana ay nasiyahan ka sa paglalakbay na ito. Buweno, at sa wakas, aalis ako dito, tulad ng ipinangako ko sa simula, maraming mga kapaki-pakinabang na link para sa isang mas malalim na pag-aaral ng materyal:

• Mga regular na expression sa Java (Artikulo ni Alex)
• Mga regular na expression sa Java (Pagsasalin ng isang artikulo ni Jeff Friesen mula kay Elleanor Kerry)
• Mga halimbawa ng java ng regular na expression (na may maginhawang syntax table)
• Mga Matakaw at Tamad na Quantifier (Mga Halimbawa ng JavaScript)
• 25 Pinaka Ginagamit na Regular Expression sa Java
• RegexOne (Mga gawaing may pagsusuri)
• Huwag matakot sa mga regular na expression. Regex sa loob ng 20 minuto! (para sa mga mas gusto ang mga video tutorial)