Dokument ten to krótkie zapoznanie się z Perlem, zawiera on podstawowe
zagadnienia z tej dziedziny i może być dobrym punktem startowym dla osób
rozpoczynających swoją przygodę z tym językiem. W celu uzyskania lepszej
czytelności tekstu skupiłem się na przedstawieniu większości zagadnień na
przykładach. Informacje tutaj zawarte pochodzą z dokumentacji do języka w
wersji 5.003, początkowo pisząc go wzorowałem się na tutorialu opracowanym
przez
Nika Silvera w
School of Computer Studies (w porozumieniu z autorem).
Wersja z dnia 19.06.97 zawierała sporo usterek. Zostały one już poprawione. Tam gdzie zachodziła taka potrzeba tematy nieco uzupełniłem. Od teraz całość jest dostępna w postaci SGML. Dziękuję wielu osobom za kontakt i przydatne opinie i sugestie.
Dokument ten można rozprowadzać, lecz jedynie w niezmienionej formie (poza konwersją z sgml do innych formatów) i o ile nie pobierane są jakakolwiek opłaty z jego tytułu.
index-2.html 100664 767 767 2554 6444314757 12245 0 ustar cassel cassel
Perl to z założenia praktyczny, interpretowany język, 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. Posiada on wiele
cech języka C, jak również sed, awk i shella. Programujący w owych językach
nie powinni mieć większych probelmów z opanowaniem Perla. Kompilatory tego
języka są dostępne dla wielu systemów operacyjnych, większość skryptów jest
przenośna.
Archiwum CPAN zawiera wiele interesujących materiałów
poświęconych Perlowi (kompilatory, skrypty, biblioteki).
index-3.html 100664 767 767 5002 6444314757 12235 0 ustar cassel cassel
Pierwsza linijka kodu w języku Perl ma specjalne znaczenie i powinna wyglądać następująco (aczkolwiek nie jest ona niezbędna do działania programu):
#!/usr/bin/perl
Oto najprostszy program w Perlu wypisujący na ekranie tekst:
#!/usr/bin/perl
print 'Hello World.'; # ten tekst zostanie wypisany na ekranie
Aby uruchomić taki 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 lini komend:
nazwa_programu # jeśli znajduje się on w katalogu na ścieżce
./nazwaprogramu # jeśli nie znajduje się w katalogu na ścieżce, a
# jest w katalogu bierzącym
perl nazwa_programu # podając go jako parametr dla interpretera (w tym
# przypadku atrybut wykonywalności pliku nie ma
# znaczenia)
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;
$a = 'bleble';
$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"
Szerokie zastosowanie w programowaniu znajdują z pewnością tablice zmiennych (ang. array). Aby stworzyć tablicę i zapisać w niej wartości piszemy:
@imiona = ("kazik", "tomek", "marek");
$imiona[0] # tak przedstawiany jest pierwszy element tablicy
$imiona[1] = 'zyzio'; # tak zapisujemy do drugiego elementu tablicy
push(@imiona, "kasia"); # dodanie kolejnego - czwartego
# elementu do tablicy @imiona
push(@imiona, "kasia", "małgosia") # dodanie dwóch elementów na raz
@damy = ("kasia", "małgosia");
push(@imiona, @damy); # dodanie dwóch tablic do siebie
$a = pop(@imiona); # $a będzie zawierać wartość ostatniego,
# usuniętego elementu tablicy @imiona
$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
$#imiona
print @imiona; # wypisuje elementy tablicy jednym ciągiem
print "@imiona"; # wypisyje elementy oddzielając je spacjami
print @imiona.""; # wypisuje ilość elementów tablicy
W specjalnej tablicy o nazwie @ARGV zapisane są wszystkie parametry podane w linii komend przy starcie programu. Aby wypisać pierwszy parametr napiszemy:
print("$ARGV[0]"); # wypisanie pierwszego parametru
if (@ARGV)
{
print "Program został wywołany z parametrami!\n";
}
Poza przedstawionymi już tablicami istnieją jeszcze tablice asocjacyjne (ang. associative array). Zasadniczą różnicą między 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 wypadku tablic asocjacyjnych każdemu elementowi będzie przyporządkowany łańcuch.
W odróżnieniu od tablic, przed nazwami tablic asocjacyjnych stawiamy znak procenta. Tak można stworzyć tablicę asocjacyjną zawierającą liczby oznaczające wiek danych osób:
%wiek = ("kazik", 17,
"tomek", 20,
"marek", 31);
$wiek{"marek"} # to wyrażenie zwróci wartość 31
Możliwe jest konwertowanie zwykłych tablic na tablice asocjacyjne 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
Program wykonywany w systemie UNIX może odwoływać się do zmiennych środowiskowych, które często zawierają przydatne nam informacje. Spróbuj wydać polecenie "set" w twoim shellu, aby dowiedzieć się o aktualnie ustalonych zmiennych środowiskowych. 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 USER zawiera aktualną
# nazwę użytkownika
Oto najważniejsze operacje jakim możemy poddać zmienne liczbowe (większość z nich pochodzi z języka C):
$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)
++$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ę
A oto przykłady innych operacji, tym razem na łańcuchach:
$a = 'Lin';
$b = 'ux'; # "sklejenie" dwóch łańcuchów, zmienna $c będzie zawierać
$c = $a . $b; # 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
Ustalać wartości zmiennych możemy na wiele sposobów. Dla przykładu przyjmujemy, że każde z poniższych przypisań jest wykonywane z osobna na 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)
Dzięki instrukcji "foreach" możemy przemieszczać się kolejno poprzez elementy tablicy lub kolejnych lini pliku tekstowego i wykonywać na nich operacje. Dla przykładu wykorzystamy tablicę "@imiona":
foreach $imie (@imiona) # Każdy kolejny element tablicy @imiona
# będzie chwilowo dostępny pod zmienną $imie
{
print "KTO : ";
print "$imie\n";
}
Rozważymy teraz kilka wyrażeń testujących. Testy porównują ze sobą zmienne lub wartości i mogą zwracać prawdę (ang. true) lub fałsz (ang. false). W Perlu zasadniczo każda liczba różna od zera i każdy łańcuch, który nie jest pusty jest uznawany za prawdę, a 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 && $b) # Czy $a i $b są prawdą ?
($a || $b) # Czy $a lub $b jest prawdą ?
!($a) # Czy $a to fałsz ?
Testy, przedstawione powyżej znajdują zastosowanie m.in. w instrukcjach warunkowych, których ogólna postać wygląda następująco:
if test1
{
operacja1;
}
elsif test2
{
operacja2;
}
else
{
operacja3;
}
Przykładowo ta instrukcja warunkowa sprawdzi, czy łańcuch "$a" jest pusty, czy też zawiera jeden, dwa, a może więcej znaków i wypisze odpowiedni komunikat:
if (!$a) # Czy łańcuch $a zwraca wartość 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";
}
Za pomocą instrukcji "unless" możemy w trochę inny sposób sprawdzać prawdziwość testów i na podstawie ich wyników wykonywać stosowne operacje.
operacja unless test; # Wykonaj operacje, chyba że test zwraca
unless test operacja; # wartość prawda
die unless ($l); # zakończ działanie programu jeżeli zmienna $l jest
# pusta
Poznamy teraz zasadę budowania podstawowej pętli "for", pochodzącej bezpośrednio z języka C. Ma ona postać:
for (inicjalizacja; test; zmiana_wartości)
{
operacja;
}
for ($a = 0; $a < 10; ++$a)
{
print "$a\n";
}
Inny sposób zapętlania uzyskujemy dzięki konstrukcji while. Ogólnie jej postać przedstawia się następująco:
while test
{
operacje;
}
continue
{
operacje;
}
Oto przykład pętli "while", która pyta użytkownika o wynik działania matematycznego i będzie powtarzać pytanie dopóki nie uzyska poprawnej odpowiedzi:
print 'Ile to jest 2*2, hmm ? ';
$a = <STDIN>; # 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 = <STDIN>;
chop($a);
}
print "Jakoś Ci się udało.\n";
W Perlu, jak w większości innych języków istnieje instrukcja "goto", pomimo tego że można ją w każdym przypadku z powodzeniem zastąpić pętlami i jej nadużywanie nie należy do kunsztu programistycznego. Jej postać jest następująca:
operacje;
label:
operacje;
goto label;
re: # oznanaczenie punktu w programie
print " HEJ ! "; # dalszy ciąg programu
goto re; # przeskok do oznaczonego punktu
Oto przykładowy program obliczający sumę algebraiczną z podanych liczb, wykorzystuje on poznane już instrukcje:
do # tak też można
{
print "Proszę podać liczbę : ";
$liczba = <STDIN>;
$efekt += $liczba;
++$numer;
}
until ($liczba eq "\n");
if ($numer != 0)
{
$sr = $efekt / $numer;
print "Średnia arytmetyczna podanych liczb : $sr\n";
}
print "Proszę podać liczbę : ";
$l = <STDIN>;
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";
Każdy plik przed zapisem lub odczytem należy otworzyć, a po zakończeniu operacji na nim zamknąć. Do otwarcia pliku dyskowego w języku Perl służy funkcja "open", zaś do zamknięcia "close". 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
open(DANE, ścieżka_do_pliku); # otwarcie pliku do odczytu
lub
open(DANE, "<ścieżka_do_pliku");
open(DANE, ">ścieżka_do_pliku"); # otwarcie pliku do zapisu
open(DANE, ">>ścieżka_do_pliku"); # otwarcie pliku do dopisywania
open(DANE, <~/plik.txt>);
open(DANE, '/etc/passwd'); # otwarcie pliku do odczytu
@tekst = <DANE>; # zapisanie tekstu z pliku w tablicy (każda
# linia będzie jednym elementem tablicy
@tekst)
close(DANE); # zamknięcie pliku
open(DANE, '>dane.txt'); # otwarcie do zapisu
print DANE "Tekst zapisywany do pliku.\n"; # zapisanie tekstu do pliku
close(DANE); # zamknięcie pliku
open(DANE, '-'); # otwarcie standardowego wejścia
open(DANE, '>-'); # otwarcie standardowego wyjścia
Operowanie na łańcuchach w Perlu jest jedną z jego mocnych stron. Perl oferuje duże możliwości w tej dziedzinie. Na początek podam sposób sprawdzania, czy dane wyrażenie występuje lub nie występuje w przeszukiwanym łańcuchu:
$s =~ /Ala/ # wyrażenie to zwraca wartość prawda, gdy łańcuch $s zawiera
# szukane słowo zawarte w slashach.
$s !~ /Ala/ # wyrażenie to zwraca wartość prawda, gdy łańcuch $s nie
# zawiera szukanego słowa zawartego w slashach.
Nadażyła się dobra okazja, aby przedstawić zmienną $_, która jest domyślną zmienną dla wielu funkcji - operacje wykonywane są na niej jeśli inna zmienna nie została wyspecyfikowana (skraca to nieco kod i eliminuje zbyt dużą liczbę zmiennych). Ten zapis:
$s = 'Ala ma kota.';
if ($s =~ /Ala/)
{
print 'Odnaleziono wyraz Ala !';
}
$_ = 'Ala ma kota.';
if (/Ala/)
{
print 'Odnaleziono wyraz Ala !';
}
Wyszukując w danym łańcuchu konkretny zapis korzysta się z wielu znaków specjalnych umieszczanych wewnątrz slashów:
. # 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
+ # jeden lub więcej powtórzeń ostatniego znaku
? # brak lub jedno wystąpienie ostatniego znaku
.* # łańcuch składający się z dowolnych znaków oprócz znaków końca lini
^$ # pusta linia
.*x$ # dowolny ciąg znaków, który kończy się literą "x" na końcu lini
(.*)* # dowolna ilość dowolnych łańcuchów
(^$)+ # jedna lub więcej pustych lini
(.*x$)* # dowolna ilość łańcuchów zakończonych literą "x" na końcu lini
[abc] # którykolwiek ze znaków, "a", "b" lub "c"
[^abc] # przeczenie - ani "a", ani "b", ani "c"
[a-z] # jakiekolwiek znaki od "a" do "z"
[^a-z] # jakiekolwiek znaki oprócz znaków "a" do "z"
(.*){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" na końcu lini
\^
\$
\*
\n # znak nowej lini
\t # tabulator
\a # alarm
\l # następny znak ma być "małą" literą
\u # następny znak ma być "dużą" literą
\L # następne znaki, aż do wystąpienia \E mają być "małymi" literami
\U # następne znaki, aż do wystąpienia \E mają być "dużymi" literami
\E # zakańcza modyfikacje "wielkości" liter
\w # pojedyńczy znak alfanumeryczny
\W # jakikolwiek znak nie będący znakiem alfanumerycznym
\s # spacja
\S # jakikolwiek znak nie będący spacją
\d # liczba
\D # jakikolwiek znak nie będący liczbą
$_ = 'linux Operating system';
/([A-Z][a-z]+\s)+/; # wykorzystanie właściwości zmiennej $_
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)
}
Bardzo pomocną funkcją wykorzystującą maski jest s/// wraz z jej opcjami. Służy ona do podmieniania zawartości jednego wyrażenia innym.
s/linux/Linux/ # przeszukiwany jest łańcuch $_, 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 $_, wszystkie
# wystąpienia wyrażenia "linux" zostaną podmienione
# na łańcuch "Linux"
s/linux/Linux/gi # przeszukiwany jest łańcuch $_, wszystkie
# wystąpienia wyrażenia "linux" (niezależnie od
# wielkości liter np. LiNux, linuX itd.) zostaną
# podmienione na łańcuch "Linux"
$_ = 'Linux Operating System';
s/(A-Z)/:\1:/g; # każda wielka litera zostanie zawarta w
# dwukropkach (:L:inux :O:perating :S:ystem)
Do podmieniania znaków innymi znakami służy funkcja tr///. Na przykład:
$_ = 'LinuX';
tr/A-Z/a-z/g; # podmienienie wszystkich dużych liter na
# małe (w efekcie dostajemy słowo "linux")
$_ = 'linux';
tr/x/s/; # podmienienie litery "x" na "s" (w efekcie "linus")
Przydatną funkcją Perla jest split. Pozwala ona na rozbicie łańcucha i umieszczenie poszczególnych jego części w tablicy:
$s = 'kazik:tomek:marek';
@tab = split(/:/, $s);
@tab = ("kazik", "tomek", "marek");
$_ = 'Linux, Operating System';
@tab = split(/.*\s/);
Funkcja substr pozwala na wycinanie części łańcucha. Posługując się nią podajemy offset, w którym rozpoczyna się szukana część łańcucha i ewentualnie jej długość.
$s = substr('Ala ma kota', 2, 6); # łańcuch $s będzie równy "a ma k"
^ ^
$s = substr('Ala ma kota', 6); # łańcuch $s będzie równy "kota"
^
$s = substr('Ala ma kota', -4, 3); # łańcuch $s będzie równy "kot"
^ ^
Jak w prawie każdym języku tak i w Perlu możemy zapisać część kodu w postaci procedur i odwoływać się do niego w późniejszym biegu programu. Procedury zawarte w programie składają się ze słowa kluczowego sub i bloku operacji:
sub moja
{
print "To moja procedura.";
}
while (true) # pętla nieskończona
{
&moja; # wywołanie procedury
}
&moja(12); # wywołanie procedury z jednym parametrem
moja(12, $_); # wywołanie procedury z parametrami
sub moja2
{
print "Procedura została wywołana z następującymi parametrami :\n";
print @_;
}
&moja2("karmazynowy pirat", "Linux"); # procedura odczyta przekazane jej
# zmienne i wyświetli je.
sub moja3
{
if ($_[0] > $_[1])
{
$_[0];
}
else
{
$_[1];
}
}
$większa = &moja3(12, 32); # zmienna $większa będzie równa 32
Kazimierz Pietruszewski Jr
next.gif 100644 767 767 461 6431713040 11507 0 ustar cassel cassel GIF87a$ Ä ˙˙˙éééçççŘŘŘÓÓÓŃŃŃĎĎĎČČČÁÁÁťťťłłłŻŻŻ¨¨¨§§§sssgggWWWVVVOOOBBB666///***&&& , $ ś dihŞÍ˛ž*ÔupMşKˇ vM4ËlcčŐdłĹř2X3Ƣ˛Q0Q¨6b,rÚ$Őä$˘ç@x@Ćp˛â*+lG#ďýb^#3Zc'P#S'@b I t< r Su'ŚPY+Ł)zIW*˝'`3Á%şĘ)PÎÂs ¸Ň,3ą×'KŰ'ßăä! ; perl.jpg 100644 767 767 20774 6431712730 11564 0 ustar cassel cassel ˙Ř˙ŕ JFIF H H ˙í4Photoshop 3.0 8BIMí H H 8BIMó 8BIM'
8BIMő H /ff lff /ff Ą 2 Z 5 - 8BIMř p ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙č ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙č ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙č ˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙č 8BIM ˙î Adobe d ˙Ű
˙Ŕ [ ˙Ģ
s !1AQa"q2ĄąB#ÁRŃá3bđ$rń%C4S˘˛csÂ5D'Łł6TdtĂŇâ&
EF¤´VÓU(ňăóÄÔäôeu
ĽľĹŐĺőfvŚśĆÖćö7GWgw§ˇÇ×ç÷8HXhx¨¸ČŘčř)9IYiyŠšÉŮéů*:JZjzŞşĘÚęú m !1AQa"q2ĄąđÁŃá#BRbrń3$4CS%˘c˛ÂsŇ5âDT
&6E'dtU7ňŁłĂ()Óăó¤´ÄÔäôeu
ĽľĹŐĺőFVfvŚśĆÖćöGWgw§ˇÇ×ç÷8HXhx¨¸ČŘčř9IYiyŠšÉŮéů*:JZjzŞşĘÚęú˙Ý ,˙Ú ? úŁ˙ 9M˙ 9?e˙ 8żä]WĎZ÷5-sI˛k8tűËI! Ű´¤:]˘IÄoŨÁUc~X˙ ˇÓ<ß˙ 8ťŹ˙ ÎDŰÇĄůM4Ë Ą[ÔŁý %ĺŹ"VłiůBÂGzÄ9ütô̢Ş˙ &˙ ĂÓżç-üćýpčÉ k>IÔŁľÖ`2Úz7hň[24˛4
ÄÜÉzq=BŞi˙ ó^óüĺ}ßüâ÷ĺŚ<ÝwŁisOć_8úŢ
ő¤×Qn 8âpźŁë)â>[}םv*ěUŘŤLĘŞYUQVc° u$⎨¨ÜîËPˇź´ťkľşĺěŚ6÷ŤŚ
Žc)