Źródło: Nik Silver. Perl Tutorial: Start. http//:agora.ac.ic.uk/nik/ - strona już nie istnieje.
Zachował się oryginalny tekst Perl Tutorial. Więcej informacji zawiera nowy podręcznik Perl-a na stronie Tutorials Point (html) lub (PDF) .

Tekst ten rozpoczyna naukę perla, i początkowo był wykorzystany przez Nika Silvera jako pierwsza część praktycznych warsztatów, prowadzonych w Szkole Nauk Komputerowych na Uniwersytecie w Leeds w Zjednoczonym Królestwie. Druga część warsztatów dotyczyła projektowania stron WWW. perla wykorzystano do obsługi przycisków oraz obszarów tekstowych i generowania zwykłych stron WWW w locie. Budowanie stron WWW bez tego wszystkiego jest o wiele prostsze. W Leeds znajdują się informacje o tym jak to należy robić, lepiej jednak zajrzeć do kompletnego przewodnika dla początkujących (Beginner's Guide) NCSA.

Istnieje wiele innych materiałów do nauki perla. Prawie wszystkie można znaleźć w Archiwum perla w UF/NA. Chciałbym jednak aby znalazły się tutaj ćwiczenia dotyczące zwartej temetyki, a żaden inny tekst tego nie zapewnia.

Zakładam bardzo podstawową wiedzę o systemie UNIX  koncentrując się na tym jak pisać podstawowe, działające programy perla. Nie wyjaśniam dlaczego coś działa tak jak działa, jak również nie dokonuje rozszerzeń języka; zakładam, że czytelnik może sam we własnym zakresie dokonać właściwych dla siebie rozszerzeń.

Dziękuje Neilowi Bowersowi z którego strony o perlu buchnąłem ikone wielbłąda (on pewnie też ją buchnął wcześniej od kogoś innego) oraz naszemu Zespołowi Pomocniczemu za techniczne umiejętności.

Podstawowy program

      #!/usr/local/bin/perl
      #
      # zwyczajny program
      #
      print 'Witaj świecie.';  # drukuj
      

Pierwsza linia

Komentarze i instrukcje

Proste wydruki

Uruchamianie programu

        chmod u+x nazwaprogramu
      

        perl nazwaprogramu
        ./nazwaprogramu
        nazwaprogramu
      

        perl -w nazwaprogramu
      

        perl -d nazwaprogramu
      

Zmienne skalarne

        $priorytet=9;
      

        $priorytet='wysoki';
      

        $priorytet='9';
        $priorytet='009';
      

Operacje i przypisania

        $a = 1 + 2;      # dodaj 1 do 2 i umieść wynik w $a
        $a = 3 - 4;      # odejmij 4 od 3 i umieść wynik w $a
        $a = 5 * 6;      # pomnóż 5 przez 6, umieść wynik w $a
        $a = 7 / 8;      # podziel 7 przez 8; wynik w $a
        $a = 9 ** 10;    # podnieś 9 do potęgi 10
        $a = 5 % 2;      # reszta z dzielenia 5 przez 2
        ++$a;            # zwiększ $a o 1 i zwróć wynik
        $a++;            # zwróć $a i następnie zwiększ $a o 1
        --$a;            # zmniejsz $a o 1
        $a--;            # zwróć $a i zmniejsz ją o 1
      

        $a = $b . $c;    # łączenia $b i $c; konkatenacja
        $a = $b x $c;    # $a powtórzone $c razy
      

        $a = $b;         # przypisz $b do $a
        $a += $b;        # dodaj $b do $a
        $a -= $b;        # odejmij $b od $a
        $a .= $b;        # przyłącz $b do $a
      

Interpolacja

        $a = 'gruszki';
        $b = 'banany';
        print $a . ' i ' . $b;
      

        print '$a  i $b';
      

        print "$a  i $b";
      

Ćwiczenie

Zmienne tablicowe

        @owoce={"gruszki","banany","porzeczki"};
        @muzyka={"gwizdek","flet"};
      

Dostęp do tablicy uzyskujemy podając indeks o wartości 0, 1, 2, ..., w nawiasie kwadratowym. Wyrażenie $owoce[2] zwraca porzeczki. Zauważmy, że znak @ zastąpiony został przez $ ponieważ porzeczki to skalar.

Przypisania tablic

      @orkiestra={"organy",@muzyka,"harfa"};
      @orkiestra={"organy","gwizdek","flet","harfa"};
    

      push{@owoce,"truskawki"};
    

      push(@owoce,"truskawki","kiwi");
      push(@owoce.("truskawki","kiwi"));
      push(@owoce,@inneowoce);
    

Aby usunąć ostatni element tablicy używamy funkcji pop.

      $pop(@owoce);
    

Możliwe jest przypisanie tablicy zmiennej skalarnej. Wynik przypisania zależy od kontekstu. Linia

      $f = @owoce;
    

      $f = "@owoce";
    

Tablic można również używać w instrukcjach wielokrotnego przypisania.

      ($a, $b) = ($c, $d);    # to samo co $a = $c; $b = $d;
      ($a, $b) = @owoce;      # $a i $b są takie same jak 
      # pierwszy i drugi element @owoce;
      ($a, @inne) = @owoce;   # $a jest pierwszym elementem @owoce
      # @inne zawiera pozostałe elementy @owoce
      (@inne, $a) = @owoce    # @inne = @owoce; $a jest niezdefiniowana
    

Jeśli w końcu chcemy znać indeks ostatniego elementu tablicy, wydajemy polecenie

      $#owoce
    

Wypisywanie tablic

      print @owoce;      # 
      print "@owoce";    # w dwu podwójnych cudzysłowach
      print @food."";    # kontekst skalarny
    

Ćwiczenie

Pliki

      #!/usr/local/bin/perl
      #
      # program otwiera plik password, czyta w nim,
      # drukuje jego zawartość i zamyka go

      $plik = '/etc/passwd';       # nazwij plik
      open(INFO,$plik);            # otwórz plik
      @linie=<INFO>;               # wczytaj go do tablicy
      close(INFO);                 # zamknij plik
      print @linie;                # drukuj tablicę
    

Funkcja close mówi by perl zakończył pracę z tym plikiem.

W związku z tą dyskusją warto dodać kilka uwag dotyczących używania uchwytów plików. Po pierwsze w poleceniu open można wyspecyfikować czy plik ma być plikiem do zapisu, do dopisywania czy też tylko do odczytu. W tym celu poprzedzamy nazwę pliku znakiem > - zapis, lub znakiem >> - dopisywanie do pliku.

        open(INFO, $plik);          # otwórz do odczytu
        open(INFO, ">$plik");       # otwórz do zapisu
        open(INFO, ">>$plik");      # otwórz w celu dopisywania
        open(INFO, "<$plik");       # otwórz do odczytu; jak w pierwszej linii
      

Po drugie, jeśli chcemy zapisać coś do uprzednio otwartego do zapisu pliku, używamy polecenia print z dodatkowym parametrem

        print INFO "Ta linia zapisana jest do pliku.\n"
      

Po trzecie, do otwarcia standardowego pliku wejścia (zazwyczaj klawiatura) i wyjścia (zazwyczaj ekran monitora) piszemy:

          open(INFO, '-');          # otwórz standardowe wejście
          open(INFO, '>-');         # otwórz standardowe wyjście
        

          @linie = <INFO>;
        

Ćwiczenie

Konstrukcje kontrolne

foreach

        foreach $produkt (@owoce)     # odwiedź kolejno każdy element
        # i nazwij go $produkt
        {
          print "$produkt\n";         # wydrukuj element
          print "Niam, niam.\n"       # To jest coś
        }
      

Testy

        $a == $b;      # czy $a jest liczbowo równe $b?
        # Ostrzeżenie: nie używaj operatora =
        $a != $b;      # czy $a jest liczbowo różne od $b?
        $a eq $b;      # czy $a jako łańcuch równe jest $b? 
        $a ne $b;      # czy $a jako łańcuch jest różne od $b?
      

        ($a && $b);            # czy prawda, że $a i $b?
        ($a || $b);            # czy prawda, że $a lub $b?
        !($a);                 # czy nie $a? 
      

for

        for (inicjacja; warunek; przyrost)
        {
          pierwsze_polecenie;
          drugie_polecenie;
          etc
        }
      

        for ($i = 0; $i < 10; ++$i)   # zacznij z $i=1
                                      # rób dopóki $i < 10
        {
           print "$i\n";
        }
      

while i until

        #!/usr/local/bin/perl
        print "Password? ";       # prośba o dane
        $a = <STDIN>              # pobierz dane
        chop $a;                  # usuń znak new line na końcu linii
        while ($a ne "fredek")    # jeśli dane są złe ...
        {
          print "Przykro mi. Jeszcze raz? "; # jeszcze raz
          $a = <STDIN>>                      # pobierz dane
          chop $a;                           # usuń znów nl
        }
      

Chcąc sprawdzić coś przeciwnego powinniśmy użyć polecenia until dokładnie w ten sam sposób. Blok wykonywany jest dopóty dopóki wyrażenie jest prawdą.

Inną użyteczną techniiką jest umieszczenie warunku while lub until na końcu instrukcji blokowej. Wymaga to obecności operatora do, który wskazuje początek bloku i umieszczenia warunku na końcu bloku. Powyższy program można zapisać następująco.

        #!/usr/local/bin/perl
        do
        {
          print "Password? ";       # prośba o dane
          $a = ;             # pobierz dane
          chop $a;                  # usuń znak new line na końcu linii
        }
        while ($a ne "fredek")      # powtórz jeśli dane są złe ...
      

Ćwiczenie

        1 root:oYpYXm/qR06n2:0:0:Super-User:/:/bin/csh
        2 sysadm:*:0:0:System V Administration:/usr/admin://bin/sh
        3 diag:*:0:996:Hardware Diagnostics:/usr/diags:/bin/csh
        etc.
      

        while ($linia = <INFO>)
        {
        ...
        }
      

Instrukcje warunkowe

        if ($a)
        {
          print "Łańcuch nie jest pusty.\n";
        }
          else
        {
          print "Łańcuch jest pusty.\n";
        }
      

W instrukcji warunkowej można zawrzeć więcej możliwości

        if (!$a)
        {
          print "Łańcuch jest pusty.\n";
        }
          elsif (length($a)==1)
        {
          print "Łańcuch zawiera jeden znak.\n";
        }
          elsif (length($a)==2)
        {
          print "Łańcuch zawiera dwa znaki.\n";
        }
          else
        {
          print "Łańcuch zawiera wiele znaków.\n";
        }
      

Ćwiczenie

Dopasowywanie łańcuchów

Wyrażenia regularne

        $zdanie =~ /to/
      

        $zdanie =~ "To jest szybki rudy lis.";
      

        $zdanie !~ /to/
      

Zmienna specjalna $_

        if ($zdanie =~ /na dole/)
        {
          print "Rozmawiamy o rugby\.";
        }
      

        $zdanie = "Na górze i na dole";
        $zdanie = "Na górze róże na dole fiołki";
      

  if (/na dole/)
  {
     print "Rozmawiamy o rugby\n";
  }

Więcej o WR

Oto niektóre specjalne znaki WR wraz z ich znaczeniami.

  .         # dowolny znak wyłączając znak nowej linii
  ^         # początek linii lub łańcucha
  $         # koniec linii lub łańcucha
  *         # zero lub więcej razy ostatni znak
  +         # raz lub więcej ostatni znak
  ?         # zero lub jeden raz ostatni znak

  t.k       # t i następnie cokolwiek oraz k
            #   pasuje to do tak, tek, tik, tuk, ...
            #   lecz nie do te, tolo
  ^f        # f na początku linii
  ^ftp      # ftp na początku linii
  e$        # e na końcu linii
  tle$      # tle na końcu linii
  und*      # und plus zero lub więcej d
            #   pasuje do un, und, undd, unddd (etc)
  .*        # wszystko z wyjątkiem new line.
            # Jest tak dlatego, iż . pasuje do wszystkiego
            #   z wyjątkiem nowej linii, a * oznacza zero lub
            #   więcej razy
  ^$        # linia pusta

  [qjk]      # q lub j lub k
  [^qjk]     # ani q ani j ani k
  [a-z]      # wszystko pomiędzy a i z włącznie
  [^a-z]     # wszystko prócz małych liter
  [a-zA-Z]   # dowolna litera
  [a-z]+     # każdy niepusty ciąg małych liter

Pionowa kreska | reprezentuje or, a nawiasy są używane aby zgrupować różne rzeczy.

  galaretka|krem  # galaretka albo krem
  (eg|le)gs       # albo egs albo legs
  (da)+           # da lub dada lub dadada lub ...

  \n           # nowa linia
  \t           # tabulator
  \w           # znak alfanumeryczny (słowo)
               # to samo co [a-zA-Z0-9_]
  \W           # wszystko co nie jest słowem
               # to samo co [^a-zA-Z0-9_]
  \d           # cyfra. To co [0-9]
  \D           # nie cyfra, [^0-9]
  \s           # znak biały: odstęp
               # nowa linia, tabulator, etc
  \S           # nie spacja
  \b           # ogranicznik słowa, tylko wewnątrz []
  \B           # zaprzeczenie powyższego

  \$           # znak dolara $
  \|           # kreska pionowa
  \[           # otwierający nawias kwadratowy
  \)           # nawias zamykający
  \*           # gwiazdka
  \\           # ukośnik lewy
  \/           # ukośnik prawy

Przykłady WR

  [01]         # albo "0" albo "1"
  \/0          # dzielenie przez zero: "/0"
  \/ 0         # dzielenie przez zero z odstępem: "/ 0"
  \/\s0        # dzielenie  przez zero ze znakiem białym:
               # "/ 0" gdzie spacja oznacza tabulator etc.
  \/ *0        # dzielenie przez zero z możliwymi odstępami:
               # "/0" lub "/ 0", lub "/  0" etc.
  \/\s*0       # dzielenie przez zero z możliwością białych
               # znaków.
  \/\s*0\.0*   # jak wyżej, lecz z kropką dziesiętną
               # i możliwymi zerami po niej. Dopuszczalne
               # są "/0." i "/0.0", i "/0.00", ..., etc.
               # oraz "/ 0." i "/  0.0", i "/   0.00",..., etc.

Ćwiczenie

• znak x
• łańcuch the
• łańcuchy the oraz The
• słowo the z małej lub dużej litery. Użyj \b w celu detekcji granicy słowa

Podstawienia i translacje

W celu zamiany łańcuch alondyn na Londyn w zmiennej $zdanie, używamy polecenia

  $zdanie =~ s/londyn/Londyn/

  s/londyn/Londyn/

Opcje

  s/londyn/Londyn/g

Jeśli chcemy by zamienione zostały ciągi lOndyn lonDYN, LoNDyN itd. możemy napisać

  s/[lL][oO][nN][dD][yY][nN]/Londyn/g

  s/londyn/Londyn/gi

Zapamiętywanie wzorców

  $_ = "Lord Whopper of Fibbing";
  s/([A-Z])/:\1:/g;
  print "$_\n";

W innym przykładzie, test

  if (/(\b.+\b) \1/)
  {
      print "Znaleziono powtórzone $1\n"
  }

Następujący fragment zamienia pierwszy i ostatni znak w zmiennej $_:

  s/^(.)(.*)(.)$/\3\2\1/

Po dopasowaniu można używać zmiennych (tylko do odczytu) $`, $& i $', które zawierają kolejno ciąg przed dopasowanym ciągiem, dopasowany ciąg oraz ciąg występujący po dopasowaniu. Po wykonaniu fragmentu

  $_ = "Lord Whopper of Fibbing";
/pp/;

  $` eq "Lord Who";
  $& eq "pp";
  $' eq "er of Fibbing";

W związku z zapamiętywaniem wzorców warto wiedzieć, że zmienne wewnątrz ukośników są interpolowane. Kod

  $szukaj = "tam";
  s/$szukaj/xxx/g;

  $szukaj = "tam";
  s/{$szukaj}ten/xxx/g;

Translacja (Przekład)

  $zdanie =~ tr/abc/edf/;

  $liczba = ($zdanie =~ tr/*/*/);

  tr/a-z/A-Z/;

Ćwiczenie

  023, Amp, James Wa(tt), Bob Transformer, etc. These pion(ee)rs

Aby uatrakcyjnić nieco ten program możesz spróbować czegoś takiego. Załóżmy, że program nazywa się liczlinie. Można go więc wywołać przez

  ./liczlinie

  ./liczlinie pierwszy drugi etc

  ./liczlinie the

  019 But (the) greatest Electrical Pioneer of (the)m all was Thomas Edison, who

split

Funkcji split używamy następująco

  $info = "Caine:Michael:Actor:14, Leafy Drive";
  @personal = split(/:/, $info);

@personal = ("Caine", "Michael", "Actor", "14, Leafy Drive");

Jeśli informacja znajduje się w zmiennej $_ możemy napisać

  @personal = split(/:/);

Jeśli pola oddzielone są dowolną liczbą dwukropków wówczs możemy użyć kodów WR. Program

$_ = "Capes:Goeff::Shot putter:::Big Avenue";
@personal = split(/:+/);

  @personal =  ("Capes", "Goeff", "Shot putter", "Big Avenue");

  $_ = "Capes:Goeff::Shot putter:::Big Avenue";
  @personal = split(/:/);

  @personal =  ("Capes", "Goeff", "", "Shot putter", "", "", "Big Avenue");

Słowo można podzielić na znaki, zdanie na słowa, a akapit na zdania.

  @znaki  = split(//, $slowo);
  @slowa  = split(/ /, $zdanie);
  @zdania = split(/\./, $akapit);

Ćwiczenie

  discovered (this is the truth) that when he
  t kinds of metal to the leg of a frog, an e
  rrent developed and the frog's leg kicked,
  longer attached to the frog, which was dea
  normous advances in the field of amphibian
  ch it hop back into the pond -- almost.  Bu
  ond -- almost.  But the greatest Electrical
  ectrical Pioneer of them all was Thomas Edi

• Wczytaj cały tekst do tablicy (nie jest to ogólnie biorąc zbyt wygodne gdyż pliki mogą być bardzo duże, ale nie będziemy się teraz tym zamartwiać). Każdy element tablicy będzie linią pliku.
• Kiedy użyta zostanie funkcja chop na tablicy, obetnie ostatni znak z każdego jej elementu. Przypomnijmy, że tablicę można połączyć w całość poleceniem w rodzaju $text = "@lines";
• Użyj łańcucha docelowego jako podzielnika tekstu (tzn. w miejscu dwukropka z poprzednich przykładów użyj łańcucha docelowego) Powinieneś otrzymać tablicę, której elementy rozdziela zadany łańcuch.
• Wydrukuj teraz każdy element tablicy, następnie łańcuch docelowy i dalej następny element tablicy.
• Pamiętaj, że ostatni element tablicy @owoce ma indeks równy $#owoce.

substr("Once upon a time", 3, 4);	# zwraca "e up"
substr("Once upon a time", 7);		# zwraca "on a time"
substr("Once upon a time", -6, 5);	# zwraca "a tim"

Jeśli użyjemy ujemnego indeksu, który wybierze podłańcuch rozciągający się przed początek łańcucha, perl ostrzeże nas lub nic nie zwróci. Aby ustrzec się takiej sytuacji można użyć wspomnianego wcześniej operatora x i uzupełnić łańcuch. Np. wyrażenie (" "x30) tworzy 30 odstępów.

Tablice asocjacyjne

Aby zdefiniować tablicę asocjacyjną używa się zwykłego zapisu z nawiasami, lecz sama nazwa tablicy poprzedzona jest znakiem %. Załóżmy, że tworzymy tablicę osób wraz z ich wiekiem. Można to zrobić następująco:

  %wiek = ("Michael Caine", 39,
           "Dirty Dean", 34,
           "Angie", 27,
           "Willy", "21 in dog years",
           "The Queen Mother", 108);

Wiek osób możemy znaleźć używając następujących wyrażeń

  $wiek{"Michael Caine"};      # zwraca 39
  $wiek{"Dirty Dean"};         # zwraca 34
  $wiek{"Angie"};              # zwraca 27
  $wiek{"Willy"};              # zwraca "21 in dog years"
  $wiek{"The Queen Mother"};   # zwraca 108

Tablice asocjacyjne można zamienić na zwykłe tablice listowe przez przypisanie ich do zmiennej talicy typu listy. Zwykłe tablice można z kolei przywrócić do postaci tablic asocjacyjnych przez przypisanie ich do zmiennej typu tablicy asocjacyjnej. Zwykłe tablice muszą mieć parzystą liczbę elementów:

@info = %wiek;        # @info jest listą. Posiada
                      # aktualnie 10 elementów
$info[5];             # zwraca wartość 27
                      # z listy (tablicy) @info
%jeszczewiek = @info; # %jeszczewiek jest tablicą asocjacyjną
                      # jest ona identyczna jak %wiek

Operatory

  foreach $osoba (keys %wiek)
  {
        print "Znam wiek $osoba\n";
  }
  foreach $lata (values %wiek)
  {
        print "Kto ma $lata lat?\n";
  }

Kiedy funkcja keys/values wywoływana jest w kontekście skalarnym, zwracana jest liczba równa liczbie par klucz/wartość w tablicy asocjacyjnej.

Istnieje też funkcja each, która zwraca listę dwuelementową: klucz i jego wartość. Za każdym wywołaniem zwracana jest inna para klucz/wartość:

while (($osoba, $lata) = each($wiek))
{
      print "$osoba ma $lata lat\n";
}

Zmienne środowiskowe

  print "Nazywasz sie $ENV{'USER'} i pracujesz
  print "z ekranem $ENV{'DISPLAY'}\n;

Procedury

  sub mojaprocedura
  {
      print "Jest to niezbyt ciekawa procedura\n";
      print "Robi zawsze to samo\n";
  }

  &mojaprocedura;         # wywołanie procedury
  &mojaprocedura($_)      # wywołanie z parametrem
  &mojaprocedura(1+2, $_  # wywołanie z dwoma parametrami

Parametry

  sub printargs
  {
      print "@_\n";
  }
  &printargs("perly", "king");        # drukuje "perly king"
  &printargs("frog", "and", "toad");  # drukuje "frog and toad"

  sub printdwapierwsze
  {
      print "Pierwszy argument jest $_[0]\n";
      print "a $_[1] jest drugim argumentem\n";
  }

Zwracanie wartości

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

$wiekszy = &maksymalny(37, 24)      # $wiekszy jest równy 37

Procedura &printdwapierwsze też zwraca wartość. Jest to 1. Jest tak dlatego, że ostatnią wykonaną rzeczą jest polecenie print, a wynikiem wykonania print jest zawsze 1.

Zmienne lokalne

sub inside
{
      local($a, $b);              # utwórz zmienne lokalne
      ($a, $b) = ($_[0], $_[1]);  # dokonaj przypisania wartości
      $a =~ s/ //g;               # usuń spacje
      $b =~ s/ //g;               #  w zmiennych lokalnych
      ($a =~ /$b/ || $b =~ /$a/   # czy $a zawiera się w $b
                                  # czy też może na odwrót
}
&inside("lemon", "dole money");   # prawda

local($a, $b) = ($_[0], $_[1]);

Last modified: pią mar 2017-03-24 16:08:26 by andrzejbaran