Tutorial: http://www.codebits.com/p5be/

1 Podstawy

1.1 Uruchamianie

* perl nazwa_programu

* jako skrypt zaczynający się od #!/usr/bin/perl

Zwyczajowo programom nadaje się rozszerzenie .pl

1.2 Najprostszy program

print(``Napis1\n'');

print(``Napis2\n''); #komentarz do końca linii

Każda instrukcja kończy się średnikiem.

Nie ma wydzielonego bloku głównego programu.

1.3 Literały

1.3.1 Liczby

* całkowite dziesiętne: 99

* całkowite ósemkowe: 013

* całkowite szesnastkowe: 0xFF

* zmiennoprzecinkowe dziesiętne: 0.7

* zmiennoprzecinkowe w notacji wykładniczej: 10.23E+4

1.3.2 Stringi

Otoczone apostrofami:

print('Napis');

Apostrof w napisie umieszcza się za pomocą \'

print('can\'t');

Nie są interpretowane kody \n, itp. natomiast string może mieć wiele
linii:

print('Ala

ma

kota');

Otoczone cudzysłowami:

Kody \n, itp. są interpretowane, cudzysłow uzyskuje się za pomocą \''

print(``\Unapis\E\''''); - zmienia na wielkie litery i ``

$ i @ uzyskuje się za pomocą \$ i \@

Łączenie stringów:

Operator '.'

print(``a'' . ``b'');

2 Zmienne

2.1 Zmienne skalarne

Przechowują jedną rzecz: string, liczbę lub referencję.

Nie muszą być deklarowane.

Odwołania poprzez $nazwa_zmiennej

Nazwy zmiennych są wrażliwe na wielkość liter.

$s = ``Napis'';

print($s);

Nazwy zmiennych są interpretowane w stringach otoczonych cudzysłowami:

print(``$s\n'');

Jeśli bezpośrednio po nazwie zmiennej ma być litera lub cyfra, to trzeba
nazwę zmiennej otoczyć {}

print(``${s}y\n'')

Zmienne skalarne nie mają typu:

$s = 2;

print($s);

$s = ``Napis'';

print($s);

Konwersja między liczbami a stringami odbywa się automatycznie:

$s = 2/3;

print(``$s\n'');

print(``2''+''3'');

2.2 Tablice

Zmienne tablicowe zawierają tablice (o zmiennej długości) indeksowane
liczbami od 0.

Odwołania przez @nazwa_zmiennej. Nazwa zmiennej tablicowej może być
taka sama jak zmiennej skalarnej.

Tablice mogą zawierać dowolne wartości skalarne przemieszane ze sobą.

@a = (1,"a","b\n", "c");

print (@a);

Pusta tablica jest oznaczana jako ()

@a = ();

print(@a);

print(``\n'');

Operator łączenia stringów '.' jest operatorem skalarnym, więc przekształca
tablicę na wartość skalarną zawierającą liczbę elementów tablicy:

@a = ("a", "b");

print (@a1 . " - liczba elementow\n");

Tablice można tworzyć za pomocą zakresów:

@a = (1..15);

@b = (``a'' .. ``z'');

print(@a);

W stringu otoczonym cudzysłowami można odwoływać się do zmiennych tablicowych,
elementy są wtedy wypisywane ze spacjami:

print(``@a\n'');

Umieszczenie tablicy w tablicy powoduje dołączenie zawartości w tym
miejscu tablicy.

@a1 = (1..3);

@a2 = (5..7);

@a3 = (@a1, " i ", @a2);

print(@a3);

print("Liczba elementów: " . @a3);

Dostęp do elementu tablicy odbywa się za pomocą nawiasów kwadratowych.
Uwaga! Otrzymujemy skalar, więc odwołujemy się za pomocą $

Indeksy są od 0

@a = (1..10);

print($a[2]); #wypisuje 3

$i = 1;

print($a[$i]);

Ujemne indeksy pozwalają na dostęp od końca tablicy:

print($a[-1]); #10

Liczbę elementów można uzyskać traktując ją jako skalar, tzn. przypisując
na skalar lub używając w miejscu w którym oczekiwany jest skalar.

print(2 * @a); # 20

Wycinanie kawałka tablicy odbywa się za pomocą nawiasów kwadratowych
zastosowanych do @nazwa_tablicy

print (@a[2,5]); #36 - wycięcie dwóch elementów

@b = @a[0..3]; # wycięcie zakresu

Można przypisywać na tymczasową tablicę:

($s1, $s2) = @a[4,5];

print($s1);

print($s2);

2.3 Tablice asocjacyjne

Tablice, w których indeksem może być dowolny skalar. Odwołania poprzez
%nazwa_tablicy.

Tworzy się jak listę zawierającą naprzemian klucze i wartości

%t = (1, "Napis", "a", 17.7);

Dostęp do elementu poprzez nawiasy klamrowe

print($t{``a''});

print ($t{1});

Przypisanie na określony element

$t{"a"} = "abc";

print ($t{"a"});

Nie można wypisywać zawartości tablicy asocjacyjnej w stringu otoczonym
cudzysłowami, a print na takiej zmiennej wypisuje tak jak zawartość
tablicy bez zachowania kolejności wstawiania.

3 Operatory

3.1 Arytmetyczne

+, -, *, / 

** - do potęgi

% - modulo

3.2 In/dekrementacja

++$i, --$i

$i++, $i--

3.3 Logiczne

&&, || , !

3.4 Bitowe

3.5 Porównywania liczb

!=, ==

<=, etc.

x<=>y - zwraca -1 gdy x<y, 0 gdy x==y , 1 gdy x>y

3.6 Porównywanie stringów

eq - równe

ne - nierówne

lt, gt, le, ge

cmp - <=>

Porządek leksykograficzny w ASCII

3.7 Operator ?:

warunek?wartość1:wartość2

3.8 Operatory stringów

. - łączenie

string x liczba - powtórzenie liczba razy

3.9 Operatory przypisań

*=, +=, itp.

.= - łączenie stringu

4 Funkcje

sub nazwa {

..Ciało..

}

Parametry są przekazywane w specjalnej tablicy @_

sub wypisz_3 {

print $_[0] x 3;

}

Zwracanie wartości odbywa się za pomocą return lub zwracana jest ostatnia
wartość wyliczona w funkcji

Można zwracać tablice

sub zwroc_3_4

{

        return ($_[0] x 3, $_[1] x 4);

}

print zwroc_3_4("B", "C");

Do funkcji można przekazać dowolną liczbę parametrów jako tablicę:

sub policz_parametry {

        print @_ . ``\n'';

}

policz_parametry(``a''..''z'');

Nawiasy dookoła parametru funkcji są niepotrzebne:

policz_parametry ``a''..''z'';

policz_parametry ``a'', ``b'';

Czasami jest konieczne poprzedzenie nazwy funkcji przy wywołaniu znakiem
& żeby uniknąć niejednoznaczności:

&policz_parametry ``a'';

Parametry przekazane do funkcji są przekazywane przez referencję, więc
jeśli się je zmienia, to należy stworzyć kopie w funkcji.

sub inc

{

        $_[0]++;

}

sub inc2

{

       $x = $_[0];

       ++$x;

}

$i = 7;

inc($i); 

print $i; # 8

print inc2($i);

print($i);

Próba modyfikacji zmiennej przekazanej przez wartość spowoduje błąd
wykonania

inc (7);

Natomiast w drugim przypadku wszystko będzie w porządku

inc2(7);

Zmienne w procedurze jeśli nie są zadeklarowane lokalnie dla procedury,
odwołują się do zmiennych globalnych

sub inci {

        $i++

}

$i = 7;

inci;

print $i; #8

Można zadeklarować zmienne jako lokalne dla tej funkcji za pomocą funkcji
my()

sub incmy {

        my($i) = $_[0];

        ++$i;

}

$i = 7;

print incmy($i); #8

print $i; #7

Można ograniczyć zasięg widoczności zmiennej do danej funkcji i wszystkich,
które ona woła za pomocą funkcji local().

Przekazywanie jednocześnie tablicy i skalarów do funkcji wymaga podania
najpierw skalarów, a potem tablicy, bo przypisanie na tablicę przypisuje
wszystkie wartości. Dlatego też można przekazać tylko jedną tablicę

sub p

{

       my($skalar, @tablica) = @_;

       ...;

}

p(7, (1..10));

5 Predefiniowane funkcje

5.1 Funkcje dla stringów

chop(string) - odcina ostatni znak

chop(tablica) - odcina ostatni znak we wszystkich elementach tablicy

index(string, substring, pozycja) - znajduje pozycję substringu w stringu
począwszy od (jeśli podane) pozycji pozycja

length(string) - długość stringu

split(pattern, string, limit) - dzieli string na części używając wzorca
pattern i zwracając co najwyżej limit części. W kontekście tablicowym
zwraca listę części, w skalarnym liczbę części.

@s = split(",", "1,2,34");

print "@s\n"; #1 2 34

substr(string, offset, długość) - zwraca część stringu, ujemny offset
oznacza indeks od końca, jeśli nie podamy długości to do końca stringu

substr może być używane po lewej stronie przypisania

$s = "123456789";

substr($s, 4, 1) = "abc";

print $s; #1234abc6789

5.2 Funkcje dla tablic

keys(tablica_asocjacyjna) - zwraca tablicę zawierającą klucze

values(tablica_asocjacyjna) - tablica wartości

delete(klucz) - usuwa klucz wraz z wartością z tablicy

exists(klucz) - sprawdza, czy istnieje dany klucz

map(wyrażenie, tablica)

join(string, tablica) - łączy wszystkie elementy tablicy stringiem

print join(",", (1..5)); #1,2,3,4,5

pop(tablica) - usuwa i zwraca ostatni element tablicy

@a = (1..10);

print pop(@a), "\n"; # 10

print "@a\n"; # 1 2 3 4 5 6 7 8 9

push(tablica, elementy) - dołącza zawartość tablicy elementy do tablicy
na końcu

@a = (1..3);

push(@a, ("a", "b"));

print "@a\n"; # 1 2 3 a b

shift(tablica) - zwraca i usuwa pierwszy element tablicy

unshift(tablica, elementy) - dołącza zawartość tablicy elementy do
tablicy na początku

each(tablica_asocjacyjna) - zwraca kolejny element tablicy asocjacyjnej

$a{"a"} = 7;

$a{"b"} = 100;

while (($k, $v) = each(%a)) {

        print "$k - $v\n";

}

6 Sterowanie

6.1 Wyrażenia

Każda instrukcja i każdy literał jest wyrażeniem.

6.2 Bloki

Blok to ciąg instrukcji wydzielony nawiasami klamrowymi. 

W bloku można deklarować lokalne zmienne. Blok jest wyrażeniem, którego
wartość to ostatnia wartość wyliczona w bloku.

6.3 Instrukcje warunkowe

if (warunek) {

} elsif (warunek2) {

} else {

}

Wyrażenie zmodyfikowane:

wyrażenie if (warunek);

odpowiada

if (warunek) {

       wyrażenie;

}

wyrażenie unless (warunek);

Odpowiada:

wyrażenie if (!warunek);

print 3/$z unless ($z == 0);

6.4 Pętle

do {

       wyrażenia;

} while (warunek);

while (warunek) {

       wyrażenia;

}

wyrażenie while (warunek);

do {

       wyrażenia;

} until (warunek);

until warunek {

       wyrażenia;

}

wyrażenie until (warunek);

print (3/$z++, "\n") until ($z == 10);

for (inicjalizator; warunek; krok) {

       wyrażenia;

}

foreach zmienna (tablica) {

}

Przechodzi po wszystkich elementach tablicy przypisując kolejną wartość
na zmienną (lub $_ jeśli nie podamy)

@a = (1..10);

foreach (@a) {

        print ($_ , "\n");

};

6.5 Sterowanie pętlami

last - wyskoczenie z bloku

next - kolejny obieg pętli

redo - powtarza wykonanie bloku

Pętle można oznaczyć etykietami i użyć tych operacji do określonej
pętli:

OUTER: for ($i=1; $i<=3; $i++) {

        for ($j=1; $j<=3; $j++) {

                print $i, "," ,$j, "\n";

                if ($j == 2 && $i == 2) {

                        last OUTER;

                }

        }

}

7 Pliki

7.1 Uchwyty plików

Uchwyty plików zwyczajowo pisane dużymi literami.

STDIN

STDOUT

STDERR

7.2 Otwieranie i zamykanie plików

open(uchwyt, nazwa)

nazwa:

'nazwa_pliku' lub '< nazwa_pliku' - otwarcie do odczytu

'> nazwa_pliku' - otwarcie do zapisu

'>> nazwa_pliku' - otwarcie do dopisywania

'+> nazwa_pliku' - otwarcie do zapisu i odczytu

'| program' - przesyła wysyłane do tego pliku do programu

'program |' - czyta dane ze standardowego wyjścia programu

close (uchwyt) - zamyka plik

7.3 Operator <> - czytanie z pliku

Operator <uchwyt> odczytuje kolejną linię z pliku i ją zwraca. Jeśli
nie poda się uchwytu przyjmowany jest STDIN. 

$a = <>;

print $a;

Domyślnie operator <> przypisuje na zmienną $_

while (<>) {

       print; #używa domyślnej zmiennej $_

}

Na końcu wczytanego stringa jest znak końca linii, można go obciąć
za pomocą chop

Można wczytać od razu cały plik do tablicy

@a = <STDIN>;

7.4 print - pisanie do pliku

print uchwyt string 

print STDERR ``Error'';

7.5 Testowanie typu pliku

Do testowania służą operatory biorące jako argument nazwę pliku lub
uchwyt. Jeśli nie poda się pliku, przyjmowana jest wartość $_

-f plik - czy to plik zwykły

-e plik - plik istnieje

-r plik - czy plik można odczytać

foreach (@ARGV) {

        print ((-f)? "$_\n" : uc("$_\n"));         

} # wypisuje dużymi literami nazwy plików nie będących zwykłymi plikami 

7.6 Funkcje plikowe

(dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size, $atime, $mtime,
$ctime, $blksize, $blocks) = stat(nazwa_pliku);

8 Wyrażenia regularne

8.1 Dopasowywanie do wzorca

m/wzorzec/ lub /wzorzec/

Zwraca prawdę lub fałsz. Wyszukuje w $_

foreach (@ARGV) {

        print if /.*\.pl$/

} # wypisuje wszystkie argumenty kończące się na .pl

Można do dopasowania dodać opcje po drugim /

g - zwracane są wszystkie pasujące części

$_ = "aabaaaabaabaabbba";

@a = /a+/g;

foreach (@a) {

        print $_ , "\n";

} 

i - nie zwraca uwagi na wielkość liter

8.2 Zastępowanie

Operator s/wzorzec/wzór/

Zastępuje pierwsze wystąpienie wzorca podanym wzorem. Opcja g powoduje
zastąpienie wszystkich wystąpień

$_ = "aabaaaabaabaabbba";

s/a+/X/g;

print; #XbXbXbXbbbX

We wzorze zastępowania można używać symboli \1 .. \9, które zawierają
to co zostało dopasowane do wzorca otoczonego nawiasami

$_ = "aabaaaabaabaabbba";

s/(a+)/\(\1\)/g;

print; #(aa)b(aaaa)b(aa)b(aa)bbb(a)

8.3 Operacje dla innych stringów niż $_

Można używać operacji wzorcowych dla innych stringów za pomocą operatora
=~

string =~ operator_wzorcowy

@a = ``aaaba'' =~ /a+/g;

print ``@a\n'';

Jeśli operator wzorcowy jest używany jako warunek logiczny, to można
użyć operatora !~ będącego zaprzeczeniem =~

9 Wykonywanie programów zewnętrznych

`program` 

10 Moduły

Moduły to zbiory funkcji, zmiennych i obiektów posiadające własną przestrzeń
nazw.

Pliki z modułami mają standardowo rozszerzenie .pm

Moduły ładuje się poleceniem use nazwa_modułu. Od tego momentu funkcje
i zmienne wyeksportowane z modułu są widoczne w programie.

use Text::Abbrev;

%h = abbrev ("a", "ab", "cba"); 

while (($k, $v) = each(%h)) {

        print "$k - $v\n";

} # wypisuje wszystkie jednoznaczne skróty dla podanych nazw

11 CGI

Do obsługi CGI służy moduł CGI

#!/usr/local/bin/perl

   use CGI;                             # load CGI routines

   $q = new CGI;                        # create new CGI object

   print 

        q->header,

         $q->start_html('hello world'), # start the HTML

         $q->h1('hello world'),         # level 1 header

         $q->end_html;                  # end the HTML

Dostęp do parametru nazwanego (lub zbioru wartości parametru) za pomocą
funkcji param:

$v = $q->param('nazwa_parametru');

h1(string) - <H1>string</H1>

use CGI qw/:standard/;

   print 

       header,

       start_html('Simple Script'),

       h1('Simple Script'),

       start_form,

       "What's your name? ",textfield('name'),p,

       "What's the combination?",

       checkbox_group(-name=>'words',

                      -values=>['eenie','meenie','minie','moe'],

                      -defaults=>['eenie','moe']),p,

       "What's your favorite color?",

       popup_menu(-name=>'color',

                  -values=>['red','green','blue','chartreuse']),p,

       submit,

       end_form,

       hr,"\n";

 

    if (param) {

       print 

           "Your name is ",em(param('name')),p,

           "The keywords are: ",em(join(", ",param('words'))),p,

           "Your favorite color is ",em(param('color')),".\n";

    }

    print end_html;