Peogramowanie w Perlu # 2

Dołączył: 12 Mar 2006

1. Co to sa tablice
2. Pierwsze kroki z tablicami.
3. Rozmiary tablic.
4. Dostep do elementow tablic i wywolywanie ich w programie.
5. Tablice asocjacyjne, co to jest?
6. Cechy tablic asocjacyjnych.
7. Roznica miedzy tablicami zwyklymi, a asocjacyjnymi.
8. Odwolania tablic + dwuwymiarowych tablic.
9. Odwolania tablic asocjacyjnych + dwuwymiarowych hashy.
10. Odwolania tablic hashy
11. Odwolania hashy tablic
12. Struktury danych.
a) Budowa tablicy tablic
b) Budowa hasha tablic
c) Budowa tablic hashy
d) Budowa hasha hashy
/--------------------------------------------------------------- --------/
1. CO TO SA TABLICE?
W Perlu mozna pogrupowac skalary pod postacia listy, jak i
tablic. Tak jak skalary zaczynaja sie od znaku '$', to tablice rozpoczyna
sie od '@'. Nazwa zmiennej tablicy moze byc taka sama jak skalara
i to nie zaszkodzi programowi. W dodatku piszac przed nazwa tablicy
"my" bedzie ona dzialac tylko w danej procedurze gdzie to napisalismy,
chyba ze piszemy kod bez procedur czy funkcji. Tablice jest to lista
skalarow, ktora przechowuje dane.
/--------------------------------------------------------------- --------/
2. PIERWSZE KROKI Z TALBICAMI!
Wartosci list zawsze ujmowane sa w nawiasach. Najprostsza lista
jest ta, ktora nie zawiera elementow, czyli jest bezelementowa. A oto
jej przyklad:
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my @tablica = ();

/--------------------------------------------------------------- --------/
Trzeba pamietac, ze kazdy nowy element w tablicy jest poprzedzony
przecinkiem, wykluczajac pierwszy element. W listach elementy
nie musza byc tylko ciagiem znakow. Moga tez byc cyfra, skalarem, etc.
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my @tablica = ("jeden", "dwa", "trzeci element", 4, "osiem", $skalar);

/--------------------------------------------------------------- --------/
Elementy listy mozna tez cytowac. Wykorzystujemy do tego funkcje
qw(). A oto przyklad:
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my @tablica = qw(jeden 123 643.34352);

/--------------------------------------------------------------- --------/
Funkcja qw() traktuje wszystki dane dokladnie jak zostaly wpisane, oraz
pomija spacje. Jednakze musimy pamietac gdy cytujemy tablice po danym
elemecie nie mozemy stawiac przecinkow. Aby utworzyc liste np.:
skladajaca sie z elementow od 5 do 20 piszemy nastepujaca:
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my @tablica = (5 .. 20);
my @tablica_dwa = ('a' .. 'z');

/--------------------------------------------------------------- --------/
Jak widac dwie kropki daja jakis przedzial. W tym wypdaku jest on od
5 do 20. Mozemy tez stosowac go w znakach alfabetu.
/--------------------------------------------------------------- --------/
3. ROZMIARY TABLIC!
Indeks pierwszy w tablicach jest pod postacja 0, a kazdy nastepny
o jeden wiekszy od niego. Jezeli mamy tablice skladajaca sie z 4
elementow to najwiekszy indeks bedzie mial wartosc 3. Najwiekszy
indeks w tablicach mozna pobrac wykorzystujac specjalna wartosc
$#tablica. Mozemy wiec napisac taki program:
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my @tablica = qw(Perl jest super szczerze wam to mowie);
print "Najwiekszy index w tabicy wynosi: ", $#tablica, "\n";

/--------------------------------------------------------------- --------/
Rozmiar tablicy mozna tez uzyskac przypisujac ja do skalara. Jednakze
w tej sytuacji rozmiar tablicy bedzie o jeden wiekszy od poprzedniego
sposobu wywolania. Jest to spowodowane tym, iz w pierwszym przykladzie
program liczy ilosc indexow, a wiemy ze one zaczynaja sie od wartosci
0, natomiast gdy bierzemy drugi sposob program liczy nam ilosc
elementow.

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my @tablica = ("jeden", "dwa", 8, "kolejny", "etc");
my $rozmiar_tablicy = @tablica;
print "Rozmiar tablicy wynosi: ", $rozmiar_tablicy, "\n";

/--------------------------------------------------------------- --------/
4. DOSTEP DO ELEMENTOW TABLIC I WYWOLYWANIE ICH
Jezeli mamy tablice skladajaca sie zaluzmy z 6 elementow,
to przed jej nazwa wyzucamy znak "@", a dodajemy '$', ale to nie koniec
po nazwie trzeba napisac ktory element chcemy wywolac, a to zapisujemy
w nawiasach kwadratowych. Prostym przykladem jest otoz ten program:
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my @tablica = ("tablica", "sklada", "sie", "z", 6, "elementow");
print $tablica[0], "\n"; # Wypisze tablica
print $tablica[2], "\n"; # Wypisze sie

/--------------------------------------------------------------- --------/
Aby wywolac cala tablice i jej wszystkie elementy nie piszemy
tak jak w skalarach print @tablica, "\n"; gdyz wypisze nam
wszystko w jednym ciagu. Najprostszym sposobem jakim to mozemy zrobic
jest wywolanie jej przez petle for. A odbywa sie to w nastepujacy sposob:
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my @tablica = qw(Roznica Perla nad ludzmi jest taka ze nigdy nie umrze);

for(my $i=0; $i<$#tablica; $i++) {
print $tablica[$i], "\n";
}

/--------------------------------------------------------------- --------/
Petla for bedzie trwac, az skalar $i dojdzie do wartosci maxymalnej
indexu listy. Jeszcze jedno w woli wyjasnienia. Skalar $i zaczynamy od
zera bo jak juz mowilem wartosc indexow tablicy zaczyna sie od 0.
I jeszcze jedno mozemy zapisac $tablica[$i], gdyz skalar $i ma wartosc
cyfrowa.
/--------------------------------------------------------------- --------/
5. TABLICE ASOCJACYJNE, CO TO JEST?
W tym rozdziale przedstawie zalety tablic asocjacyjnych (hashy).
Jak zauwazyliscie zwykle tablice mozemy jedynie wywolac pod postacia
wartosci indexow i jest to pewne nieudogodnienie, gdyz musimy wiedziec
co w ktorym indexie sie znajdoje. Oczywiscie mozna z tego jakos wybrnac
poprzez wyrazenia regularne, lecz zajmie to nam wiecej linijek kodu
niz poslugujac sie tablicami asocjacyjnymi. W hashu kazdy element
jest powiazany z kluczem, ktory jest w postaci wyrazu, frazy, etc.
Inaczej mowiac kluczem moze byc kazda wartosc skalarna.
/--------------------------------------------------------------- --------/
6. CECHY TABLIC ASOCJACYJNYCH!
Tak jak nazwy skalarow porzedzane sa '$', zwyklych tablic, '@', to
hashe tez maja swoj charakterystyczny znak na poczatku, a mianowicie
procent '%'. A taki jest schemat tworzenia tablic asocjacyjnych:
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my %hash = ("klucz pierwszy", "wartosc pierwsza",
"klucz drugie", "wartosc druga",
"klucz trzeci", "wartosc trzecia");

Jest jednak prostrzy i bardziej przejzystszy sposob na tworzenie hashy:

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my %hash = ("klucz pierwszy"=> "wartosc pierwsza",
"klucz drugi"=> "wartosc druga",
"klucz trzeci"=> "wartosc trzecia",
);

/--------------------------------------------------------------- --------/
Jest jeszcze jedna sprawa nazwe klucza nie trzeba pisac w cudzyslowiu
pod warunkiem ze nie jest to jakas fraza. Mozna wiec zapisac to w ten
sposob:

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my %hash = ("jeden"=> "wartosc pierwsza",
"dwa"=> "wartosc druga",
"trzy"=> "wartosc trzecia",
);

/--------------------------------------------------------------- --------/
Teraz przejdzmy do wywolywania hashy. Jak juz wspomnialem na wstepie
jest to zdecydowanie szybszy sposob, niz wywolywanie tablic.
Schemat wywolywania hashy wyglada nastepujaco:
print $hash{klucz}, "\n";
Napiszmy wiec program ktory wywola nam wartosc. Wartoscia hashy
bedzie wiek, a klucz bedzie w postaci imienia.
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my %hash = ( Michal=> 15,
Magda=> 17,
Mariusz=> 20);
print $hash{Mariusz}, "\n";# Wypisze 20
print $hash{Magda}, "\n";# Wypisze 17
print $hash{Michal}, "\n";# Wypisze 15

/--------------------------------------------------------------- --------/
Wbudowana funkcja w Perlu "keys" przyjmuje jako argumenty hashe,
a tworzy liste zawierajaca nazwy kluczy.
Powyzszy przyklad bedzie wygladac nastepujaco:
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl

use strict;
use warnings;

my %hash = ( Michal=> 15,
Magda=> 17,
Mariusz=> 20);
# Pobiera klucze
#
my @keys = keys %hash;
# Wypisze klucze
#
my $keys = @keys;
for(my $i=0; $i<$keys; $i++) {
print "Klucze: ", $keys[$i], "\n";
}

/--------------------------------------------------------------- --------/
7. ROZNICE MIEDZY TABLICAMI ZWYKLYMI, A ASOCJACYJNYMI
Po poznaniu czym sa listy, a czym hashe mozemy to spokojnie
podsumowac i wywnioskowac czego bedzie nam prosciej uzywac.
1) Zwykle tablice posiadaja elementy, ktore sa pewnymi skalarami, lecz
nie posiadaja kluczy, ktore umozliwiaja latwiejszy dostep.
2) Jednakze wywolanie calej tablicy, gdzie po kazdym elemencie
jest enter bedzie prostrze niz wywolanie calego hasha.
3) Tablice asocjacyjne sa bardziej przejzystsze od zwyklych tablic.
Znowusz jest to spowodowane tym, ze hashe posiadaja klucze, a nie
jedynie indexy.
Jest jeszcze wiele roznic pomiedzy hashami, a listami np.: w strukturach
danych, lecz to opisze w rodziale 10. Teraz wybor nalezy do was co
wybierzecie.
/--------------------------------------------------------------- --------/
8. ODWOLANIA TABLIC + DWUWYMIAROWYCH TABLIC
Pierwsza rzecza ktora musimy sobie wyjasnic jest zapytanie:
"Czym sa odwolania i jakie sa rodzaje?". Otoz napiszmy krotki przyklad,
ktorym bedziemy sie poslugiwac:

Kod:

my @tablica = ('asembler', 'c', 'c++', 'perl', 'php');

Jezeli teraz napiszemy $tablica[3] to wartosc jej bedzie "perl".
Oznacza to ze jedna zmienna ($tablica[3]) zawiera napis, ktory
jest druga zmienna (perl). Programisci w Perlu mowia na to, ze
jedna zmienna odwoluje sie do drugiej zmiennej. Taki typ odwolania
nazywa sie odwolaniem symbolicznym. Kolejnym rodzajem odwolania jest
odwolanie stale. To wlasnie z niego korzysta wiekszosc programistow
Perla. Nazywa sie je tak gdyz sa one trwale i naturalne. Odwolania
stale mozna przyrownac do dobrego administratora sieci, ktory nie
pozwoli wlamac sie byle komu, lecz odwolania symboliczne do "ladmina",
czyli administratora, ktory nie "opiekuje" sie siecia tylko popija
sobie kawke. Pokazalem jak wyglada odwolanie symboliczne, wiec teraz
pokaze zapis odwolania stalego.
/--------------------------------------------------------------- --------/

Kod:

$odwolanie_skalarne = $skalar;
$odwolanie_tablicy = @tablica;
$odwolanie_hasha = %hash;
$odwolanie_kodu = &kod;
$odwolanie_stalej = 5822453.43432;

/--------------------------------------------------------------- --------/
W powyzszych przykladach backslash poprostu tworzy kopie odwolania,
ktore jest przypisane do nazwy zmiennej. Jest jeden wyjatek od tego.
Mianowicie $odwolanie_stalej nie jest tworzone przez druga zmienna,
lecz przez ciag cyfr (wartosc).
/--------------------------------------------------------------- --------/
Kolejnym przykladem odwolan jest odwolanie do anonimowej tablicy.
Tak jak zwykle tablice tworzylo sie z '@' i nawiasy, to te tablice
tworzymy ze znakiem dolara na poczatku i nawiasty sa kwadratowe.

[cod2]
my $odwolanie_anon_tablicy = [1, 2, 3, ["cos", 8, "text"], "koniec"];
%>
Kod:

#!/usr/bin/perl
use strict;
use warnings;

my $odwolanie_anon_tablicy = [1, 2, 3, ["cos", 8, "text"], "koniec"];
print $odwolanie_anon_tablicy->[1], "\n";#Wyswietli 2
print $odwolanie_anon_tablicy->[3][2], "\n";#Wyswietli text

/--------------------------------------------------------------- --------/
Przy tego typu odwolaniach musicie ZAPAMIETAC, ze gdy chcecie wywolac
takiego rodzaju tablice musicie przed nawiasami dac strzalke.
Struktura tego wyglada nastepujaco:
print $odw_anon_tablicy->[pierwsza_wartosc][wartosc_tablicy_drugiej ]
/--------------------------------------------------------------- --------/
Wywolanie calego odwolania do tablicy:

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my $odwolanie_anon_tablicy = [1, 2, 3, ["cos", 8, "text"], "koniec"];

for(my $i=0;$i<5; $i++) {
if($i == 3) {
for(my $j=0; $j<3; $j++) {
print $odwolanie_anon_tablicy->[$i][$j], "\n";
}
}
print $odwolanie_anon_tablicy->[$i], "\n";
}

/--------------------------------------------------------------- --------/
Nie jest to taki super sposob sa lepsze ale na wstep moze byc.
Na tym narazie skonczymy odwolania do anonimowych tablic.
/--------------------------------------------------------------- --------/
9. ODWOLANIA TABLIC ASOCJACYJNYCH + DWUWYMIAROWYCH HASHY
Kolejne trzy dzialy liczac z tym beda bardzo krotkie, gdyz
system budowy odwolan anonimowych hashy czy tez innych struktur jest
bardzo podobny. Struktura odwolania do anonimowego hasha
wyglada nastepujaco:
/--------------------------------------------------------------- --------/

Kod:

my $odwolanie_hasha = {
"jeden*dwa"=> "dwa",
"dwa*dwa"=> "cztery",
"cztery*dwa"=> "osiem",
};

/--------------------------------------------------------------- --------/
Jak widac znowu zmienia sie poczatek, tym razem zamiast '%' jest
'$', a zamiast nawiasow okraglych sa nawiasy klamrowe.
Wywolanie jednej wartosci w odwolaniu do anonimowego hasha wyglada
podobnie jak w anoniomowej tablicy, z tym ze zamiast nawiasow
kwadratowych sa klamrowe. Piszac ciag dalszy do powyzszego przykladu
zakladamy, ze chcemy wywolac klucz o nazie "dwa*dwa". Robimy to
w nastepujacy sposob:
/--------------------------------------------------------------- --------/

Kod:

print $odwolanie_hasha->{"dwa*dwa"}, "\n";

/--------------------------------------------------------------- --------/
Warto tu zwrocic uwage na jedna rzecz. Mianowicie przy wywolaniu jak
i napisaniu nazwy klucza w tym wypadku nalezy dac cudzyslow, gdyz
w naziwe klucza jest znak "*".
/--------------------------------------------------------------- --------/
Mozna tez tworzyc odwolania do anonimowych hashy hashy, inaczej mowiac
dwuwymiarowych hashy. Tu tez nie ma duzej roznicy pomiedzy odwolaniami
od anonimowych (dwuwymiarowych) tablic. Struktura jest nastepujaca:

Kod:

my $odwolanie_hasha_hashy = {
"pierwszy"=> "czarny",
"drugi"=> "niebieski",
"trzeci"=> {
"ostatni" => "blekitny",
"srodkowy" => "zielony",
"pierszy z trzech" => "czerwony",
},
"czwarty"=> "zolty",
};

W tym odwolaniu stworzylem jakie kolory lubie najbardziej, tyle
ze mialem dylemat co wybrac na trzecie miejsce wiec postanowilem
posegregowac od ostaniego do pierwszego z tych trzech.
Teraz wyobrazmy sobie ze chcemy wyswietlic co jest na pierwszym miejscu
i co jest na trzecim miejscu jako pierwsze. Cod bedzie wygladac
nastepujaco:
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my $odwolanie_hasha_hashy = {
"pierwszy"=> "czarny",
"drugi"=> "niebieski",
"trzeci"=> {
"ostatni" => "blekitny",
"srodkowy" => "zielony",
"piewrszy z trzech" => "czerwony",
},
"czwarty"=> "zolty",
};

print $odwolanie_hasha_hashy->{pierwszy}, "\n";
print $odwolanie_hasha_hashy->{trzeci}{"pierwszy z trzech"}, "\n";

/--------------------------------------------------------------- --------/
W ponizszym przykladzie wywola nam na ekranie: czarny i czerwony.
/--------------------------------------------------------------- --------/
10. ODWOLANIA TABLIC HASHY
Ten typ jest poprostu polaczeniem dwuch poprzednich rozdzialow.
Wyobrazmy sobie taka sytuacje, ze mamy jakies cyfry
np.: -3, -2, -1, 0, 1 , 2 ,3. Teraz zrobimy tak pierwsze trzy elementy
beda normalnie napisane w tablicy, 0 i 1 damy do hasha i znowu przejdzie
do tablicy. Nastepnie wywolamy tylko 2index, z hasha zero i jeden
oraz 5 index.
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my $odw_tablicy_hasha = ["-3", "-2", "-1",
{
"zero" => 0,
"jeden" => 1,
},
"2", "3"];

print $odw_tablicy_hasha->[2], "\n";# Wypisze -1
print $odw_tablicy_hasha->[3]{zero}, "\n";# Wypisze 0
print $odw_tablicy_hasha->[3]{jeden}, "\n";# Wypisze 1
print $odw_tablicy_hasha->[5], "\n";# Wypisze 3

/--------------------------------------------------------------- --------/
Jak widac nie jest to zbyt skaplikowane, a dzieki temu mozemy robic wiele
ciekawych programow.
/--------------------------------------------------------------- --------/
11. ODWOLANIA HASHY TABLIC
Na logike bedzie robi sie to na odwrot jak w poprzednim rozdziale.
Pod wartosc (nie klucz) hasha wstawiamy tablice. Jest to kolejny
sposob przestawienia tabeli. Przykladowy program bedzie mial ilosc
pucharow i jakie miejsca zajalem.
Jeden puchar za 4 i 5 miejsce, dwa puchary za 1 i 3 miejsce, i cztery puchary za 2 miejsce.
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my $odw_hasha_tablic = {
jeden=> [4, 5],
dwa=> [1, 3],
cztery=> [2],
};
print $odw_hasha_tablic->{jeden}[1], "\n";# Wypisze 5
print $odw_hasha_tablic->{dwa}[0], "\n";# Wypisze 1
print $odw_hasha_tablic->{cztery}[0], "\n";# Wypisze 2

Mysle ze tutaj niczego nie trzeba tlumaczyc juz.
/--------------------------------------------------------------- --------/
12. STRUKTURY DANYCH
a) BUDOWA TABLICY TABLIC
Omowilismy juz budowy anonimowych tablic, hashy, etc. Teraz
omowimy budowe struktur danych (tablicy tablic). Istnieje wiele
struktur danych lecz ta jest najprostsza wiec od niej zaczniemy.
Nazwa tablice tablic wziela sie od tego, iz jest to dwuwymiarowa
tablica. Przypomnijcie sobie jak sie tworzylo pojedyncze tablice,
ta sie tak samo tworzy z tym, ze pewna wartosc indexu jest kolejna
tablica. Oto struktura tablicy tablic:

Kod:

@tablica_tablic = ( "wartosc_indexu0",
["tablica druga i wartosc indexu numer 0",
"tablica druga i wartosc indexu numer 1",
],
"wartosc_indexu2",
"wartosc_indexu3",
["tablica druga i wartosc indexu numer 0"],
);

Taka tablice wywoluje sie tak samo jak odwolanie do anonimowej
tablicy tablic wykluczajac strzalke. Czyli odbywa sie to tak:

Kod:

print $tablica_tablic[wartosc_indexu_1_tablicy][wart_indexu_2_tablicy] ;

Jezeli mamy juz stworzona powyzsza tablice tablic napiszmy zatem krotki
program.
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my @tablica_tablic = ( "wartosc_indexu0",
["tablica druga i wartosc indexu numer 0",
"tablica druga i wartosc indexu numer 1",
],
"wartosc_indexu2",
"wartosc_indexu3",
["tablica druga i wartosc indexu numer 0"],
);

print $tablica_tablic[0], "\n" # Wypisze wartosc_indexu0
print $tablica_tablic[1][1], "\n" # Wypisze tablica druga i wartosc
# indexu numer 1
print $tablica_tablic[3], "\n" # Wypisze wartosc_indexu3
print $tablica_tablic[4][0],"\n"; # Wypisze tablica druga i wartosc
# indexu numer 0

/--------------------------------------------------------------- --------/
Teraz stworzmy taka tablice ze w pierwszym elemencie tablicy
znajduje sie tablica z cyframi od 1 do 5, w drugim elemencie
tablica z cyframi od 6 do 10, natomiast w trzecim tablica z cyframi
od 11 do 15. Nastepnie program wywola nam wszystkie cyfry odzielone
przecinkiem i spacja. Bedzie to podobne do wywolywania wszystkich
elementow z pojedynczej tablicy z tym, ze beda nam tu potrzebne
dwie petle for.
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my @tab_tab = (
[1, 2, 3, 4, 5],
[6, 7, 8 ,9 ,10],
[11, 12, 13, 14, 15],
);

for my $i (0 .. 2) {
for my $j (0 .. 4) {
print $tab_tab[$i][$j], ", ";
}
print "\n";
}

/--------------------------------------------------------------- --------/
Program powinien wypisac nam
1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12, 13, 14, 15,
/--------------------------------------------------------------- --------/
W sumie nie jest to typowa petla for, oczywiscie mozna byloby napisac
for(my $i=0; $i<2; $i++), ale ja jestem zwolennikiem nie rozpisywania
programow i staram sobie ulatwic jak moge Wink

Teraz opowiedz na pytanie dlaczego potrzebne sa do tego dwie petle.
Jest to sprawa ze najpierw petla wchodzi w pierwszy element tablicy,
ale odczytuje, ze to jest kolejna tablica wiec znowu wchodzi do
drugiej tablicy i tam wyswietla jej 5elementow, nastepnie wychodzi
z niej i napotyka w drugim elemencie kolejna tablice i znowu
robi to samo wyswietla tam 5elementow i wychodzi z niej. Tak samo robi
z ostania tablica.
/--------------------------------------------------------------- --------/
Aby dowiedziec sie jakie dany wiersz ma indexy mozemy napisac tak:

Kod:

for my $wiersz (0 .. $#tab_tab) {
print "Wiersz: ", $wiersz, " zawiera ", @{$tab_tab[$wiersz]}, "\n";
}

Jednak przejzyscie bedzie w ten sposob dodajac wewnetrzna funkcje for

Kod:

for my $i (0 .. $#tab_tab) {
for my $j (0 .. @{$tab_tab[$i]}) {
print "Element $i $j ma wartosc $tab_tab[$i][$j]\n";
}
}

Tutaj jeszcze mozna by uzyc odwolania do tablicy, co by sprawilo,
ze kod bylby bardziej czytelny oraz prostszy.

Kod:

for my $i (0 .. $#tab_tab) {
my $wers = $tab_tab[$i];
for my $j (0 .. $#{$wers}) {
print "Element $i $j ma wartosc $wers->[$j]\n";
}
}

/--------------------------------------------------------------- --------/
Wszystkie te przyklady byly na tablicy ktora stworzylem wczesniej.
/--------------------------------------------------------------- --------/

b) BUDOWA HASHY TABLIC
Hashe tablic wykozystujemy gdy wiemy ze w przyszlosci
bedziemy wyszukiwac wartosci z indexu pod jakimisc kluczami.
Tym razem jest to polaczenie hasha, gdzie w kluczu tworzymy
tablice z jakimis elementami. Struktura tego wyglada nastepujaco:

my %hash_tab = (
klucz1 => ["element1", "element2", "element3"],
klucz2 => ["element1", "element2", "element3"],
klucz3 => ["element1", "element2", "element3"],
);

Wywolanie hasha tablic wyglada nastepujaco:

print $hash_tab{klucz}[wartosc_indexu], "\n";

Dla przykladu napiszemy program, gdzie w kluczach sa firmy produkujace
auta, a jako wartosci indexow beda marki aut.
I po naszym wpisaniu firmy pokaza nam sie wszystkie marki
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my %hash_tab = (
peugeot=> [106, 205, 206, 607],
toyota=> ["Yaris", "Celica", "Corola" "Avansis"],
porshe=> ["Cayman", "Carrera 911S", "Carrera Sport", "Carrera IV"],
);

chomp(my $company = <STDIN>);

for $i (0 .. 3) {
print $hash_tab{$company}[$i], ", "
}
print "\n";

/--------------------------------------------------------------- --------/
Na wywolanie danej firmy jest tez jeszcze jeden sposob moze wydawac
sie bardziej skomplikowany ale nie trzeba wpisywac w for ile
marek aut jest w tablicy.

Kod:

for my $i ( 0 .. $#{$hash_tab{$company}}) {
print "$hash_tab{$company}[$i]\n";
}

$#{$hash_tab{$company}} - znajduje maxymalna wartosc indexu w tablicy.
/--------------------------------------------------------------- --------/
Aby dodac jakis element wystarczy napisac:

Kod:

$ht{ford} = ["focus", "mondeo", "probe"];

/--------------------------------------------------------------- --------/
Jezeli chcemy wyswietlic calego hasha tablic w dodatku posortowanego
alfabetycznie trzeba przyjac w petli for ze $company
jest to firma a $i jest to kolejny index tablicy. Fraza, ktora pojawi
sie w pierwszej petli for, mianowicie sort keys %hash_tab oznacza
posortowanie kluczy wedlug alfabetu. W drugiej petli
pojawi sie 0 .. $#{ $hash_tab{$company}} co jak juz wyzej wposminalem
ustali maxymalna wartosc indexu w danej tablicy $company.
A oto caly program:
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my %hash_tab = (
peugeot=> [106, 205, 206, 607],
toyota=> ["Yaris", "Celica", "Corola" "Avansis"],
porshe=> ["Cayman", "Carrera 911S", "Carrera Sport", "Carrera IV"],
);

for my $company ( sort keys %hash_tab ) {
for my $i ( 0 .. $#{ $hash_tab{$company} }) {
print $company, " ma nastepujace auta:\n", $hash_tab{$company}[$i], "\n";
}
}

/--------------------------------------------------------------- --------/
c) TABLICE HASHY
Tablice hashy sa przydatne tylko wtedy gdy masz do czynienia
z wieloma rekordami, a w nich sa zapisane klucze z wartosciami.
Ten sposob jest najzadziej uzywany przez programistow. Jednakze
warto go omowic i znac. Niechcac sie powtarzac odrazu pokaze budowe
tablic hashy i dam przyklad.

Kod:

@tab_hashy = (
{
klucz1 => "wartosc1",
klucz2 => "wartosc2",
},
{
klucz3 => "wartosc3",
klucz4 => "wartosc4",
klucz5 => "wartosc5",
},
);

/--------------------------------------------------------------- --------/
Przykladem na to moze byc kilka rodzin gdzie jest podany wiek
meza, zony i dziecka

Kod:

my @tab_hashy = (
{
maz=> 40,
zona=> 37,
dziecko => 16,
},
{
maz=> 35,
zona=> 35,
dziecko => 10,
},
{
maz=> 30,
zona=> 28,
dziecko => 5,
},
);

/--------------------------------------------------------------- --------/
Aby dodac jescze jeden hash do tablicy uzyjemy wbudowanej funkcji push.
push @tab_hashy, { maz => 25, zona => 24, dziecko => 0 };
/--------------------------------------------------------------- --------/
Jezeli chcemy wyswietlic jedna element tablicy, i jeden klucz z hasha
wystarczy napisac:

Kod:

print $tab_hashy[wartosc_indexu]{klucz}, "\n";

/--------------------------------------------------------------- --------/
Jednak my chcemy wszystko wyswietlic wiec do powyzszego przykladu piszemy

Kod:

for $href (@tab_hashy) {
print "{\n";
for $stanowisko ( sort keys %$href ) {
print "$stanowisko=$href->{$stanowisko}\n";
}
print "} \n";
}

/--------------------------------------------------------------- --------/
d) HASHE HASHY
Wielowymiarowy hash jest najbardziej elastyczny ze wszystkich
struktur w Perlu. Jeden klucz odpowiada innym klucza ktore maja wartosc.
Na kazdym poziomie indexem hasha jest napis. A oto budowa hasha hashy.

Kod:

my %hash_hashy = (
klucz1 => {
klucz1a => "wartosc1",
klucz1b => "wartosc2",
klucz1c => "wartosc3",
},
klucz2 => {
klucz2a => "wartosc4",
klucz2b => "wartosc5",
klucz2c => "wartosc6",
},
);

Przykladowy program na to moze byc rodzaju:
pierwszy klucz to rodzaj rasy psow, kolejny klucz przypisany
do rodzaju rasy to rasa psa, a wartosc jego to dlugosc wlosa w jakim dana
rasa moze wystepowac.
/--------------------------------------------------------------- --------/

Kod:

my %hash_hashy = (
pasterskie => {
"owczarek niemiecki"=> "krotkowlosy",
"owczarek kaukaski"=> "dlugowlosy",
"owczarek nizinny"=> "sredniowlosy",
},
teriery => {
"pit bull"=> "krotkowlosy",
"bull terrier"=> "krotkowlosy",
"amstaff"=> "krotkowlosy",
},
);
print $hash_hashy{pasterskie}{"owczarek kaukaski"}, "\n";
print $hash_hashy{teriery}{"pit bull"}, "\n";

W ponizszym kodzie wypisze nam dlugowlosy i krotkowlosy.
/--------------------------------------------------------------- --------/
Aby dodac hasha hashy wystarczy wpisac:

Kod:

$hash_hashy{klucz1} => {
klucz1a => "wartosc1",
klucz1b => "wartosc2",
}

/--------------------------------------------------------------- --------/
W celu wyswietlenia wszystkich hashy hashy trzeba stworzyc dwie
petle for (pod warunkiem ze jest to dwuwymiarowy hash).
W pierwszej for $typ_rasy ( sort keys %hash_hashy ) przypisze do
skalara $typ_rasy jeden klucz i zacznie go przeszukiwac. Po wyjsciu
wejdzie jeszcze raz i tak do skonczenia petli.
Natomiast w drugiej:

Kod:

for $rasa ( sort keys %{ $hash_hashy{$typ_rasy}}) wchodzi do

wewnetrznego hasha i przeszukuje go.
Caly program bedzie wygladac nastepujaca:
/--------------------------------------------------------------- --------/

Kod:

#!/usr/bin/perl
use strict;
use warnings;

my %hash_hashy = (
pasterskie => {
"owczarek niemiecki"=> "krotkowlosy",
"owczarek kaukaski"=> "dlugowlosy",
"owczarek nizinny"=> "sredniowlosy",
},
teriery => {
"pit bull"=> "krotkowlosy",
"bull terrier"=> "krotkowlosy",
"amstaff"=> "krotkowlosy",
},
);

for my $typ_rasy ( sort keys %hash_hashy ) {
print "$typ_rasy = ";
for my $rasa (sort keys %{ $hash_hashy{$typ_rasy}}) {
print "$rasa=$hash_hashy{$typ_rasy}{$rasa}\n";
}
}

/--------------------------------------------------------------- --------/
I to by bylo na tyle w tym kursie. Niedlugo zaczne pisac nowy
jesli czas pozwoli. Pozdro

o kurcze ale sie napisales

Dołączył: 12 Mar 2006

no ale morzesz sie dużo dowiedzieć!

no kolejnae arcydzielo pikaso

to dobrze ze hoc jedna osoba to czyta

Dołączył: 12 Mar 2006

kur** zem sie teraz wnerwił !

[link widoczny dla zalogowanych]

Dołączył: 17 Mar 2007

Only new videos!
[link widoczny dla zalogowanych]