PERL kalbos pirminė paskirtis buvo palengvinti ir išplėsti ataskaitų kūrimo galimybes UNIX operacinėje sistemoje, todėl natūralu, kad ši kalba turi gerai išvystytas tekstų apdorojimo funkcijas. UNIX operacinėje sistemoje tekstinės informacijos apdorojimui paprastai naudojamos tokios komandas kaip sed, awk, grep, cut. Šių komandų paskirtis yra ribota, todėl norint gauti sudėtingą ataskaitą, rašomi pakankamai dideli ir sudėtingi shell script'ai. Taigi čia į pagalbą ateina PERL kalbos reguliarios išraiškos bei šablonai.

Reguliariosios išraiškos – tai taisyklių rinkiniai, aprašantys tekstinį šabloną, pagal kurį randamas reikalingas tekstas ar fragmentas. Papraščiausios reguliariosios išraiškos – tai literalų eilutės. Sudėtingesnėse reguliariose išraiškose naudojami metasimboliai, kurie apibrėžia galimus ieškomo teksto ar fragmento variantus.

Pačias paprasčiausias reguliariasias išraiškas sudaro vienas paprastas simbolis. Paprastas simbolis reguliarioje išraiškoje reiškia pats save ir papildomai neinterpretuojamas.

Metasimboliai – tai spec.simboliai, turintys tam tikrą reikšmę reguliariose išraiškose. Metasimboliai gali būti naudojami vietoj vieno simbolio arba jų grupės.

Simboliai bei metasimboliai, priklausantys reguliariajai išraiškai, atskiriami  / /  ir formuoja eilutės paieškos šabloną. Pavyzdžiui:

/Perl/  -  atitinka visos eilutės, kuriose yra žodis Perl
            /ab*c/ -  atitinka visos eilutės, kuriose yra simboliai abc (b simbolių gali būti bet koks skaičius)

 Jei šabloną atitinka tekstas eilutėje, tuomet grąžinama reikšmė "true" arba "1", priešingu atveju grąžinama reikšmė "false" arba "0".

PERL metasimboliai ir jų prasmė

Toliau panagrinėsime reguliariose išraiškose naudojamus pagrindinius metasimbolius.

Vietą nurodantys metasimboliai

Žemiau išvardinti simboliai nurodo ieškomo teksto vietą eilutėje. Dažniausiai naudojami ^ ir $ metsimboliai reiškiantys atitinkamai eilutės pradžią ir pabaigą.

Pasikartojimo nurodymas reguliariose išraiškose

Žemiau išvardinti simboliai pasako, kad prieš juos buvusi reguliarioji išraiška (t.y. iš kairės) gali pasikartoti eilutėje tam tikrą kiekį kartų.

Kintamieji, susiję su reguliariomis išraiškomis

 Jei eilutėje buvo rastas tekstas, atitinkantis šabloną, tai likusi eilutės dalis, neatitikusi šablono, yra priskiriama specialiems kintamiesiems. Šabloną atitikęs tekstas taip pat priskiriamas specialiajam kintamajam.
 

Pavyzdys

$_ = "tai yra testinis pavyzdys";
/tes.*nis/;     # atitinka žodį "testinis"
                # $`   reikšmė "tai yra "
                # $&   reikšmė "testinis"
                # $'   reikšmė "pavyzdys"

Jei reguliarioje išraiškoje naudojamas grupavimas, tai radus eilutėje tekstą, kuris atitiko šabloną, sukuriami kintamieji $1, $2, $3 ir t.t., kurie turi tas pačias reikšmes kaip ir \1, \2, \3 ir t. t. Pavyzdžiui:

$_ = "this is a test";
/(\w+)\W+(\w+)/; # šį šabloną atitinka pirmi du žodžiai, todėl
                 # $1 dabar yra "this", o $2 turi reikšmę "is"

Išplėstinės reguliariosios išraiškos

Norint išplėsti šablonų panaudojimo galimybes, buvo praplėsta reguliariųjų išraiškų sintaksė įvedant (?.....) konstrukciją. Simbolis, einantis po “?”, apibrėžia funkciją, kuri turi būti atliekama. Šiuo metu naudojama apie dešimt išplėstinių reguliariųjų išraiškų konstrukcijų. Panagrinėkime dažniausiai naudojamas konstrukcijas.

 
(?#text)         tekstas esantis po "#"  ir iki  " )"  laikomas komentaru ir ignoruojamas. Pavyzdžiui
                        /Perl(?# ieškome žodžio Perl)/.

(?:pattern)  grupavimas, kaip ir "(...)" atveju, tačiau nesukuriami kintamieji $1, $2 ir t. t. (žr. aukščiau). Pavyzdžiui /(?:Perl|perl)/.

(?=pattern)  sekantis teksto fragmentas turi atitikti pattern. Tai reiškia, kad prieš šią konstrukciją turi būti šablonas, o tik po jo (?=pattern). Pavyzdžiui, /\w+(?=\t)/ atitinka žodį, po kurio iš kart eina tabuliacija. Be to tabuliacija nepriskiriama $& kintamajam.

(?!pattern) ši konstrukcija reiškia, jog sekantis teksto fragmentas neturi atitikti pattern. Pavyzdžiui, /foot(?!ball)/ atitinka bet kurį žodį ar jo fragmentą “foot”, išskyrus “football”. “ball” nepriskiriamas $& kintamajam.

(?<=pattern) konstrukcija reiškianti, jog prieš buvęs teksto fragmentas turi atitikti pattern. Pavyzdžiui, /(?<=bad)boy/ atitinka žodį “boy”, jei prieš jį buvo “bad”. Be to “bad” nepriskiriamas $& kintamajam.

(?<!=pattern) konstrukcija reiškianti, jog prieš buvęs teksto fragmentas neturi atitikti pattern. Pavyzdžiui, /(?<!=bad)boy/ atitinka bet kurį žodį “boy”, jei prieš jį nebuvo “bad”. “bad” nepriskiriamas $& kintamajam.

(?>pattern)  atitinka eilutę, kurioje pattern yra nurodytoje pozicijoje.

Naudojant išplėstines reguliariasias išraiškas, galima naudoti ir paiešką modifikuojančius raktus t.y. (?imsx-imsx). Jie dar vadinami modifikatoriais. Jei prieš raides i, m, s, x rašomas “-“, tuomet modifikatorius atšaukiamas. Pavyzdžiui /(?ix) perl # ignoruojamos didž.-maž. raidės ir bei galimi tarpai šablone/
Žemiau pateikti modifikatorių paaiškinimai. 
 

Veiksmai naudojant reguliariasias išraiškas

Išsiaiškinę reguliariųjų išraiškų formavimo principus, pereikime prie sekančio etapo, t. y. reguliariųjų išraiškų panaudojimo Perl skriptuose. Taigi reguliariosios išraiškos paprastai naudojamos norint atlikti paieškos operaciją, pakeitimo ar transliteracijos veiksmus. Panagrinėkime kiekvieną iš šių operacijų.

 
PAIEŠKA

 Sintakė

     m/pattern/[g i m o s x]

Paieškos operacija atlieka šabloną atitinkančio teksto paiešką. Operacijos rezultatas gali būti reikšmė 1 (”true”) arba tuščia eilutė (“false”). Pagal nutylėjimą paieška vykdoma eiltutėje,  priskirtoje specialiajam kintamajam $_. Naudojant pririšimo operatorius “=~” ir “!~” galima atlikti paiešką ir kitiems kintamiesiems priskirtose eilutėse. Operatoriai “=~” ir “!~” skiriasi tuo, kad grąžina skirtingas logines reikšmes. Pavyzdžiui:

$var = “Mano batai buvo du”;
$var =~ m/^Man./;                 #vykdome paiešką kintamajam $var priskirtoje eilutėje
                                  #ir gražinama true, nes randamas žodis Mano
$var !~ m/^Man./                  #false, nes randamas žodis Mano

Raktai  g i m o s x  modifikuoja paieškos operacijas. Žemiau pateiktas jų aprašymas.
 

Pavyzdžiai

#Ignoruojamos didžiosios bei mažosios raidės
print "Ar pratesti darbą? ";
if (<STDIN> =~ m/^y]/i) {                # tikrinama ar įvedimas pradedamas y simboliu?
    print "Tai šaunu\n! ";
}

#Globali paieška masyvo ir skaliariniame kontekste
$str="abaabbaaabbb";
@result = $str =~ m/a+b+/g;               #masyvo kontekstas globalioje paieškoje
print "\@result = @result\n";
@result = $str =~ m/(a+)(b+)/g;           #masyvo kontekstas globalioje paieškoje
print "\@result = @result\n";
print "Skaliarinis kontekstas\n";
while ($result=$str =~m/ m/(a+)(b+)/g; {  #skaliarinis kontekstas globalioje paieškoje
    print "result=$result \n";
}

#Paieška naudojant skirtingus raktus
@pattnlist = ("a+", "b+", "c+", "d+");    #masyvas, apibrėžiantis paieškas
foreach $pattn (@pattnlist) {
   $line = <STDIN>;
$line =~ m/$pattn/o                       #dėl rakto o, naudojamas tik a+ šablonas
    print "pattn=$pattn \$& = $&\n";
}

PAKEITIMAS

Sintakė

     s/pattern/replacement/[e g i m o s x]

Pakeitimo operacija s/pattern/replacement/ atlieka šabloną pattern atitinkančio teksto paiešką ir, jei jis randamas, pakeičiamas tekstu replacement. Operacijos grąžinama reikšmė – atliktų pakeitimų skaičius arba tuščia eilutė, jei nebuvo atliktas nei vienas pakeitimas. Pagal nutylėjimą paieška vykdoma eiltutėje, priskirtoje specialiajam kintamajam $_ . Naudojant pririšimo operatorius “=~” ir “!~” galima atlikti paiešką ir kitiems kintamiesiems priskirtose eilutėse, pavyzdžiui:

   $var =~ s/pattern/replacement/[e g i m o s x]

Raktai  g i m o s x  reiškia tą patį kaip ir atliekant paieškos operaciją, o raktas e pasako, kad keičiamąjį tekstą replacement pirmiausiai reikia interpretuoti kaip PERL išraišką, o tik po to atlikti pakeitimus.

Pavyzdžiai

$_= "foot fool buffoon";
s/foo/bar/g;                         #dabar $_  yra "bart barl bufbarn"
 

$_= "this is a test";
s/(w+)/<$1>/g;                       # dabar  $_  yra "<this>  <is>  <a >  <test>"
 

$_= "Hello world";
$new = "Goodbye";
s/hello/$new/;                       # dabar  $_  yra "Goodbye world"
 

$str = "abaabbaaabbb";
$result=$str =~s[(a+b+)]<length($1)>ge;
print "result=$result new str=$str\n";       #result=3 new str=246
 

TRANSLITERACIJA

 Sintakė

     tr/searchlist/replacement/[c d s]

Transliteracijos operacija keičia kiekvieną simbolį iš sąrašo searchlist į atitinkamą simbolį iš pakeitimų sąrašo replacement. Pagal nutylėjimą pakeitimai atliekami eiltutėje, priskirtoje specialiajam kintamajam $_ . Naudojant pririšimo operatorius “=~” ir “!~” galima atlikti paiešką ir kitiems kintamiesiems priskirtose eilutėse, pavyzdžiui:

     $var =~ tr/searchlist/replacement/[c d s]

Simbolių sąrašai searchlist ir replacement gali būti pateikiami kaip atskirai išvardinti simboliai ar simbolių diapazonai. Pavyzdžiui:

    $str =~ tr/A-Z/a-z/      #didžiosios raidės keičiamos mažosiomis.

Žemiau pateiktas raktų, naudojamų transliteracijos operacijose, aprašymas.

Pavyzdžiai

$count = $str =~ tr/\000/ /c      #suskaičiuojamas simbolių skaičius eilutėje.

$str =~ tr/\200-\377/ /cs         #bet kuri simbolių seka nuo ASCII kodo 128 iki 255
                                  #keičiama vieninteliu tarpo simboliu

$_ = "fred and barney";
tr/fb/bf/;                        # $_ dabar "bred and farney"
tr/abcde/ABCDE/;                  # $_ dabar "BrED AnD fArnEy"
tr/a-z/A-Z/;                      # $_ dabar "BRED AND FARNEY"
$count = tr/A-Z//;                # $_ nepakeistas, o $count lygus 13
$count1 = tr/A-Z//c;              # $_ nepakeistas, o $count1 lygus 2 (suskaičiuoti
                                  #    neraidiniai simboliai t.y. tarpai)
tr/A-Z/x/;                        # $_ dabar "xxxx xxx xxxxxx"
tr/a-z/_/c;                       # $_ dabar "xxxx_xxx_xxxxxx" t.y. (non-letters => _)
 

Naudingos eilučių apdorojimo funkcijos

Žemiau pateikiamos dažniausiai naudojamos PERL funkcijos, skirtos darbui su eilutėmis.

Pavyzdžiai

#Pozicijos paieška eilutėje
$person = "barney";
$where = index("fred barney",$person);       # $where lygus 5
$where = index("hello world","l");           # $where lygus 2 (pirmasis l)
$where = index("hello world","l",3);         # $where lygus 3

$w = rindex("hello world","he");             # $w lygus 0
$w = rindex("hello world","l");              # $w lygus 9 (dešiniausias l eilutėje)
$w = rindex("hello world","xx");             # $w lygus -1 (nes nerastas)
 

#Eilutės dalies paėmimas arba pekeitimas
$hello = "hello, world!";
$grab  = substr($hello, 3, 2);               # $grab lygus "lo"
$grab  = substr($hello, 7, 100);             # $grab lygus "world!"
substr($hello, 0, 5) = "hi";                 # $hello dabar "hi world!"

#Vykdoma PERL kodas, nuskaitytas iš STDIN
print "code line: ";
chop($code = <STDIN>);
eval $code; die "eval: $@" if $@;                # PERL kodas vykdomas, jei nėra klaidų

#Eilutės skaidymas ir sujungimas
$line = "merlyn::118:10:Randal:/home/merlyn:/usr/bin/perl";
@fields = split(/:/,$line);                      # skaidoma $line, ties rastais :
#
# dabar @fields yra ("merlyn","","118","10","Randal","/home/merlyn","/usr/bin/perl")
#
$outline = join(":", @fields);    #atstatoma  eilutė $line naujame kintamajame $outline

Į turinį