Tekst źródłowy strony Perl

[[Category:Programowanie]]
== Perl ==
'''Perl''' (''Practical Extraction and Report Language''), twórcą języka jest Larry Wall. Perl jest bardzo często wykorzystywany przy tworzeniu małych "szybkich" programów. Jeżeli ktoś z czytelników programował wcześniej w takim języku jak '''C/C++''' to nie powinien mieć wielkich problemów z nauką perla, gdyż składnie tych języków są bardzo podobne.

Długich wstępów jak wiadomo i tak nie wielu czyta ;-) więc przejdźmy do bardziej praktyczniejszych spraw związanych z językiem perl.
=== Omówienie składni ===

Aby jak najłatwiej opisać składnię tego języka, na początku omówimy pierwszy mały programik

 #! /usr/bin/perl
 print "witaj swiecie\n";
 print "witaj swiecie\n\n\n\n";

Pierwsza linijka kodu jest wymagana do działania programu, gdyż wskazuje ścieżkę do zainstalowanego w systemie programu perl, inaczej mówiąc mówimy naszemu systemowi, że mamy zamiar napisać program w języku perl. Taka sama zasada panuje np wtedy, gdy chcemy napisać program w języku bash. Jeżeli z jakiś powodów w swoim systemi mamy inną ścieżkę do programu perl, możemy wyświetlić jej ścieżkę za pomocą polecenia

 $ whereis perl
 perl: /usr/bin/perl /usr/share/man/man1/perl.1.gz

Jeżeli chodzi o kolejną linijkę kodu to jak się nietrudno domyśleć, komenda print wyświetla znaki zawarte w cudzysłowiach "", znak \n powoduje wstawienie nowej lini. Na końcach widzimy znak średnika, który jest konieczny do poprawnego skompilowania programu.

Musimy również pamiętać o daniu odpowiednich praw dla stworzonego programu za pomocą polecenia chmod.

Jak widać pierwszy program wyświetlający napisy witaj świecie nie jest zbyt skomplikowany, ale na początek wystarczy, aby oswoić się ze składnią.  Poniżej postaram się przedstawić więcej szczegółów języka perl.

=== Operatory sterujące ===

W pierwszym przykładzie użyliśmy operatora w postaci \n, który powodował wstawienie nowej lini. Poniżej przedstawiam całą kolekcję operatorów, które mogą nam ułatwić życie w czasie pisania programu, jednocześnie musimy pamietać jak używać operatorów łańcuchowych. Dla przypomnienia

 print "jakiś łańcuch \a";

lub

 print 'jakies znaki' . "\t";

Pierwsza jak i druga forma jest dozwolona i jak najbardziej prawidłowa.

*\a dzwonek systemowy
*\b znak backspace
*\cD znak ctrl (w przykładzie + D)
*\e znak escape
*\E kończy działanie znaków  \L, \U, \Q
*\f znak wysunięcia strony
*\l następny jeden znak będzie małą literą
*\L cały ciąg będzie napisany z małych liter aż do \E
*\n znak nowego wiersza enter
*\r znak powrotu karetki
*\Q wstawia przed wszystkimi kolejnymi znakami znak lewego ukośnika aż do \E
*\t znak tabulacji
*\u kolejny znak napisany będzie z dużej litery
*\U wszystkie znaki aż do \E będzą wielkimi literami
*\x2f wartość ASCII zapisana w systemie szesnastkowym - tutaj 2f
*\007 wartość ASCII zapisana w systemie ósemkowym - tutaj 007
*\\ wstawia znak lewego ukośnika
*\" wstawia znak podwójnego cudzysłowu
 
=== Ostrzeżenia perla ===

Perl posiada bardzo przydatną funkcję wyświetlania komunikatów ostrzeżeń. Jeżeli ktoś chciałby wyświetlić takie komunikaty musi jedynie wywołać program z parametrem -w np

 localhost$ perl -w testowy_program 

można również dopisać do programu taką funkcję jak

 #! /usr/bin/perl
 use warnings; 

jednak powyższy przykład może nie działać na starszych wersjach perla.
=== Zmienne ===

Bardzo dobrą i przydatną funkcją języków programowania jest przypisywanie wartości do zmiennych.  Używanie zmiennych jest o tyle dobre, że zmienna zadeklarowana w jednym miejscu może być użyta w wielu fragmentach kodu, jeśli zajdzie potrzeba zmiany wartości, to będziemy musieli zmienić ją tylko w jednym miejscu.

Poniżej przykład zadeklarowania zmiennych

 $zmienna1 = 20;
 $zmienna2 = 'lancuch znakow'; 
 $zmienna3 = $zmienna1 + 10;

=== Wypisywanie danych na wyjściu ===

Wypisywanie danych na wyjściu, najprawdopodobniej na ekranie monitora odbywa się za pomocą polecenia print(). Jeżeli ktoś czytał początek tego howto to taka funkcja perla była już używana w celu wypisania jakiegoś łańcucha danych na ekranie. Funkcja print() wykorzystywana jest również do  wywoływania operatorów sterujących takich jak np \n, \t. Przykład użycia przedstawiam poniżej

 print "hello world \n";
 print 10 + 10;
 print "\n";
 print "10 i 10 rowna sie $zmienna1";

=== Logiczne operatory porównania ===

Tak jak w każdym języku programowania tak i perl posiada logiczne operatory porównania, które służą do niczego innego jak do porównania wartości pomiędzy sobą. Każdy z operatorów może zwrócić dwie wartości prawde (true) lub fałsz (fals).

Mamy również możliwość porównywania łańcuchów znakowych, co możemy uczynić za pomocą operatorów: eq, ge, gt, le, lt ,ne.  Poniższa tabela prezentuje wszystkie możliwości.

{| class="wikitable sortable"
|-
! Liczby !! Łańcuchy !! Opis
|-
| == || eq || równe
|-
| != || ne || różne
|-
| < || lt || mniejsze niż
|-
| > || gt || większe niż
|-
| >= || ge || większe niż lub równe
|-
| <= || le || mniejsze niż lub równe
|}

=== Podejmowanie decyzji za pomocą if else ===

Teraz kiedy umiemy porównać dane, możemy się nauczyć w jaki sposób decydować co ma się stać kiedy coś będzie większe, mniejsze lub równe czemuś innemu. Do tego celu możemy użyć polecenia if. W celu użycia konstrukcji warunkowej if musimy użyć nawiasów klamrowych w celu odsepasrowania bloków kodu, który jest wykonany wtedy, gdy coś spełni lub nie spełni warunku if. Jeżeli chcemy dać alternatywę dla wykonywanego programu, to używamy dodatkowej składni else. Ogólny schemat działania jest następujący

  if (dane <= dane2)
  {
      jakis wynik
    }
    else
    {
      jakis inny wynik
   }

Przykład możemy zobaczyć poniżej

 #! /usr/bin/perl
 $USER = 'testowy';
 if ($USER eq 'root')
 {
  print "Witaj super użytkowniku $USER \n";
 }
 else
 {
  print "Nie jesteś super użytkownikiem, tylko $USER \n";
 }

Możliwe jest również zagnieżdżanie konstrukcji warunkowej '''if''' np

    if (dane <= dane2)
    {
    if ( jakis wynik < inny wtynik )
    {
    jeszcze inny wynik
    }
    ....
    }
    else
    ...

Narazie przykłady mogą wydawać się mało praktyczne, ale z biegiem czasu będziemy na pewno potrafilii tworzyć bardziej praktyczne programy.
 
=== Pobieranie danych ze standardowego wejścia ===

W celu pobrania danych od użytkownika musimy posłużyć się operatorem , perl w tym momencie zaczeka na wprowadzenie danych przez usera aż do momentu, gdy zostanie naciśnięty klawisz nowego wiersza np enter.  W tym momencie dane zostaną wysłane do programu. Prosty przykład widzimy poniżej

 #! /usr/bin/perl
 print "Podaj liczbe od 1 do 9:";
 $liczba_usera = <STDIN>;
 chomp($liczba_usera);
 $automat = '5';
 print "Liczba uzytkownika = $liczba_usera \n";
 print "Liczba automatu =   $automat\n\n";
 if ($automat == $liczba_usera)
 {
  print "Zgadłeś liczbę automatu $automat \n";
 }
  else
 {
  print "Podana przez ciebie liczba $liczba_usera jest nieprawidłowa! \n";
 }
  
Pobieranie danych od użytkownika w powyższy sposób ma jeden feler, tzn pobierając znaki ze standardowego wejścia pobieramy również znak nowego wiersza co może wywołać w niektórych przypadkach nieoczekiwane wyniki. Aby naprawić ten błąd możemy posłużyć się operatorem chomp.

Operator '''chomp''' usuwa znak nowego wiersza z pobranego łańcucha danych można to zaobserwować na poniższym przykładzie

 #! /usr/bin/perl
 print "Podaj login:";
 $user = <STDIN>;
 chomp($user);
 $u = 'root';
 print "Nazwa usera = $user \n";
 print "Nazwa użytkownika root =   $u\n\n";
 if ($u eq $user)
 {
  print "Jesteś super userem $u \n";
 }
  else
 {
  print "Jestes zwyklym uzytkownikiem $user \n";
 } 
 
W celu testowym możemy zobaczyć co się stanie jeśli odpalimy ten sam program wymazując tylko linijkę chomp($user);

==== Operator "diamentowy" ====
Pobieranie danych z operatora "diamentowego" ''<>'' (znak mniejszości i większości) umożliwia stworzenie programu, który podczas uruchamiania pobierze dodatkowe argumenty ze standardowego wejścia znaczy klawiatury np
 ./program test1 test2
''test1'' oraz ''test2'' to istniejące pliki. Przykład poniżej powinien rozjaśnić całą zabawę z operatorem diamentowym w perlu.
 #! /usr/bin/perl
 while (defined($line = <>)) {
        chomp($line);
        print "Wczytałem wiersz $line \n";
 }
należy pamiętać aby operator ''<>'' użyć w programie tylko jeden raz w innym przypadku pojawią się błędy.

=== Pętla while ===

Piękno programowania polega na tym, że najnudniejsze operacje wykonuje komputer, a nie my ;-) Do tego celu możemy użyć jednej z wielu pętli jaką jest while. W tym przypadku blok kodu będzie się wykonywać tak długo, aż nie zostanie spełniony jakiś warunek. Jako że najlepiej zobaczyć i zrozumieć działanie na przykładowym kodzie poniżej przedstawiam kolejny przykład z wykorzystaniem pętli while.

 #! /usr/bin/perl
 $liczba = 0;
 while ($liczba < 10)
 {
  $liczba +=1;
  print "wartosc: $liczba \n";
 }

Na początku deklarujemy zmienną $liczba, aby później było można stworzyć warunek, który będzie mógł przerwać działanie pętli.

W 5 wierszu mamy tzw argument przypisania czyli $liczba +=1; jest to to samo co zapis $liczba = $liczba + 1;. Wiersz ten dodaje do zmiennej $liczba wartość 1 co jeden skok pętli aż do momentu, gdy wartość zmiennej  $liczba osiągnie 10, wtedy warunek się spełni i pętla zakończy swoje działanie.

=== Przypisywanie listy ===

Przypisanie listy wartości do zmiennych odbywa się w prawie taki sam sposób jak zwykłe przypisanie wartości do zmiennej.

 ($wart1, $wart2, $wart3) = ("zawartosc1", "zawartosc2", "zawartosc3");

wszystkim zmiennym po lewej stronie została przypisana odpowiednia wartość. W tym momencie, aby odczytać dane z tak przygotowanej listy wykonujemy znany już nam bardzo dobrze odczyt danych za pomocą polecenia print

 print $wart2. "\n";
 print $wart3. "\n";

=== Tablice ===

Tablica podobnie jak w innych językach programowania np C/C++, jest swego rodzaju zmienną, która zawiera uporządkowaną listę wartości. Każdy element tak uporządkowanej listy jest oddzielną zmienną, która posiada przypisany indeks. Tablice indeksowana jest zawsze od 0! W ten sposób wiemy, że zawsze pierwszy element tablicy będzie miał indeks 0.

Aby zapisać dane w tablicy, możemy do każdego indeksu przypisać dane z osobna lub posłużyć się pętlą. Poniżej użyję pierwszej metody aby czytelnik łatwiej mógł zrozumieć działanie tablic

 $tab[0] = "pierwsza pozycja tablicy, indeks 0";
 $tab[1] = "druga pozycja tablicy, indeks 1"; 
 $tab[2] = "trzecia pozycja tablicy, indeks 2";

Każda z pozycji tablicy może zawierać zarówno łańcuch znakowy jak i liczby

Aby dostać się do wybranej wcześniej zadeklarowanej tablicy wystarczy podać nazwę tablicy oraz indeks

 print $tab[0]; 

Jeżeli chcielibyśmy wyświetlić całą tablicę tzn wszystkie pozycje jej listy możemy użyć operatora @ i pominąć nawiasy kwadratowe [ ]. Prostym przykładem użycia tego operatora może być

 $tab[0] = "pierwsza pozycja tablicy, indeks 0";
 $tab[1] = "druga pozycja tablicy, indeks 1"; 
 $tab[2] = "trzecia pozycja tablicy, indeks 2"; 
 print @tab;

jak możemy zaobserwować ostatnia linijka kodu print @tab; wyświetli nam całą listę tablicy tab.

Kolejnym udogodnieniem w perlu jest edytowanie tablic bez potrzeby znajomości indeksów, tzn mowa o operatorach pop oraz push.

==== Operator pop ====

Operator pop usuwa i zwraca ostatni element tablicy. Możemy to zaobserwować na poniższym przykładzie

 #! /usr/bin/perl
 $tab[0] = "pierwsza pozycja tablicy, indeks 0\n";
 $tab[1] = "druga pozycja tablicy, indeks 1\n";
 $tab[2] = "trzecia pozycja tablicy, indeks 2\n\n";
 print @tab;
 pop @tab;
 print @tab;

Jak widzimy ostatnia linika kodu po wykonaniu zwróciła już tylko dwie pierwsze pozycje tablicy, ostatnia została usunięta.

==== Operator push ====

Co innego jeśli  chodzi o operator push, który pozwala nam na dodanie wartości na samym końcu tablicy. Przykładowy programik pownien wszystko wyjaśnić ;-)

 #! /usr/bin/perl
 $tab[0] = "pierwsza pozycja tablicy, indeks 0\n";
 $tab[1] = "druga pozycja tablicy, indeks 1\n";
 $tab[2] = "trzecia pozycja tablicy, indeks 2\n\n";
 print @tab;
 push @tab, $tab[1];
 print @tabo;
 push @tab, 1000;
 print @tab;

W powyższym przykładzie w lini push @tab, @tab[1]; dodaliśmy na koniec tablicy jedną z pozycji tablicy $tab o indeksie 1. Kolejnym przykładem jest dodanie do tablicy wartości w postaci 1000 w lini push @tab, 1000;.

'''UWAGA''' analogicznie do operatorów pop i push działają operatory shift i unshift. Operatory różnią się tym, że pop i push działają na końcu tablicy a operatory shift i unshift działają na początku tablicy. W tym przypadku unshift jest operatorem, który może dodać dane na początku tablicy a operator shift jest tym, który może usunąć dane z początku tablicy.

 #! /usr/bin/perl
 $tab[0] = "pierwsza pozycja tablicy, indeks 0\n";
 $tab[1] = "druga pozycja tablicy, indeks 1\n";
 $tab[2] = "trzecia pozycja tablicy, indeks 2\n\n";
 print @tab;
 shift @tab;
 print @tab;
 unshift @tab, 1000;
 print @tab;
 unshift @tab, $tab[1];
 print @tab;

Powyższy przykład działa analogicznie do omawianego przykładu z operatorów pop i push tyle tylko, że zmiany zachodzą na początku tablicy, a nie na jej końcu.

=== Skrót qw ===

Jak pięknie możemy sobie uprościć pracę z tablicami w perlu za pomocą skrótu qw. Skrót qw możemy użyć zawsze gdy chcemy utworzyć tablice z wieloma pozycjami,a nie chcemy tracić czasu na pisania i indeksowanie każdej pozycji tablicy. Wykorzystanie tego skrótu pokazuje poniższy przykład

 #! /usr/bin/perl
 @tab = qw{pozycja1 pozycja2 pozycja3 pozycja4};
 print @tab[1];
 print "\n";

Jak widać w drugiej linijce kodu została zadeklarowana tablica a następnie w trzeciej linijce odczytaliśmy 2 pozycję z zadeklarowanej tablicy (przypominam, że indeksy liczy się od 0 dlatego chociaż, że została wywołana pozycja z indeksem 1 to jest to druga pozycja z tablicy).

=== Struktura foreach ===

Umiemy już stworzyć własną tablicę na różne sposoby, umiemy również wyświetlić całą tablicę lub wskazane przez nas pozycję. Teraz nauczymy się jak przetworzyć całą listę tablicy. W tym celu perl udostępnia strukturę kontrolną foreach. Co taka pętla nam daje? foreach jest bardzo przydatną funkcją programowania w perlu, gdyż umożliwia nam automatyczne wykonanie napisanych przez nas instrukcji do każdej z pozycji listy.

Poniższy przykład demonstruje program, który składa się z trzech pozycji, następnie lista wyświetlana jest za pomocą foreach a dodatkowo do każdej z pozycji dodawwany jest znak nowej lini oraz tabulacja.

 #! /usr/bin/perl
 @tablica = qw/ pozycja1 pozycja2 pozycja3 /;
 foreach $zmienna (@tablica)
 {
        $zmienna = "\t$zmienna";
        $zmienna .= "\n";
 }
 print "Mamy następujące pozycje:\n", @tablica;

=== Sztuczka z $_ ===

Programista nie zawsze musi wymyślać nowe zmienne do przeprowadzenia jakiejś operacji, gdyż może do tego celu użyć domyślnej zmiennej perla, jest nią oczywiście $_ . Najłatwiej pokazać o co chodzi na małym przykładzie

 $_ = "domyślna zmienna perla\n";
 print;

Powyższa operacja jak nie trudno się domyśleć wypisze na ekranie domyślą zmienną, czyli akurat w tym przypadku będzie to tekst domyślna zmienna perla. Innym przykładem na wykorzystanie tego typu zmiennej może być następujący kod

 #! /usr/bin/perl
 foreach (1..20)
 {
      print "Liczę do: $_ \n";
 }

=== Operator reverse oraz sort ===

==== Operator reverse ====

Operator r'''everse''' jak sama nazwa wskazuje odwraca kolejność wyświetlanej listy. Przykład jest oczywisty ;-)

 #! /usr/bin/perl
 @tab = qw/jeden dwa trzy cztery piec szesc siedem /;
 foreach $zmienna (@tab)
 {
      $zmienna = reverse($zmienna);
      $zmienna .= "\n";
 }
 print "Wyświetlam w odwróconej formie:\n", @tab;
 $tab2[0] = "1";
 $tab2[1] = "2";
 $tab2[2] = "3";
 print @tab2;
 print "\n";
 @tab2 = reverse(@tab2);
 print @tab2;
 print "\n";

Przykład pokazuje dwa sposoby w jaki działa operator reverse, pierwszy odwraca kolejność znaków a drugi odwraca kolejność wyświetlania listy.

==== Operator sort ====

Operator sort sortuje wynik w porządku z kodu ASCII. Oznaczza to że, liczby zawsze będą przed innymi znakami, wszystkie wielkie litery znajdują się przed małymi literami, znaki z białej listy czyli spacje, tabulacje znajdują się w jednej grupie jak i drugiej.  Przykład

 #! /usr/bin/perl
 @tab = qw/ jeden dwa trzy cztery piec szesc /;
 @tab = sort @tab;
 print @tab, "\n";

=== Procedury ===

Procedury są to kawałki kodu odpowiedzialne za wykonanie danego mu działania, które możemy użyć kilkakrotnie w każdym z miejsc naszego programu. Plusem tego typu działania jest to, że nie musimy pisać kilkakrotnie tych samych funkcji, które robią to samo, wystarczy użyć raz napisanej procedury. Aby zadeklarować procedure używamysłowa kluczowego sub oraz nazwy procedury.

 #! /usr/bin/perl
 sub procedura
 {
         $a += 1;
         print "Wywołuje procedure $a\n";
 }
 &procedura
 &procedura
 &procedura
 &procedura

od lini 2 do 5 mamy zadeklarowaną procedurę za pomocą słowa kluczowego sub następnie występuje nazwa procedury procedura, należy zwrócić uwagę, że przy nazwie procedury nie występuje żaden inny znak typu @, $, &. W lini trzeciej otwieramy nawias klamrowy i poniżej widzimy właściwe działanie tzn to co wykonuje nasza procedura. Oczywiście kod procedury może być o wiele bardziej rozbudowany. Całą procedurę zamykamy nawiasem klamrowym.

A co z wywołaniem procedury? Jest to dość prosta sprawa, gdyż wystarczy użyć polecenia

 &procedura

No i dla ugruntowania informacji jako, że uważam, że najlepiej jest uczyć się na przykładach to jeszcze jedna porcja kodu ;-)

 #! /usr/bin/perl
 sub procedura1
 {
           print "podaj pierwszą liczbe:";
           $a = ;
 }
 sub procedura2
 {
           print "\nPodaj drugą liczbę:";
           $b = ;
 }
 $pierwsza = &procedura1;
 $druga = &procedura2;
 print "procedura1: $pierwsza\n";
 print "procedura2: $druga\n";
 $wynik = $pierwsza + $druga;
 print  "Suma: $wynik\n";

=== Argumenty inny sposób ===

Jak inaczej można przekazać argumenty dla procedur lub innych funkcji naszego programu? Chciałbym w tym miejscu pokazać całkiem ciekawą ale niezbyt czystą funkcję programowania w perlu.

 $a = &liczby(1, 2, 3, 4, 5);

Taki zapis perl potraktuje jako specjalne wartości i przechowa je na czas trwania procedury w specjalnej zmiennej tablicowej @_ .Jak dobrze pamiętamy tablice składają się z danych, które są uporządkowane w listach do których mamy dostęp w indeksach i tak samo jest w tej sytuacji. Aby dostać się do tak zadeklarowanych wartości musimy użyć np $_[0] będzie to pierwsza wartość druga będzie $_[1] itd. Aby w pełni zrozumieć działanie tego mechanizmu przyglądnijmy się takiemu przykładowi

 #! /usr/bin/perl
 $a = &max(10, 20, 30, 40);
 sub max
 {
 if ($_[0] > $_[1])
      {
           print $_[0];
      }
 else
      {
            print $_[1];
      }
 }
 &max

Dlaczego wyżej napisałem, że ta metoda nie jest zbyt "czysta". Jak pewnie zauważyliśmy w tablicy max mamy zadeklarowane liczby 10, 20, 30, 40 a korzystamy tylko z 10 i 20 więc cała reszta jest nie wykorzystana. Dopóki o tym pamiętamy i świadomie używamy takiego mechanizmu to powinno być wszystko dobrze jednak radziłbym w takich miejscach wstawiać odpowiednie komentarze ;-)

=== Zmienna leksykalna my ===

Zmienne leksykalne '''my''' używamy wtedy gdy, chcemy powiedzieć kompilatorowi, że dana zmienna powinna być prywatna lub mieć ograniczony zasięg np jedynie do danego bloku. W tym momencie żadna inna zmienna o tej samej nazwie nie będzie mogła być zastąpiona inną wartością, która przechowywana jest w zmiennej o tej samej nazwie. Co lepsze taka zasada działa również na odwrót tzn, że żadna inna zmienna nie zmieni tak zadeklarowanej zmiennej w danym bloku. Przykładowy programik przedstawiam poniżej

 #! /usr/bin/perl
 print "Podaj jakieś imie:";
 $what = <STDIN>;
 chomp($what);
 my @names = qw/ kasia slawek ania piter natalia adam jacek kuba /;
 my $result = &which_elements_is($what, @names);
 sub which_elements_is {
        my ($what, @array) = @_;
        foreach (0..$#array) {
        if ($what eq $array[$_]) {
        return $_;
         }
    }
 -1;
 }
 if ($result == 1) {
        print "Imię $what zostało odnalezione w bazie\n";
 } else {
        print "Imię $what NIE zostało odnalezione w bazie \n";
 }

Jak można łatwo zauważyć w tym krótkim programiku występują dwie stałe o nazwie $what, które działają koło siebie bez żadnych błędów. Tak czy inaczej pisząc w ten sposób program stał się mało czytelny.

=== Tablica asocjacyjna ===
Tablica asocjacyjna jest strukturą danych, która może przechowywać dowolne wartości i zwracać je na żądanie programisty.  Indeksowanie wartości odbywa się za pomocą nazw (kluczy) a nie jak to miało miejsce w zwykłych tablicach za pomocą indeksów. Mały przykład użycia
 #! /usr/bin/perl
 $nazwa1{"kowalski"} = "Jan";
 nazwa1{"nowak"} = "Adam";
 foreach $ludzie (qw< nowak kowalski >) {
        print "Słyszałem o rodzinie $ludzie $nazwa1{$ludzie}. \n";
 }



'''HOWTO W TRAKCIE PISANIA''' 
<br /><google1 style="4"></google1>