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

Ang orihinal ng artikulong ito ay narito . Marahil ay walang masyadong teorya, at magbibigay ako ng ilang mga link sa mas detalyadong materyal sa regex sa dulo ng artikulo. Ngunit tila sa akin na ang pagsisimula sa isang paksa tulad ng mga regular na expression ay magiging mas kawili-wili kung mayroong isang pagkakataon na hindi lamang magsiksik, ngunit agad ding pagsamahin ang kaalaman sa pamamagitan ng pagkumpleto ng maliliit na gawain sa daan. Magsimula na tayo. Karaniwang binabanggit ng mga kalaban sa paggamit ng mga regular na expression ('RegEx' o simpleng 'regex') sa programming ang sumusunod na quote, na iniuugnay kay Jamie Zawinski: "Ang ilang mga tao, kapag nahaharap sa isang problema, iniisip, 'Alam ko, gagamit ako ng mga regular na expression. .'" Ngayon ay mayroon silang dalawang Problema". Sa katunayan, ang paggamit ng mga regular na expression ay hindi pa mabuti o masamang ideya. At ito mismo ay hindi magdaragdag ng mga problema at hindi malulutas ang alinman sa mga ito. Ito ay isang kasangkapan lamang. At kung paano mo ito ginagamit (tama o mali) ang tumutukoy kung anong mga resulta ang makikita mo. Kung susubukan mong gumamit ng regex, halimbawa, upang lumikha ng HTML parser, malamang na makakaranas ka ng sakit . Ngunit kung gusto mo lang i-extract, halimbawa, ang mga timestamp mula sa ilang row, malamang na magiging maayos ka. Upang gawing mas madali para sa iyo na makabisado ang mga regular na expression, pinagsama-sama ko ang araling ito na tutulong sa iyo na makabisado ang mga regular na expression mula sa simula sa loob lamang ng dalawampung maikling hakbang. Pangunahing tumutuon ang tutorial na ito sa mga pangunahing konsepto ng mga regular na expression at nagsasaliksik sa mas advanced na mga paksa kung kinakailangan lamang.

Hakbang 1: Bakit gumamit ng mga regular na expression

Ang mga regular na expression ay ginagamit upang maghanap ng mga tugma sa teksto gamit ang mga tinukoy na pattern (mga pattern). Gamit ang regex, madali at simpleng makakapag-extract tayo ng mga salita mula sa text, pati na rin ang mga indibidwal na literal at meta character at ang mga pagkakasunud-sunod ng mga ito na nakakatugon sa ilang partikular na pamantayan. Narito ang sinasabi sa atin ng Wikipedia tungkol sa mga ito : Ang mga regular na expression ay isang pormal na wika para sa paghahanap at pagmamanipula ng mga substring sa teksto, batay sa paggamit ng mga metacharacter (mga wildcard na character). Para sa paghahanap, ginagamit ang isang sample na string (pattern ng Ingles, sa Russian na madalas na tinatawag na "template", "mask"), na binubuo ng mga simbolo at metasymbol at tinukoy ang panuntunan sa paghahanap. Upang manipulahin ang teksto, ang isang kapalit na string ay karagdagang tinukoy, na maaari ding maglaman ng mga espesyal na character. Ang pattern ay maaaring kasing simple ng salita dogsa pangungusap na ito:

Ang mabilis na brown fox ay tumalon sa ibabaw ng tamad na aso.

Ang regular na expression na ito ay ganito ang hitsura:

aso

... Madali lang, di ba? Ang pattern ay maaari ding maging anumang salita na naglalaman ng titik o. Ang isang regular na expression upang makahanap ng gayong pattern ay maaaring magmukhang ganito:

\w * o\w *

( Maaari mong subukan ang regular na expression na ito dito .) Mapapansin mo na habang ang "pagtutugma" na mga kinakailangan ay nagiging mas kumplikado, ang regular na expression ay nagiging mas kumplikado. May mga karagdagang anyo ng notasyon para sa pagtukoy ng mga pangkat ng mga character at pagtutugma ng mga umuulit na pattern, na ipapaliwanag ko sa ibaba. Ngunit, sa sandaling makakita kami ng tugma sa isang pattern sa ilang teksto, ano ang magagawa namin dito? Binibigyang-daan ka ng mga modernong regular na expression engine na mag-extract ng mga character o sequence ng mga character (substrings) mula sa nilalamang text, o alisin ang mga ito, o palitan ang mga ito ng ibang text. Sa pangkalahatan, ang mga regular na expression ay ginagamit upang i-parse at manipulahin ang teksto. Maaari naming i-extract, halimbawa, ang mga substring na mukhang mga IP address at pagkatapos ay subukang i-verify ang mga ito. O maaari naming kunin ang mga pangalan at email address at iimbak ang mga ito sa isang database. O gumamit ng mga regular na expression upang maghanap ng sensitibong impormasyon (tulad ng mga numero ng pasaporte o numero ng telepono) sa mga email at alertuhan ang user na maaaring inilalagay nila ang kanilang sarili sa panganib. Ang Regex ay talagang isang maraming nalalaman na tool na madaling matutunan ngunit mahirap na master: "Kung paanong may pagkakaiba sa pagitan ng mahusay na pagtugtog ng isang piraso ng musika at paglikha ng musika, may pagkakaiba sa pagitan ng pag-alam sa mga regular na expression at pag-unawa sa mga ito." - Jeffrey E. F. Friedl, Mastering Regular Expressions

Hakbang 2: Mga Square Bracket[]

Ang pinakasimpleng mga regular na expression na madaling maunawaan ay ang mga naghahanap lang ng character-by-character na tugma sa pagitan ng pattern ng regular na expression at ng target na string. Halimbawa, subukan nating maghanap ng pusa:

pattern: pusa
string: Naputol ang pusa nang tumakbo ito sa ilalim ng kotse.
mga tugma:      ^^^

( Paano ito gumagana sa pagsasanay - tingnan dito ) NB! Ang lahat ng mga solusyon ay ipinakita dito bilang mga posibleng solusyon lamang. Sa mga regular na expression, tulad ng sa programming sa pangkalahatan, maaari mong malutas ang parehong mga problema sa iba't ibang paraan. Gayunpaman, bilang karagdagan sa isang mahigpit na paghahambing ng character-by-character, maaari din naming tukuyin ang mga alternatibong tugma gamit ang mga square bracket:

pattern: car[rt]
string: Naputol ang pusa nang tumakbo ito sa ilalim ng kotse.
mga tugma:      ^^^ ^^^

( Paano ito gumagana ) Ang pagbubukas at pagsasara ng mga square bracket ay nagsasabi sa regular na expression engine na dapat itong tumugma sa alinman sa mga tinukoy na character, ngunit isa lamang. Ang regular na expression sa itaas ay hindi mahahanap, halimbawa, ang cartbuong salita, ngunit makikita lamang ang bahagi nito:

pattern: car[rt]
string: Naputol ang pusa nang tumakbo ito sa ilalim ng kariton.
mga tugma:      ^^^ ^^^

( Paano ito gumagana ) Kapag gumamit ka ng mga square bracket, sasabihin mo sa regular na expression engine na tumugma lamang sa isa sa mga character na nasa loob ng mga bracket. Hinahanap ng makina ang karakter c, pagkatapos ay ang karakter a, ngunit kung ang susunod na karakter ay hindi ro t, hindi ito kumpletong tugma. Kung mahahanap nito ang ca, at pagkatapos ay alinman sa r, o t, hihinto ito. Hindi nito susubukan na tumugma sa higit pang mga character dahil ang mga square bracket ay nagpapahiwatig na isa lamang sa mga nilalamang character ang kailangang itugma. Kapag nakahanap ito ca, hahanapin nito rang susunod na salita cart, at hihinto dahil nakahanap na ito ng katugma para sa pagkakasunod-sunod car.

Mga layunin sa pagsasanay:

Sumulat ng regular na expression na tumutugma sa lahat ng 10 pattern hadsa Hadsipi na ito ng mga hindi maisasalin na puns sa lokal na diyalekto:

pattern:
string: Si Jim, kung saan nagkaroon si Bill ng "nagkaroon" , ay nagkaroon ng "nagkaroon" . "Had had" ay tama.
mga tugma:                  ^^^ ^^^ ^^^ ^^^ ^^^ ^^^ ^^^ ^^^ ^^^ ^^^ ^^^

( Tingnan ang posibleng solusyon dito ) Paano ang lahat ng pangalan ng hayop sa sumusunod na pangungusap?

pattern:
string: Isang paniki, pusa, at daga ang pumasok sa isang bar...
mga tugma:    ^^^ ^^^ ^^^

( Posibleng solusyon ) O mas simple: hanapin ang mga salita baro bat:

pattern:
string: Isang paniki, pusa, at daga ang pumasok sa isang bar...
mga tugma:    ^^^ ^^^

( Posibleng solusyon ) Ngayon natutunan na namin kung paano magsulat ng mas marami o hindi gaanong kumplikadong mga regular na expression, at nasa step 2 pa lang kami! Ituloy natin!

Hakbang 3: Mga Escape Sequence

Sa nakaraang hakbang, natutunan namin ang tungkol sa mga square bracket []at kung paano kami tinutulungan ng mga ito na makahanap ng mga alternatibong tugma gamit ang regex engine. Ngunit paano kung gusto nating makahanap ng mga tugma sa anyo ng mga bukas at saradong square bracket mismo []? Kapag gusto naming maghanap ng character-by-character na tugma ng salita cat, ibinigay namin ang regex engine ng ganitong pagkakasunud-sunod ng mga character ( cat). Subukan nating maghanap ng mga square bracket []sa parehong paraan:

pattern: [] 
string: Hindi mo maitugma ang [] gamit ang regex! Pagsisisihan mo ito!
mga tugma: 

( Tingnan natin kung ano ang nangyari ) May hindi gumana, gayunpaman... Ito ay dahil ang mga square bracket na character ay gumaganap bilang mga espesyal na regex engine na character na karaniwang ginagamit upang ipahiwatig ang ibang bagay, at hindi isang literal na pattern upang tumugma sa kanila mismo. Tulad ng naaalala namin mula sa hakbang 2, ginagamit ang mga ito upang maghanap ng mga alternatibong tugma upang ang regex engine ay maaaring tumugma sa alinman sa mga character na nasa pagitan ng mga ito. Kung hindi ka maglalagay ng anumang mga character sa pagitan nila, maaari itong magdulot ng error. Upang itugma ang mga espesyal na character na ito, dapat nating takasan ang mga ito sa pamamagitan ng unahan sa kanila ng isang backslash na character \. Ang backslash (o backslash) ay isa pang espesyal na character na nagsasabi sa regex engine na hanapin ang susunod na character nang literal, sa halip na gamitin ito bilang isang metacharacter. Ang regex engine ay maghahanap lamang ng mga character [at ]literal kung pareho silang nauunahan ng backslash:

pattern: \[\]
string: Hindi mo maitugma ang [] gamit ang regex! Pagsisisihan mo ito!
mga tugma:                  ^^ 

( Tingnan natin kung ano ang nangyari sa pagkakataong ito ) OK, paano kung gusto nating hanapin ang backslash mismo? Simple lang ang sagot. Dahil \isang espesyal na karakter din ang backslash, kailangan din itong i-escape. Paano? Backslash!

pattern: \\
string: C:\Users\Tanja\Pictures\Dogs
mga tugma:    ^^ ^^

( Parehong halimbawa sa pagsasanay ) Mga espesyal na character lang ang dapat na mauna sa backslash. Ang lahat ng iba pang mga character ay literal na binibigyang kahulugan bilang default. Halimbawa, ang regular na expression ay tliteral na tumutugma lamang sa tmga maliliit na titik:

pattern: t
string: tttt
mga tugma: ^^ ^^

( Halimbawa ) Gayunpaman, ang pagkakasunod-sunod na ito \tay gumagana nang iba. Ito ay isang template para sa paghahanap ng isang tab na character:

pattern: \t
string: tttt
mga tugma:   ^^

( Halimbawa ) Kasama sa ilang karaniwang mga pagkakasunud-sunod ng pagtakas \n(UNIX-style line break) at \r(ginagamit sa Windows-style na line break \r\n). \ray isang character na "carriage return" at \nisang character na "line feed", na parehong tinukoy kasama ng pamantayan ng ASCII noong malawak na ginagamit ang mga teletypewriter. Ang iba pang mga karaniwang pagkakasunud-sunod ng pagtakas ay sasaklawin mamaya sa tutorial na ito.

Pansamantala, palakasin natin ang materyal gamit ang ilang simpleng puzzle:

Subukang magsulat ng isang regular na expression upang makahanap ng... isang regular na expression ;) Ang resulta ay dapat na ganito:

pattern:
string: ...itugma ang regex na ito ` \[\] ` sa isang regex?
mga tugma:                       ^^^^	

( Solusyon ) Nagawa mo ba? Magaling! Ngayon subukang gumawa ng regex para maghanap ng mga escape sequence tulad nito:

pattern:
string: ` \r `, ` \t `, at ` \n ` ay lahat ng regex escape sequence.
mga tugma:   ^^ ^^ ^^

( Solusyon )

Hakbang 4: hanapin ang "anumang" character gamit ang isang tuldok.

Kapag isinusulat ang mga solusyon sa pagtutugma ng pagkakasunud-sunod ng pagtakas na nakita namin sa nakaraang hakbang, maaaring naisip mo, "Maaari ko bang itugma ang character na backslash at pagkatapos ay anumang iba pang karakter na sumusunod dito?"... Siyempre kaya mo! May isa pang espesyal na karakter na ginagamit upang tumugma sa (halos) anumang karakter - ang tuldok (full stop) na karakter. Narito ang ginagawa nito:

pattern: .
string: Sorry, Dave. Natatakot akong hindi ko magawa iyon.
mga tugma: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^	

( Halimbawa ) Kung gusto mo lang itugma ang mga pattern na mukhang mga escape sequence, maaari kang gumawa ng ganito:

pattern: \\. 
string: Hi Walmart ang apo ko doon ang pangalan niya ay " \n \r \t ".
mga tugma:                                              ^^ ^^ ^^	

( Halimbawa ) At, tulad ng lahat ng mga espesyal na character, kung gusto mong tumugma sa isang literal ., kailangan mong unahan ito ng isang character \:

pattern: \. 
string: Ang Digmaan ay Kapayapaan . Ang Kalayaan ay Pang-aalipin . Ang kamangmangan ay Lakas . 
mga tugma:             ^^

( Halimbawa )

Hakbang 5: Mga Saklaw ng Character

Paano kung hindi mo kailangan ng anumang mga simbolo, ngunit nais lamang na makahanap ng mga titik sa teksto? O mga numero? O patinig? Ang paghahanap ayon sa mga klase ng character at kanilang mga hanay ay magbibigay-daan sa amin na makamit ito.

` \n `, ` \r `, at ` \t ` ay mga character na whitespace, ` \. `, ` \\ ` at ` \[ ` ay hindi .	

Ang mga character ay "whitespace" kung hindi sila lumikha ng nakikitang marka sa teksto. Ang puwang na " " ay isang puwang, line break, o tab. Sabihin nating gusto nating maghanap ng mga escape sequence na kumakatawan lang sa mga whitespace na character \n, \rat \tsa passage sa itaas, ngunit hindi sa iba pang escape sequence. Paano natin ito magagawa?

pattern: \\[nrt] 
string: ` \n `, ` \r `, at ` \t ` ay mga whitespace na character, ` \. `, ` \\ ` at ` \[ ` ay hindi .
mga tugma:   ^^ ^^ ^^	

( Halimbawa ) Gumagana ito, ngunit hindi ito isang napaka-eleganteng solusyon. Paano kung mamaya kailangan nating itugma ang escape sequence para sa character na "form feed", \f? (Ang simbolo na ito ay ginagamit upang ipahiwatig ang mga page break sa teksto.)

pattern: \\[nrt] 
string: ` \n `, ` \r `, ` \t `, at ` \f ` ay mga whitespace na character, ` \. `, ` \\ ` at ` \[ ` ay hindi .
mga tugma:   ^^ ^^ ^^	

( Hindi gumaganang solusyon ) Sa diskarteng ito, kailangan nating hiwalay na ilista ang bawat maliliit na titik na gusto nating itugma, sa mga square bracket. Ang isang mas madaling paraan upang gawin ito ay ang paggamit ng mga hanay ng character upang tumugma sa anumang maliliit na titik:

pattern: \\[az] 
string: ` \n `, ` \r `, ` \t `, at ` \f ` ay mga whitespace na character, ` \. `, ` \\ ` at ` \[ ` ay hindi .
mga tugma:   ^^ ^^ ^^ ^^	

( At gumagana na ito ) Gumagana ang mga hanay ng character gaya ng maaari mong asahan, na ibinigay sa halimbawa sa itaas. Maglagay ng mga square bracket sa paligid ng una at huling mga titik na gusto mong itugma, na may gitling sa pagitan. Halimbawa, kung gusto mo lang makahanap ng "mga hanay" ng backslash \at isang titik mula asa m, maaari mong gawin ang sumusunod:

pattern: \\[am] 
string: ` \n `, ` \r `, ` \t `, at ` \f ` ay mga whitespace na character, ` \. `, ` \\ ` at ` \[ ` ay hindi .
mga tugma:                         ^^	

( Halimbawa ) Kung gusto mong tumugma sa maraming hanay, ilagay lang ang mga ito sa pagitan ng mga square bracket:

pattern: \\[a-gq-z] 
string: ` \n `, ` \r `, ` \t `, at ` \f ` ay mga whitespace na character, ` \. `, ` \\ ` at ` \[ ` ay hindi .
mga tugma:         ^^ ^^ ^^	

( Halimbawa ) Kasama sa iba pang karaniwang hanay ng character ang: A-Zat0-9

Subukan natin ang mga ito sa pagsasanay at lutasin ang ilang mga problema:

Ang mga hexadecimal na numero ay maaaring maglaman ng mga digit 0-9at pati na rin ng mga titik A-F. Kapag ginamit upang tukuyin ang mga kulay, ang mga hexadecimal code ay maaaring maglaman ng maximum na tatlong character. Lumikha ng isang regular na expression upang makahanap ng wastong hexadecimal code sa listahan sa ibaba:

pattern:
string: 1H8 4E2 8FF 0P1 T8B 776 42B G12
mga tugma:      ^^^ ^^^ ^^^ ^^^	

( Solusyon ) Gamit ang mga hanay ng character, lumikha ng regular na expression na pipili lamang ng mga maliliit na katinig (hindi patinig, kabilang ang y) sa pangungusap sa ibaba:

pattern:
string: T h e w a lls i n th e m a ll a r e t o t a lly , t o t a lly  t a ll .
mga tugma:   ^ ^ ^^^ ^ ^^ ^ ^^ ^ ^ ^ ^^^ ^ ^ ^^^ ^ ^^	

( Solusyon )

Hakbang 6: "hindi", caret, circumflex, caret... simbolo^

Totoo, mayroong higit sa 9000 mga pangalan para sa simbolo na ito :) Ngunit, para sa pagiging simple, marahil ay magtutuon tayo sa "hindi". Medyo mahaba ang solusyon ko sa huling problema. Kinailangan ng 17 character para sabihing "kunin ang buong alpabeto maliban sa mga patinig." Siyempre may mas madaling paraan para gawin ito. Ang "not" sign ^ay nagbibigay-daan sa amin na tukuyin ang mga character at hanay ng mga character na hindi dapat tumugma sa mga tinukoy sa pattern. Ang isang mas simpleng solusyon sa huling problema sa itaas ay ang paghahanap ng mga character na hindi kumakatawan sa mga patinig:

pattern: [^aeiou] 
string:   Th e w a lls i n th e m a ll a r e t o t a lly, t o t a lly  t all . 
mga tugma: ^^ ^^ ^^^^ ^^^^ ^^ ^^^ ^ ^^ ^ ^^^^^^ ^ ^^^^^ ^^^	

( Halimbawa ) Ang "not" sign ^bilang pinakakaliwang character sa loob ng square bracket []ay nagsasabi sa regular expression engine na tumugma sa isang (anumang) character na wala sa square bracket. Nangangahulugan ito na ang regular na expression sa itaas ay tumutugma din sa lahat ng mga puwang, tuldok ., kuwit ,at malalaking titik Tsa simula ng isang pangungusap. Upang ibukod ang mga ito, maaari rin naming ilagay ang mga ito sa mga square bracket:

pattern: [^aeiou .,T] string  
: T h e w a lls i n th e m a ll a r e t o t o t ally , t o t a lly t a ll . 
mga tugma:   ^ ^ ^^^ ^ ^^ ^ ^^ ^ ^ ^ ^^^ ^ ^ ^^^ ^ ^^	

( Halimbawa ) talana sa kasong ito, hindi natin kailangang takasan ang tuldok na may backslash, tulad ng ginawa natin noon noong hinanap natin ito nang hindi gumagamit ng mga square bracket. Maraming mga espesyal na character sa mga square bracket ang literal na tinatrato, kasama ang open [- ngunit hindi ang closing - ]bracket character (mahuhulaan mo ba kung bakit?). \Hindi rin literal na binibigyang kahulugan ang karakter ng backslash . Kung gusto mong itugma ang isang literal na backslash \gamit ang mga square bracket, dapat mong takasan ito sa pamamagitan ng pag-uuna dito ng sumusunod na backslash \\. Ang gawi na ito ay idinisenyo upang ang mga character na whitespace ay mailagay din sa mga square bracket para sa pagtutugma:

pattern: [\t]
string: tttt
mga tugma:   ^^

( Halimbawa ) Ang "not" sign ^ay maaari ding gamitin sa mga range. Kung gusto kong makuha lang ang mga character a, b, c, x, yat z, magagawa ko ang isang bagay na tulad nito:

pattern: [abcxyz] 
string:   abc defghijklmnopqrstuvw xyz 
matches: ^^^ ^^^

( Halimbawa ) ...o, maaari kong tukuyin na gusto kong maghanap ng anumang karakter na wala sa pagitan dng at w:

pattern: [^dw] 
string:   abc defghijklmnopqrstuvw xyz 
matches: ^^^ ^^^

( Halimbawa ) Gayunpaman,mag-ingat kana may "hindi" ^. Madaling isipin "mabuti, tinukoy ko [^ b-f], kaya dapat akong makakuha ng maliit na titik ao isang bagay pagkatapos ng f. Hindi iyon ang kaso. Tutugma ang regex na ito sa anumang character na wala sa hanay na iyon, kabilang ang mga titik, numero, bantas, at espasyo.

pattern: [^dw] 
string:   abc defg h . i , j - klmnopqrstuvw xyz 
mga tugma: ^^^ ^ ^ ^ ^ ^^^

( Halimbawa )

Pag-level up ng mga gawain:

Gamitin ang sign na "hindi" ^sa mga square bracket upang tumugma sa lahat ng mga salita sa ibaba na hindi nagtatapos sa y:

pattern:
string: day dog ​​​​hog hay bog bay ray rub 
matches:      ^^^ ^^^ ^^^ ^^^	

( Solusyon ) Sumulat ng isang regular na expression gamit ang isang range at isang "not" sign ^upang mahanap ang lahat ng taon sa pagitan ng 1977 at 1982 (kasama):

pattern:
string: 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
mga tugma:            ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^

( Solusyon ) Sumulat ng isang regular na expression upang mahanap ang lahat ng mga character na hindi isang "hindi" sign character ^:

pattern:
string:   abc1 ^ 23*() 
mga tugma: ^^^^ ^^^^^	

( Solusyon )

Hakbang 7: Mga Klase ng Character

Ang mga klase ng character ay mas simple kaysa sa mga hanay ng character. Ang iba't ibang regular na expression engine ay may iba't ibang klase na magagamit, kaya't sasaklawin ko lang ang mga pangunahing dito. (Tingnan kung aling bersyon ng regex ang iyong ginagamit, dahil maaaring marami sa kanila - o maaaring iba ang mga ito sa mga ipinapakita dito.) Ang mga klase ng character ay gumagana halos katulad ng mga hanay, ngunit hindi mo maaaring tukuyin ang mga halaga ng 'simula' at 'pagtatapos': Ang klase ng character na "salita" \way partikular na kapaki-pakinabang dahil ang set ng character na ito ay kadalasang kinakailangan para sa mga wastong identifier (mga pangalan ng variable, pangalan ng function, atbp.) sa iba't ibang mga programming language. Magagamit natin \wpara pasimplehin ang regular na expression na nakita natin kanina:

pattern: \\[az] 
string: ` \n `, ` \r `, ` \t `, at ` \f ` ay mga whitespace na character, ` \. `, ` \\ ` at ` \[ ` ay hindi .
mga tugma:   ^^ ^^ ^^ ^^	

Gamit ang \wmaaari naming isulat tulad nito:

pattern: \\\w 
string: ` \n `, ` \r `, ` \t `, at ` \f ` ay mga whitespace na character, ` \. `, ` \\ ` at ` \[ ` ay hindi .
mga tugma:   ^^ ^^ ^^ ^^	

( Halimbawa )

2 gawain para sa swerte:

Tulad ng alam mo at ko, sa Java, ang isang identifier (pangalan ng variable, klase, function, atbp.) ay maaari lamang magsimula sa titik a- zA- Z, dollar sign $o underscore _. ( Siyempre, ang salungguhit ay masamang istilo, ngunit nilalampasan ito ng compiler, tala ng tagasalin ). Ang natitirang mga character ay dapat na mga character na "salita" \w. Gamit ang isa o higit pang mga klase ng character, lumikha ng isang regular na expression upang maghanap ng mga wastong Java identifier sa mga sumusunod na tatlong-character na pagkakasunud-sunod:

pattern:
string:   __e $12 .x2 foo Bar 3mm
mga tugma: ^^^ ^^^ ^^^ ^^^	

( Solusyon ) Ang US Social Security Numbers (SSN) ay 9-digit na mga numero sa format na XXX-XX-XXXX, kung saan ang bawat X ay maaaring maging anumang digit [0-9]. Gamit ang isa o higit pang mga klase ng character, sumulat ng regular na expression upang mahanap ang mga SSN na na-format nang tama sa listahan sa ibaba:

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

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