[Perl] Kurs Perl - cz.2 - podstawy dobrego stylu, zmiene - c.d., petle...

[TQM]

Lecimy dalej

Dobry styl jaki jest nie wie nikt - kazdy ma swoj i tyle hihi. Sa jednak pewne wytyczne jak posac dobry kod, ktory jest pozniej latwo utrzymac na chodzie.

1. Zmiennym nadajemy nazwy ktore cos znacza - w ten spsoob kod prawie sam sie dokumentuje
2. use strict - to oszczedzi nam mase czasu jak bedziemy szukac bledow, kazda zmienna musi zostac zadeklarowana przed uzyciem - w ten sposob od razu wylapiemy literowki, zamiast szukac poznej czemu zmienne maja wartosc 0 i program nie dziala
3. use warnings albo flaga -w - dodatkowy debug moze sie przydac
4. Jesli jest modul realizujacy nasze zadanie to najprawdopodobniej powinnismy go uzyc (o tym dalej).

Kazdy musi wypracowac swoj styl - trwa to czasami dosc dlugo. Moj jaki jest taki jest, jednak moj kolega z pracy ktory od ponad 15 lat pisze w Perlu stwierdzil ze moj kod jest dosc zjadliwy, wiec chyba nie jest zle hihi.

Polecam 'man perlstyle' - dobrze widzicie, jest na ten temat strona manuala!

Zasieg leksykalny zmiennych
Jak wiece z innych jezykow, zmienne sa widoczne tylko w pewnym zakresie. W programie okreslamy zmienna $l i przypisujemy jej wartosc. Rzecz w tym ze nazwy $l mozna uzyc dalej w kodzie robiac z niej zmienna lokalna - zaraz bedzie przyklad.

Deklaracja funkcji
Funkcje czy tez procedury (tu nie ma rozroznienia jak w Pascalu na przyklad) moga zwracac wartosci, moga nic nie zwracac, moga dostawac parametry na rozne sposoby... do tego dojdziemy za chwilke

sub nazwa {
  polecenia;
}

Jesli mamy program w ktorym definiujemy zmienna $l, poznej definiujemy funkcje o nazwie XYZ i wewnatrz tej funkcji deklarujemy zmienna $l to beda to 2 rozne zmienne - odpalcie ponizszy kod:

use strict;
my $l=0;
print "L glowne = $l\n";
&nic;
print "L glowne = $l\n";

sub nic {
        print "L glowne w funkcji = $l\n";
	my $l = 5;
	print "Lokalne L funkcji = $l\n";
}

Jesli pominiemy to my, to przypisujac nowa wartosc zmieniamy wartosc zmiennej globalnej. Jesli jednak uzywamy strict, to ta pierwsza zmienna na poczatku kodu tez musi zostac okreslona jako my.
Tak samo strict wymusza aby funkcje byly jawnie deklarowane w kodzie w momencie wywolania - tzn napisanie nic; nie zadziala - trzeba wpisac &nic;.
Na poczatku uzywanie strict jest bardzo denerwujace - wiem po sobie, jednak w dluzszej perspektywie sami zobaczycie ze bez strict bedziecie miec mase problemow!

c.d.n

[TQM]

Przechodzac do petli dojdziemy do niektorych zmiennych magicznych jak to niektorzy nazywaja. Sa to po prostu zmienne kontekstowe, ktore powoduja ogromne zamieszanie zazwyczaj, choc tak na prawde nie sa straszne - wystarczy nieco myslec nad tym co sie robi...

Petle
Tutaj generalnie Perl nie rozni sie wiele od innych jezykow...

for ($l=0;$l<=100;$l++) {
  prin "L = $l\n";
}

$l=0;
while ($l<=100) { 
  print "L = $l\n";
  $l++;
}

tu zaczniemy nieco wiecej 'magii'

@liczby = (1..10);
foreach $liczba (@liczby) {
  print "L = $liczba\n";
}

Sprawdzanie warunkow odbywa sie standardowo:

$l=0;
if ($l >5) {
	print ">5\n";
} elsif ($l == 0) {
	print "zero";
} else {
	print "<5\n";
}

Wazne jest to, ze = to przypisanie wartosci, == to porownanie! Czesty blad to zrobienie czegos takiego:

if ($zmienna = 5) {
  # cokolwiek
} else {
  # inne cokolwiek
}

Oczywiscie efekt jasny - zawsze test zwroci wartosc prawda i wykona sie tylko pierwsza czesc - nigdy nie wykona sie kod w sekcji else.

Nieco magii - enigmatyczne zmienne
To jest to czego ludzie sie boja... bo zwyczajnie nie rozumieja co to jest. Nie wiem jak to wytlumaczyc prosto - postarajm sie, wiec jakby bylo dalej cos watpliwe to pytac.

Zmienne o ktorych bedziemy mowic to: $_, @_, @ARGV, $$ oraz cala kategoria innych (to zostawie do doczytania zainteresowanym - na razie nie bedziemy nic wiecej uzywac - w sumie niezbyt czesto sie innych uzywa z tego co wiem). To sa zmienne domyslne, ktorych sie nie deklaruje. Nie sa to zimienne srodowiskowe - powiedzmy ze cos podobnego. Cos jak 'runtime variables'.

for (1..9) { print };

To jest calutki kod - wysiwietli nam od cyfry od 1 do 9 - pytacie dlaczego?
Ten kod omzna tez zapisac jako:

foreach $_ (1..9) {
  print "$_";
}

$_ jest zmienna domyslna w wielu operacjach. Jesli na przyklad czytamy plik tekstowy (przyklady beda w nastepnych czesciach) to ta zmienne bedzie domyslna (jesli nie podamy jawnie innej zmiennej) ktora bedzie przechowywac wczytane linie.

Kolejna taka zmienna to @_, ktora jak widac jest tablica... a oto przyklad zastosowania:

iloczyn(5,4);
sub iloczyn {
  my $a = $_[0];
  my $b = $_[1];
  print "Iloczyn $a i $b wynosi ", $a*$b;
}

Jest to lista parametrow przekazanych do funkcji. Mozna tez zapisac ten sam kod jako:

sub iloczyn {
  my ($a,$b) = @_;
  #reszta kodu

Jesli jednak podamy 3 parametry i tak program przyjmie 2... a trzeci parametr zignoruje.

Dosc istotne jest to, ze zmiennej @_ nie mozemy nadpisac wewnatrz funkcji. To sa stale parametry. Jesli chcemy je zmienic musimy przypisac do zmiennych i pozniej mozemy zmienic wartosc zmiennej ktora stworzylismy. Zmienna @_ lub $_[numer] jest READ-ONLY!

c.d.n.

[TQM]

Kolejna wesola zmienna to @ARGV - zawiera ona parametry przekazane programowi w wierszu polecen. Oczywiscie w nazwach zmiennych sa rozrozniane duze i male litery, wiec @ARGV i @ARgV to inne sprawy (to drugie nie istnieje, chyba ze sami stworzymy).

Idac za ciosem iloczynu, nieco bardziej zaawansowany przyklad (zapisujemy kod w pliku iloczyn.pl):

$wynik=1;  # to chyba jasne dlaczego? mnozymy 1 * n, bo 0*n da zawsze 0
foreach (@ARGV) {
  $wynik *= $_;
}
print "Wynik = $wynik\n";

po czym uruchamiamy:

iloczyn.pl 2 3 4

Odpowiedz bedzie '24', jesli podamy 2 0 4 jako parametry to wynik bedzie oczywiscie 0 (niby co innego mialoby nam wyjsc?).

$ARGV[0] oznacza pierwszy parametr, itd... @ARGV jak kazda tablica jest numerowana od 0 w gore...

if ($#ARGV < 2) {
  die "Za malo parametrow, wymagane minimum 3!\n";
}

$#nazwa_tablicy zwraca numer ostatniego elementu tablicy. die() oznacza ze program ma zakonczyc dzialanie, zwracajac podany komunikat i ustawiajac kod powrotu > 0 (czyli blad). @ARGV jest rowniez tylko do odczytu.

Zmienna $$ to nic wiecej jak numer procesu w systemie. Przydaje sie czasami jesli chcemy stworzyc plik tymczasowy i nie chcemy aby 2 kopie programu sobie w droge wlazily... kiepskie zabezpieczenie ale na poczatek wystarcza.

die, print, warn, exit ?
print wyswietla dane na standardowe wyjscie (STDOUT) a warn na standardowe wyjscie dla bledow (STDERR). exit() konczy prace programu i jesli podamy kod powrotu to taki bedzi przekazany do systemu operacyjnego.

zakonczenie
Sadze ze na dzisiaj tyle wystarczy - pliki, operacje I/O omowimy pozniej. Przejdziemy tez nieco do regexow, ktore sa glowna sila napedowa wiekszosci tego co robie hihi.
Nie ukrywam ze problem bedzie z zadaniami praktycznymi, poniewaz ciezko mi wymyslic cos co bedzie dluzsze niz 5 linijek i nie wykorczy poza to co omowilismy. Bede sie staral ilustrowac wiec to co omawiam kodem a moze raczej omawiac kod...

Czekam na uwagi, pytania, itp

[Bouzer]

Mógłbyś jeszcze wspomnieć o tym jak zwrócić wartość procedury, czyli:

&nazwa_procedury

I że będzie zwrócona wtedy ostatnia wartość.

P.S. Bardzo mi się podoba kursik. I dosyć dużo informacji pojawiło się w ciągu dnia.

[TQM]

A wlasnie Dobra uwaga bouzer!

use strict;

my $zmienna1 = iloczyn(5,8,23);
print "Iloczyn 5, 8 i 23 to $zmienna1\n";
print "Iloczyn 7, 3 i 4 to ", iloczyn(5,8,23);

sub iloczyn {
  my $wynik = 1;
  foreach my $i (@_) {
    $wynik *= $i;     # rownoznaczne z $wynik = $wynik * $i;
  }
  return $wynik;
}

Jak widzicie nie uzywalem & przed nazwa funkcji - nie zawsze trzeba... ale piszac ten kod na kolanie popelnilem kilka bledow To co widzicie to juz kod czysty, dzialajacy...

Bledy znalazlem dzieki uzyciu strict oczywiscie - perl zwrocil blad... To co pogrubilem to to do czego strict sie przyczepil. Jesli usuniecie pogrubione fragmenty i sprobujecie odpalic kod to zobaczycie co sie stanie. Bez strict program pewnie ruszy ale nie zadziala tak jak trzeba.

strict to dobra sprawa... nawet sobie koszulke taka zrobie - use strict;


Oczywiscie funckja moze tez zwrocic tablice, hash, cokolwiek inne... albo modyfikowac przekazane do niej parametry globalne, tak jak w przykladzie gdzie wyswietlalismy $l - mozna te zmienna zmienic i tez bedzie ok.
Ogolnie piszac funkcje ktore cos wykonuja warto pomyslec o zwracaniu kodu powrotu albo czegokolwiek co mozna interpretowac w kontekscie boole'owskim - bedziemy wiedziec czy robota zostala wykonana czy nie.

Zwrocenie tablicy odbywa sie przez return @tablica albo return ($zmienna1, $zmianna2). Tak samo mozna zwrocic hash jesli ktos woli.

Jedyne co nas ogranicza to fantazja i to czy wiemy jak nasza fantazje zapisac...

[hedVB]

dobra przebrnąłem przez początek i spłodziłem super program który nie działa

use strict;
my $zmienna=0;

while ($zmienna<=10) {
	show
}

sub show {
	print "zmienna = $zmienna\n";
	$zmienna++;
}

Dopóki zmienna jest mniejsza niż 10 odwołuj do show ==> który wyświetla zmienna=wartość i podnosi wartość zmiennej na mój rozum a tu:

Bareword "show" not allowed while "strict subs" in use at hello.pl line 5.
Execution of hello.pl aborted due to compilation errors.

[Bouzer]

use strict;
my $zmienna=0;

while ($zmienna<=10) {
	&show
}

sub show {
	print "zmienna = $zmienna\n";
	$zmienna++;
}

Pogrubione to czego brakowało.

[TQM]

Dokladnie... po pierwsze po show powinien byc srednik Po drugie strict zbuntowal sie o nazwe funkcji. Mozna to wylaczyc - polecam http://search.cpan.org/~rgarcia/perl.../lib/strict.pm

Kod mozna tez zapisac tak jak nizej i bedzie dzialal bez problemow - najpierw funkcje, pozniej glowne cialo programu - liczy sie kolejnosc

use strict;
my $zmienna=0;

sub show {
	print "zmienna = $zmienna\n";
	$zmienna++;
}

while ($zmienna<=10) {
	show;
}

[Bouzer]

po pierwsze po show powinien byc srednik

Bez średnika też działa

[TQM]

Konstrukcje proste mozna zapisac bez...

while ($zmienna<=10) { show }

zazwyczaj daje sie srednik dla czytelnosci - ja na przyklad zawsze daje a w konstrukcji jak wyzej po zamknieciu klamry czyli { show };

Jak widzicie - TIMOTOWTDI (there is more than one way to do it)