KURS PROGRAMOWANIA W PERL-u


1. Co to jest Perl?

Perl to z założenia praktyczny, interpretowany język programowania przeznaczony przede wszystkim do wykonywania różnych zadań systemowych m.in. przeszukiwania plików tekstowych, pobierania z nich informacji i generowania komunikatów na ich podstawie. Świetnie nadaje się do pisania skryptów CGI. Jego autorem jest Larry Wall wspomagany oczywiście przez ogromną liczbę innych programistów. Perl jest kompletny, stosunkowo łatwy w użyciu oraz wydajny, przypłacając to może nieco elegancją. Posiada wiele cech języka C, jak również sed, awk i sh. Programujący w w/w językach nie powinni mieć większych problemów z opanowaniem Perla. Kompilatory Perla są bezpłatne i dostępne dla wielu systemów operacyjnych. Większość skryptów jest przenośna. Archiwum CPAN zawiera wiele cennych materiałów dotyczących Perla, takich jak kompilatory, skrypty, biblioteki.

2. Zaczynamy.
2.1 Pierwsza linijka.
Pierwsza linijka kodu w języku Perl ma specjalne znaczenie, aczkolwiek nie jest niezbędna do działania programu. Powinna wyglądać następująco:


#!/usr/bin/perl

Ścieżka /usr/bin/perl zależy od konkretnego systemu i należy ją odpowiednio zmodyfikować, tak aby wskazywała interpreter. Zasadniczo, podobnie jak w zwykłych skryptach pisanych np. w sh, linie rozpoczynające się od znaku "#" są ignorowane przez kompilator i pozwalają na umieszczanie własnych komentarzy wewnątrz programu.

2.2 Pierwszy program.
Oto najprostszy program w Perlu wypisujący na ekranie tekst:


#!/usr/bin/perl

print 'Hello World.';

Należy pamiętać o tym, że każdą operację oddzielamy od następnej za pomocą średnika.

2.3 Uruchamianie programu.
Aby uruchomić nasz program, należy zapisać go w zwykłym pliku tekstowym. Możemy użyć do tego celu jakiegokolwiek edytora. Następnie nadajemy plikowi odpowiedni atrybut wykonywalności poleceniem: chmod u+x nazwa_pliku. Uruchamiamy program, wywołując go z linii komend:


nazwa_programu # jeśli znajduje się on w katalogu na ścieżce
./nazwa_programu # jeśli nie znajduje się w katalogu na ścieżce, ale
# jest w katalogu bieżącym
perl nazwa_programu # podając go jako parametr dla interpretera (w tym
# przypadku atrybut wykonywalności pliku nie musi
# być ustawiony)

Istnieje jeszcze inny, czasem przydatny sposób uruchamiania programów. Opcja interpretera -e może być użyta do wprowadzenia pojedynczej linii skryptu, np. perl -e "print 'Hello World.';". Możliwe jest wielokrotne użycie opcji -e i budowanie w ten sposób skryptu o wielu liniach, np. perl -e "print 'Hello World. ';" -e "print 'Hello once again.'".
Aby sprawdzić poprawność składni jakiegoś programu, ale nie uruchamiać go, należy interpreter wywołać z opcją -c.
Inną pomocną i stosunkowo nową w języku opcją interpretera jest -w. Powoduje ona wypisanie komunikatów dotyczących aktualnie wykonywanego skryptu. Często dzięki niej możemy odnaleźć usterki niezauważone w procesie kompilacji, a mimo to istotne dla działania programu.


3. Zmienne i tablice zmiennych.
3.1 Zmienne.
W Perlu korzystanie ze zmiennych zostało maksymalnie uproszczone. Nie trzeba ich tu w żaden specjalny sposób deklarować. Do wszelkich zmiennych skalarnych odwołujemy się umieszczając przed ich nazwą znak dolara. Przypisanie zmiennej $a wartości liczbowej 123 będzie miało postać:


$a = 123;

Aby przypisać zmiennej odpowiednią wartość łańcuchową, napiszemy pamiętając o apostrofach:


$a = 'xxx';

Wypisywaliśmy już zwykły tekst. Teraz pozostaje tę samą czynność powtórzyć ze zmiennymi. Duże znaczenie mają użyte apostrofy.


$a = 'jeden';
$b = 'dwa';
$c = 'trzy';

print $a.' - '.$b.' - '.$c; # wypisze: jeden - dwa - trzy
print '$a - $b - $c'; # wypisze: $a - $b - $c
print "$a - $b - $c"; # wypisze: jeden - dwa - trzy

Tekst zawarty w pojedynczym apostrofie jest traktowany jak zwykły ciąg znaków. Tekst zawarty w podwójnym apostrofie może zawierać nazwy zmiennych, które zostaną podmienione na ich wartości, jak również specjalne znaki, np. \t (tabulator), \n (nowa linia).
Kompilator rozróżnia wielkie i małe litery ($A to nie to samo co $a).
Nazwy zmiennych dobierane są dowolnie. Mogą nimi być dowolne kobinacje liter i cyfr (poza kilkoma wyjątkami, np. $_) o nieograniczonej długości.

3.2 Tablice zmiennych.
Szerokie zastosowanie w programowaniu znajdują z pewnością tablice zmiennych. Duża wygoda ich użycia w Perlu wynika m.in. z tego, że nie posiadają one określonych rozmiarów, rosną w miarę potrzeb. Aby stworzyć tablicę i zapisać w niej wartości, napiszemy:


@imiona = ("kazik", "tomek", "marek");

Z tak przygotowanej tablicy możemy pobierać poszczególne elementy, a także je zapisywać. Należy pamiętać, że pola tablicy są numerowane począwszy od zera.


$imiona[0] # tak przedstawiany jest pierwszy element tablicy
$imiona[1] = 'zyzio'; # tak zapisujemy do drugiego pola tablicy

Każdy element tablicy to zwykła zmienna skalarna, dlatego w celu odwołania się do niej używamy znaku dolara a nie "małpki".
W ten sposób dodajemy do tablicy nowe elementy:


push(@imiona, "kasia"); # dodanie kolejnego (czwartego)
# elementu do tablicy @imiona
push(@imiona, "kasia", "małgosia") # dodanie dwóch nowych elementów
# na raz
@damy = ("kasia", "małgosia");
push(@imiona, @damy); # dodanie dwóch tablic do siebie

Tak usuwamy ostatni element tablicy i jednocześnie go zwracamy:


$a = pop(@imiona); # $a będzie zawierać wartość ostatniego,
# usuniętego elementu tablicy @imiona

Możliwe jest przyporządkowywanie zmiennym skalarnym tablic. Znowu należy zwrócić uwagę na użycie apostrofów.


$a = @imiona; # zmienna $a będzie zawierać liczbę elementów tablicy
$a = "@imiona"; # zmienna $a będzie łańcuchem składającym się z
# kolejnych elementów tablicy @imiona odzielonych spacjami

Numer ostatniego elementu tablicy otrzymujemy dzięki zastosowaniu zapisu:


$#imiona

Możliwe jest ustalanie spodziewanych wielkości tablic przez przypisywanie odpowiednich wartości powyższej zmiennej. Ma to na celu przyspieszenie działania programu.
Pozostała jeszcze kwestia wypisywania zawartości tablic:


print @imiona; # wypisuje elementy tablicy jednym ciągiem
print "@imiona"; # wypisuje elementy, oddziela je od siebie spacjami
print @imiona.""; # wypisuje ilość elementów tablicy


3.3 Tablica @ARGV.
W specjalnej tablicy o nazwie @ARGV zapisane są wszystkie opcje podane w linii komend przy starcie programu. Aby wypisać pierwszą opcję, napiszemy:


print("$ARGV[0]");

Następujący program zakończy swe działanie odpowiednim komunikatem, jeśli okaże się, iż został wywołany z jakimikolwiek parametrami:


if (@ARGV)
{
print "Program został wywołany z parametrami!\n";
}


3.4 Tablice asocjacyjne.
Poza przedstawionymi już zwykłymi tablicami istnieją jeszcze tablice asocjacyjne. Zasadniczą różnicą między zwykłą tablicą a tablicą asocjacyjną jest sposób odwoływania się do poszczególnych ich elementów: w zwykłej tablicy każdemu elementowi odpowiadała liczba, podczas gdy w tablicach asocjacyjnych każdemu elementowi będzie przyporządkowany łańcuch. W odróżnieniu od zwykłych tablic przed nazwami tablic asocjacyjnych stawiamy znak procenta. Przykładowo stworzymy tablicę asocjacyjną zawierającą liczby oznaczające wiek danych osób:


%wiek = ("kazik", 17,
"tomek", 20,
"marek", 31);

Aby odczytać interesującą nas informacje z wcześniej przygotowanej tablicy asocjacyjnej, napiszemy:


$wiek{"marek"} # to wyrażenie zwróci wartość 31

Ponieważ w polach tablicy asocjacyjnej zapisane są zmienne skalarne, do ich odczytu używamy znaku dolara.
Możliwe jest konwertowanie zwykłych tablic do tablic asocjacyjnych i na odwrót:


@tab = %wiek; # od tej chwili @tab = ("marek", "31", "tomek",
# "20", "kazik", "17");
%nowa = @tab # od tej chwili %nowa jest taką samą tablicą jak
# %wiek


3.5 Tablica asocjacyjna %ENV.
Program wykonywany w systemie UN*X może odwoływać się do zmiennych środowiskowych, które często zawierają przydatne informacje. (Aby dowiedzieć się o aktualnie ustalonych zmiennych środowiskowych, proszę wydać polecenie set). Perl standardowo udostępnia nam cały zestaw tych zmiennych. Są one umieszczone w tablicy asocjacyjnej o nazwie %ENV.


print "Ty jesteś $ENV{'USER'}, witam!"; # zmienna środowiskowa USER zawiera
# aktualną nazwę użytkownika


4. Operatory.
4.1 Operatory liczbowe.
Oto najważniejsze operacje (nb. większość z nich pochodzi z języka C), jakim możemy poddać zmienne liczbowe:


$x = 4 + 2; # dodawanie (w wyniku $x = 6)
$x = 4 - 2; # odejmowanie (w wyniku $x = 2)
$x = 4 * 2; # mnożenie (w wyniku $x = 8)
$x = 4 / 2; # dzielenie (w wyniku $x = 2)
$x = 4 ** 2; # potęgowanie (w wyniku $x = 16)
$x = 4 % 2; # reszta z dzielenia (w wyniku $x = 0)

Następujące operatory służą do automatycznego zwiększania lub zmniejszania wartości zmiennych:


++$a; # zwiększenie $a o jednostkę i zwrócenie wartości
$a++; # zwrócenie wartości $a i zwiększenie jej o jednostkę
--$a; # zmniejszenie $a o jednostkę i zwrócenie wartości
$a--; # zwrócenie wartości $a i zmniejszenie jej o jednostkę

Warto tutaj nadmienić, iż operator inkrementacji może zostać użyty także względem zmiennych łańcuchowych. W takim przypadku cyfry zmniejszają się lub zwiększają, litery zaś zostają odpowiednio przesunięte w alfabecie.

4.2 Operatory łańcuchowe.
A oto przykłady innych, przeznaczonych do działania na łańcuchach operatorów:


$a = 'Lin';
$b = 'ux'; # "sklejenie" dwóch łańcuchów - zmienna $c w efekcie
$c = $a . $b; # zawierać będzie słowo "Linux"

$a = 'masło';
$b = 10; # zmienna $c będzie zawierać łańcuch złożony z dziesięciu
$c = $a x $b; # "sklejonych" łańcuchów $a


4.3 Ustalanie wartości zmiennych.
Ustalać wartości zmiennych możemy na wiele sposobów. Dla przykładu przyjmijmy, że każde z poniższych przypisań jest wykonywane z osobna dla zmiennych $a = 2 i $b = 3:


$a = $b # przypisanie $a do $b (w wyniku $a = 3, $b = 3)
$a += $b # dodanie $b do $a (w wyniku $a = 5, $b = 3)
$a -= $b # odjęcie $b od $a (w wyniku $a = -1, $b = 3)
$a .= $b # dopisanie $b do $a (w wyniku $a = 23, $b = 3)

5. Instrukcje.
5.1 Instrukcja foreach.
Dzięki instrukcji foreach możemy przemieszczać się kolejno poprzez elementy tablicy lub kolejne linie pliku tekstowego i wykonywać na nich operacje. Dla przykładu wykorzystamy wcześniej już używaną tablicę @imiona:


foreach $imie (@imiona) # każdy kolejny element tablicy @imiona
# będzie chwilowo dostępny pod zmienną $imie
{
print "KTO : ";
print "$imie\n";
}

Nawiasy klamrowe, jakie pojawiły się powyżej, są używane do określania bloku programu, czyli zbioru instrukcji i wyrażeń. W tym akuratnie przypadku za każdym podstawieniem pod zmienną $imie nowej wartości wykonywane są dwie czynności. Instrukcja foreach odnosi się do obydwu z nich.

5.2 Testy.
Rozważymy teraz kilka wyrażeń testujących. Testy porównują ze sobą zmienne lub wartości i zwracają prawdę lub fałsz. W Perlu każda liczba różna od zera i każdy łańcuch, który nie jest pusty, jest uznawany za prawdę, zaś liczba 0 lub pusty łańcuch za fałsz. I tak:


$a == $b # prawda jeśli $a jest liczbowo równe $b
$a != $b # prawda jeśli $a jest liczbowo różne od $b
$a eq $b # prawda jeśli łańcuch $a jest taki sam jak $b
$a ne $b # prawda jeśli łańcuchy $a i $b się różnią

A tak używamy logicznych wartości AND, OR, NOT:


($a && $b) # Czy $a i $b są prawdą?
($a || $b) # Czy $a lub $b jest prawdą?
(!$a) # Czy $a to fałsz?


5.3 Instrukcja if.
Przedstawione powyżej testy znajdują zastosowanie m.in. w budowaniu instrukcji warunkowych, których ogólna postać wygląda następująco:

if test1
{
operacje1;
}
elsif test2
{
operacje2;
}
else
{
operacje3;
}
Instrukcje takie działają na następującej zasadzie: Jeśli okaże się, że test1 wykazuje wartość prawda, to zostaje wykonany pierwszy blok programu - operacje1. Jeśli test1 się nie powiedzie, to zostaje przeprowadzony test2 i, jeśli ten się powiedzie, wykonanywane są operacje2. (Jedna instrukcja warunkowa może zawierać wiele członów elsif). Następny, zaczynający się od słowa else człon instrukcji dotyczy przypadku, w którym żaden z wcześniejszych testów się nie powiódł. (W najprostszym razie człony elsif i else nie muszą się w ogóle pojawić).
Przykładowo ta instrukcja warunkowa sprawdzi, czy łańcuch $a jest pusty czy też zawiera jeden, dwa a może więcej znaków, a następnie wypisze odpowiedni komunikat:


if (!$a) # czy łańcuch $a zwraca fałsz?
{
print "Łańcuch jest pusty.\n";
}
elsif (length($a) == 1) # czy łańcuch $a ma jeden znak?
{
print "Łańcuch składa się z jednego znaku.\n";
}
elsif (length($a) == 2) # czy łańcuch $a ma dwa znaki?
{
print "Łańcuch składa się z dwóch znaków.\n";
}
else # gdy ilość znaków > 2
{
print "Łańcuch składa się z wielu znaków.\n";
}


5.4 Instrukcja unless.
Za pomocą instrukcji unless możemy w jeszcze inny sposób sprawdzać prawdziwość testów i na tej podstawie wykonywać stosowne operacje. Możliwe są dwa, równoważne sposoby budowania instrukcji unless:

operacja unless test;

unless test operacja;
Działanie tej instrukcji polega na tym, że operacja jest wykonywana, chyba że test zwraca wartość prawda. Przykładowo:


die unless ($l); # zakończ działanie programu, jeżeli zmienna $l jest pusta


5.5 Pętla for.
Poznamy teraz zasadę budowania podstawowej, pochodzącej bezpośrednio z języka C pętli for. W ogólności pętla ta wygląda następująco:

for (inicjalizacja; test; zmiana_wartości)
{
operacje;
}
Na początku pętli for wykonywana jest inicjalizacja. Następnie przeprowadzany jest test i jeśli zwróci on wartość prawda, zostają wykonane operacje. W ostatnim etapie ma miejsce zmiana_wartości, która najczęściej polega na zwiększeniu o jednostkę zmiennej ustalonej podczas inicjalizacji. (Zmiana_wartości jest wyrażeniem wykonywanym zawsze, w każdym przebiegu pętli). Cała pętla wykonywana jest dopóki test nie zwróci fałszu.
Oto przykład pętli for, która wypisze cyfry od 0 do 9:


for ($a = 0; $a < 10; ++$a)
{
print "$a\n";
}


5.6 Pętla while.
Inny sposób zapętlania uzyskujemy dzięki instrukcji while. Ogólna jej konstrukcja przedstawia się następująco:

while test
{
operacje;
}
continue
{
operacje;
}
Działanie jej polega na ciągłym wykonywaniu bloku operacji, jeśli tylko test zwraca prawdę. Drugi człon (począwszy od słowa continue) nie jest niezbędny, a jego rola jest taka sama jak elementu zmiana_wartości w pętli for - wyrażenie to jest wykonywane w każdym przebiegu pętli.
Oto przykład pętli while, która pyta użytkownika o wynik działania matematycznego i powtarza swoje pytanie, dopóki nie uzyska poprawnej odpowiedzi:


print 'Ile to jest 2*2, hmm? ';
$a = ; # tak czytamy dane ze standardowego wejścia
chop($a); # odcięcie znaku końca linii
while($a ne 4) # powtarzaj, dopóki użytkownik nie poda dobrego wyniku
{
print "Niestety to zły wynik!\nSpróbuj ponownie: ";
$a = ;
chop($a);
}
print "Jakoś Ci się udało.\n";


5.7 Instrukcja goto.
W Perlu, podobnie jak w większości innych języków, istnieje instrukcja goto, pomimo że można ją w każdym przypadku z powodzeniem zastąpić pętlami. (Jej nadużywanie nie należy do kunsztu programistycznego). Postać instrukcji goto jest następująca:

operacje;
znacznik:
operacje;
goto znacznik;
Instrukcja powoduje zatrzymanie programu i przeskok do punktu, w którym został umieszczony znacznik.
Poniższy program po uruchomieniu będzie wypisywał na ekranie dane słowo w nieskończoność:


re: # znacznik
print " HEJ ! "; # dalszy ciąg programu
goto re; # przeskok wstecz do znacznika

W Perlu budowanie instrukcji jest dosyć dowolne. Ten sam efekt bardzo często możemy uzyskać na wiele sposobów, a wybranie jednego z nich zależy wyłącznie od własnych upodobań.

5.8 Przykłady.
Oto przykładowy program obliczający sumę algebraiczną z podanych przez użytkownika liczb. Wykorzystuje on poznane wcześniej instrukcje:


do # tak też można
{
print "Proszę podać liczbę : ";
$liczba = ;
$efekt += $liczba;
++$numer;
}
until ($liczba eq "\n"); # dopóki użytkownik przestanie
# wprowadzać liczby
if ($numer != 0)
{
$sr = $efekt / $numer;
print "Średnia arytmetyczna podanych liczb : $sr\n";
}

Ten przykładowy program natomiast służy do odnajdywania liczb pierwszych według dość prymitywnego algorytmu:


print "Proszę podać liczbę : ";
$l = ;
chop($l);
for($i = 2; $i < $l; $i++)
{
if (($l % $i) == 0)
{
print "Liczba $l nie jest pierwsza!\n";
exit;
}
}
print "Liczba $l jest pierwsza!\n";

6. Obsługa plików tekstowych.
Każdy plik przed zapisem lub odczytem należy otworzyć, a po zakończeniu operacji na nim - zamknąć. Do otwarcia jakiegokolwiek pliku w języku Perl służy rozbudowana funkcja open, zaś do zamknięcia - close. Nie ma żadnych limitów ilości otwieranych plików w Perlu poza zewnętrznymi, systemowymi. Schemat obsługi pliku jest prosty:

open(DANE, ścieżka_do_pliku); # otwarcie pliku (DANE to przykładowa nazwa)
[ ... ] # operacje na nim
close(DANE); # zamknięcie pliku
Plik jednakże może zostać otwarty na kilka sposobów:


open(DANE, ścieżka_do_pliku); # dwa sposoby otwarcia
open(DANE, "<ścieżka_do_pliku"); # pliku do odczytu

open(DANE, ">ścieżka_do_pliku"); # otwarcie pliku do zapisu
open(DANE, ">>ścieżka_do_pliku"); # otwarcie pliku do dopisywania

Często przydatną rolę w lokalizacji plików na dysku pełnią rozszerzenia sh. Można z nich skorzystać, kiedy ujmiemy ścieżkę do pliku w odpowiednie nawiasy. Na przykład chcąc otworzyć plik znajdujący się w katalogu domowym użytkownika, napiszemy:


open(DANE, <~/plik.txt>);

Najprostszym przypadkiem wyprowadzania danych z pliku będzie wczytanie do tablicy całej zawartości pliku tekstowego:


open(F, '/etc/passwd'); # otwarcie pliku do odczytu
@tekst = ; # zapisanie tekstu z pliku w tablicy (każda linia
# zostaje umieszczona z osobna, w jednym polu tablicy)
close(F); # zamknięcie pliku

A tak zapisujemy dane do pliku:


open(DANE, '>dane.txt'); # otwarcie pliku do zapisu
print DANE "Tekst zapisywany do pliku.\n"; # zapisanie tekstu do pliku
close(DANE); # zamknięcie pliku

Za pomocą funkcji open możemy także otwierać i zamykać standardowe wejście (najczęściej klawiatura) i wyjście (najczęściej ekran).


open(DANE, '-'); # otwarcie standardowego wejścia
open(DANE, '>-'); # otwarcie standardowego wyjścia

Funkcja open może także zostać użyta do otwierania strumieni w środowiskach wieloprocesowych. W poniższym przykładzie posortujemy kilka łańcuchów przy użyciu zewnętrznej komendy sort:


open(SORT, "|sort"); # otwarcie strumienia
print SORT ("d\n", "z\n", "a\n");
close SORT;

7. Manipulacje łańcuchami.
Obsługa łańcuchów jest jedną z mocnych stron Perla. Oferuje on duże możliwości w tej dziedzinie. Na początek podam sposób sprawdzania, czy dane wyrażenie występuje czy też nie występuje w przeszukiwanym łańcuchu:


$s =~ /Ala/ # wyrażenie to zwróci wartość prawda, jeżeli okaże się, że
# łańcuch $s zawiera szukane słowo zawarte w pochyłym nawiasie
$s !~ /Ala/ # wyrażenie to zwróci wartość prawda, jeżeli okaże się, że
# łańcuch $s nie zawiera szukanego słowa zawartego w pochyłym
# nawiasie


7.1 Zmienna $_.
Nadażyła się dobra okazja, aby przedstawić zmienną $_, która jest domyślną zmienną i na której operuje wiele funkcji wtedy, gdy inna zmienna nie została do konkretnego celu wyszczególniona. Takie rozwiązanie skraca nieco kod oraz eliminuje zbyt dużą liczbę zmiennych i mogące z tego wyniknąć zamieszanie.


$s = 'Ala ma kota.';
if ($s =~ /Ala/)
{
print 'Odnaleziono wyraz Ala!';
}

Powyższy zapis jest równoważny następującemu:


$_ = 'Ala ma kota.';
if (/Ala/)
{
print 'Odnaleziono wyraz Ala!';
}


7.2 Maski.
Kiedy poszukujemy w danym łańcuchu konkretnego zapisu, korzystamy często z wielu znaków o specjalnym znaczeniu, umieszczanych wewnątrz pochyłego nawiasu. Te znaki to:


. # jakikolwiek znak oprócz znaku nowej linii (\n)
^ # rozpoczęcie nowej linii lub łańcucha
$ # koniec linii lub łańcucha

* # dowolna ilość powtórzeń ostatniego znaku
+ # jedno lub więcej powtórzeń ostatniego znaku
? # brak lub jedno wystąpienie ostatniego znaku

Za pomocą powyższych znaków specjalnych można budować maski i porównywać je ze zmiennymi. Oto kilka przykładowych masek:


.* # łańcuch składający się z dowolnych znaków oprócz znaków końca linii
^$ # pusta linia
.*x$ # dowolny ciąg znaków, który kończy się literą "x"

Zwykłych nawiasów możemy używać do grupowania znaków:


(.*)* # dowolna ilość dowolnych łańcuchów
(^$)+ # jedna lub więcej pustych linii
(.*x$)* # dowolna ilość łańcuchów zakończonych literą "x"

Jeśli chcemy odnaleźć którykolwiek znak spośród kilku, należy je umieścić w nawiasach kwadratowych. I tak:


[abc] # którykolwiek ze znaków: a, b lub c
[^abc] # negacja: ani a ani b ani c
[a-z] # jakiekolwiek znaki od a do z
[^a-z] # jakiekolwiek znaki oprócz znaków od a do z

Nawiasy klamrowe służą do określania ilości powtórzeń wystąpienia łańcucha:


(.*){3} # trzy dowolne łańcuchy
(^$){3,} # przynajmniej trzy dowolne łańcuchy
(.*x$){3,5} # przynajmniej trzy, ale nie więcej niż pięć łańcuchów
# zakończonych literą "x"

Aby w masce zawrzeć znaki, które mają pierwotnie swoje znaczenie w języku (np. $) należy je poprzedzić znakiem "\". Na przykład:


\^
\$
\*

Ponadto w masce niektóre litery poprzedzone znakiem "\" nabierają specjalnego znaczenia:


\n # znak nowej linii
\t # tabulator
\a # alarm

\l # następny znak ma być małą literą
\u # następny znak ma być dużą literą
\L # następne znaki mają być małymi literami, aż do wystąpienia \E
\U # następne znaki mają być dużymi literami, aż do wystąpienia \E

\w # pojedynczy znak alfanumeryczny
\W # jakikolwiek znak nie będący znakiem alfanumerycznym
\s # spacja
\S # jakikolwiek znak, który nie jest spacją
\d # liczba
\D # jakikolwiek znak, który nie jest liczbą

Na przykładzie pokażę sposób "wyłuskiwania" pewnych części łańcuchów za pomocą porównywania ich z maskami:


$_ = 'linux Operating system';
/([A-Z][a-z]+\s)+/; # wykorzystanie właściwości zmiennej $_

Po wykonaniu takiej czynności do naszej dyspozycji zostaje oddany szereg pseudo-zmiennych, których wartości można jedynie czytać, ale nie zapisywać. Jak widać maska, której użyliśmy, opisuje słowo "Operating". Z tego względu w zmiennej $& odnajdziemy to słowo. Pod zmienną $` natomiast zapisane zostanie słowo "linux", a pod $' słowo "system". Dzięki temu mechanizmowi jesteśmy w stanie "wyłuskać" potrzebną nam część łańcucha.
Przy przeszukiwaniu łańcuchów wszystkie odnalezione wyrażenia zawarte w zwykłych nawiasach są zapamiętywane w pseudo-zmiennych $1, $2, $3, itd. Można je także wykorzystać w ramach aktualnie wykonywanej funkcji odwołując się do nich poprzez \1, \2, \3, itd.


$_ = 'Linux Operating System';
if (/(.*ux)/)
{
print "$1\n"; # znaleziony łańcuch "Linux"
}


7.3 Funkcja s///.
Bardzo pomocną funkcją wykorzystującą maski jest s///. Służy ona do podmieniania zawartości jednego wyrażenia innym.


s/linux/Linux/ # przeszukiwany jest łańcuch $_, a gdy okaże się, że
# zawiera on wyrażenie "linux", zostanie ono
# podmienione na łańcuch "Linux"
s/linux/Linux/g # przeszukiwany jest łańcuch $_ i wszystkie
# wystąpienia wyrażenia "linux" zostaną podmienione
# na łańcuch "Linux"
s/linux/Linux/gi # przeszukiwany jest łańcuch $_ i wszystkie
# wystąpienia wyrażenia "linux" (niezależnie od
# wielkości poszczególnych liter) zostaną
# podmienione na łańcuch "Linux"

Przykład zastosowania funkcji s///:


$_ = 'Linux Operating System';
s/([A-Z])/:\1:/g; # każda pojawiająca się wielka litera
# zostanie zawarta w dwukropkach


7.4 Funkcja tr///.
Do podmieniania znaków innymi znakami służy funkcja tr///. Na przykład:


$_ = 'LinuX';
tr/A-Z/a-z/; # podmienienie wszystkich dużych liter na małe

$_ = 'linux';
tr/x/s/; # podmienienie litery "x" na "s"


7.5 Funkcja split().
Przydatną funkcją w Perlu jest split. Pozwala ona na rozbicie łańcucha i umieszczenie poszczególnych jego części w tablicy:


$s = 'kazik:tomek:marek';
@tab = split(/:/, $s);

Po wykonaniu takiej operacji otrzymamy poszczególne części łańcucha, które w $s były odgraniczane znakiem dwukropka, zapisane w kolejnych polach tablicy. Efekt działania funkcji split będzie wyglądał tak:


@tab = ("kazik", "tomek", "marek");

Oczywiście w miejsce pojedynczego znaku dwukropka możemy wprowadzić dowolne maski, które będą opisywać wyrażenia oddzielające od siebie szukane łańcuchy.
Funkcja split może także być stosowana w krótszej postaci (operować na zmiennej $_):


$_ = 'Linux, Operating System';
@tab = split(/.*\s/);

W efekcie otrzymamy tablicę @tab składającą się z trzech wyrazów ("Linux", "Operating", "System") zapamiętanych w kolejnych jej polach.

7.6 Funkcja substr().
Funkcja substr pozwala na "wycinanie" części łańcucha. Posługując się nią podajemy miejsce, w którym rozpoczyna się szukany wycinek łańcucha i ewentualnie długość tego wycinka.


$s = substr('Ala ma kota', 2, 6); # łańcuch $s będzie zawierał "a ma k"
^ ^
$s = substr('Ala ma kota', 6); # łańcuch $s będzie zawierał "kota"
^
$s = substr('Ala ma kota', -4, 3); # łańcuch $s będzie zawierał "kot"
^ ^

8. Procedury.
Jak w prawie każdym języku tak i w Perlu możemy zapisać część kodu w postaci procedur i odwoływać się do nich w późniejszym biegu programu. Procedury systematyzują i skracają kod programu. W Perlu składają się one ze słowa kluczowego sub i następującego po nim bloku operacji. Przykładowo:


sub moja
{
print "To moja procedura.";
}

Tak zapisaną procedurę możemy wywoływać w dalszej części programu:


while (true) # pętla nieskończona
{
&moja; # wywołanie procedury
}

Do procedury możemy przekazywać zmienne pochodzące z innych części programu, wywołując ją w następujący sposób:


&moja(12); # wywołanie procedury z jednym parametrem
&moja(12, $_); # wywołanie procedury z dwoma parametrami

Prosta procedura, jaką stworzyliśmy, nie reaguje w żaden sposób na przekazywane jej zmienne.
We wnętrzu procedury do przekazanych jej zmiennych możemy dostać się poprzez tablicę o nazwie @_:


sub moja2
{
print "Procedura została wywołana z następującymi parametrami :\n";
print @_;
}

Stworzone przez nas procedury same także zwracają wartości.


sub moja3
{
if ($_[0] > $_[1])
{
$_[0];
}
else
{
$_[1];
}
}

Procedura moja3 wywołana z dwoma zmiennymi sprawdza, która z nich jest większa i zwraca jej wartość. A oto jej konkretne zastosowanie:


$wieksza = &moja3(12, 32); # zostanie odnaleźona większa z dwóch
# liczb i umieszczona w zmiennej $wieksza


"Artykuł ściągnięty ze strony Kazimierza Pietruszewskiego:
http://pipeta.chemia.pk.edu.pl/Perl/"