Leer hier Perl

Zo ben ik weer... en zo blauw als een tientje twintigje...

Maar we gaan door met zoals ik beloofd had: assosiatieve lists/arrays... oftewel: hashes

We hebben leren werken met lists, dus we kunnen een stapje verder gaan....

Zoals jullie weten is de index naar een item in een list een getal.. dus je zegt 'het 0e element, of het 6e element' ... dit is heel handig... maar soms wil je niet op een element nummer zoeken, maar op een naam... hier zijn hashes handig voor...

Zoals gezegd identificeer je een hash door het % teken...

Hashes werken bijna hetzelfde als lists, alleen wanneer je nu een element wil hebben gebruik je { en} in plaats van [ en ]...

Dus stel ik wil het element 'ChOas' hebben uit de hash %UserId... zeg ik: $UserId{'ChOas'}

Bij een hash zijn er 2 dingen van belang, je hebt je sleutel (key) en je waarde (value)

Dus stel je voor dat ik mijn userId gekoppeld heb aan mijn naam zoals dit:

$UserId{'ChOas'}=693;

Dan is 'ChOas' de key, en 693 de value...

Voor een hash zijn er 2 belangrijke functies:

keys geeft een list terug met alle keys uit een hash...
values geeft een list terug met alle values uit een hash...

Let er op dat de keys uit een hash CAPS gevoelig zijn!!!

Laat ik even een voorbeeld geven aan de hand van de eerse 4 posters in dit topic:

---
#!/usr/bin/perl -w

use strict;

#Nieuwe hash variabele UserId:
my %UserId;

#Vul %UserId met een paar waarden:
$UserId{'ChOas'}=693;
$UserId{'hielkej'}=16933;
$UserId{'gieling'}=65516;
$UserId{'Wouta'}=72574;

#Wat zijn de sleutels, en wat zijn de waarden ? :
my @Sleutels=keys %UserId;
my @Waarden=values %UserId;

#En druk ze af:
print "Sleutels: @Sleutels\n";
print "Waarden: @Waarden\n";

#En nog een voorbeeldje:

my $Ik="ChOas";

print "Mijn naam is $Ik, mijn UserId is $UserId{$Ik}\n";
---

Dit geeft als output:

Sleutels: hielkej gieling Wouta ChOas
Waarden: 16933 65516 72574 693
Mijn naam is ChOas, mijn UserId is 693

In het volgende deel gaan we wat meer doen met hashes, waaronder loops over hashes, en wat meer... maar ik ben nu echt zo kachel als een kanarie...

Als ik straks nuchter ben volgt er nog een deel... zo niet, morgenochtend

[ Bericht 0% gewijzigd door ChOas op 05-06-2004 21:49:06 ]

quote:

Op zaterdag 5 juni 2004 17:54 schreef Cunt het volgende:

[..]

Ja mag... (doe maar klooncheck) ben niet thuis

Klopt, dat was ik

Oh, en ik wil toevoegen dat ik vereerd ben dat jullie hier een FAQ van willen maken

Zooooooooo... gaan we weer

(even off topic... ik denk "Vandaag schrijf ik eens wat op mijn PC i.p.v. op mijn Powerbook|" ... geen probleem dacht ik... gooi ik dat ding aan (met nieuwe videokaart) is dat klote dink een system restore ingegaan.. AL mijn patches kwijt, binnen 45 seconden had ik Blaster EN Sasser )

Maar we zijn weer helemaal hersteld, en we gaan verder met Hashes

Dit is een vrij korte les met alleen nog een voorbeeldje van hoe we hashes kunnen gebruikten... here goes:

---
#!/usr/bin/perl -w

use strict;

#Nieuwe hash variabele UserId:
my %UserId;

#Vul %UserId met een paar waarden, een Hash kan je eigenlijk zien als een list met daarin
# sleutel, waarde, sleutel, waarde, etc.
# Een andere manier om de Hash te vullen is dus:
%UserId=('ChOas',693,'hielkej',16933,'gieling',65516);

# We kunnen natuurlijk dan nog altijd zo nog een gebruiker toevoegen:
$UserId{'Wouta'}=72574;

#Wat zijn de sleutels, en wat zijn de waarden ? :
my @Sleutels=keys %UserId;
my @Waarden=values %UserId;

#We hebben gezien dat we met foreach over een lijst kunnen lopen, dat gaan we nu
#ook gebruiken om met behulp van de keys door de Hash te lopen:
my $Gebruiker;

foreach $Gebruiker (@Sleutels)
{
print "Manier 1: Gebruiker $Gebruiker heeft UserId: $UserId{$Gebruiker}\n";
};

#Even netjes een extra enter:
print "\n";
#En sterker nog, wanneer je dit soort vaker doet zal je het zo gaan schrijven:

foreach $Gebruiker (keys %UserId)
{
print "Manier 2: Gebruiker $Gebruiker heeft UserId: $UserId{$Gebruiker}\n";
};

#Even netjes een extra enter:
print "\n";

# En later zal ik laten zien dat het ook zo kan:
print "Manier 3: Gebruiker $_ heeft UserId: $UserId{$_}\n" for keys %UserId;

---

En de output van dit programma:

Manier 1: Gebruiker hielkej heeft UserId: 16933
Manier 1: Gebruiker gieling heeft UserId: 65516
Manier 1: Gebruiker Wouta heeft UserId: 72574
Manier 1: Gebruiker ChOas heeft UserId: 693

Manier 2: Gebruiker hielkej heeft UserId: 16933
Manier 2: Gebruiker gieling heeft UserId: 65516
Manier 2: Gebruiker Wouta heeft UserId: 72574
Manier 2: Gebruiker ChOas heeft UserId: 693

Manier 3: Gebruiker hielkej heeft UserId: 16933
Manier 3: Gebruiker gieling heeft UserId: 65516
Manier 3: Gebruiker Wouta heeft UserId: 72574
Manier 3: Gebruiker ChOas heeft UserId: 693

Nou, hopelijk maakt dit weer wat duidelijk...

Ik ga nu even iets verzinnen hoe ik het openen van bestanden ga uitleggen...

Volgende lessen:

Bestand openen om te lezen.

Bestand openen om te schrijven.

Perl weetjes zoals de 'jeweetwelvariabele' en wat meer manieren om dingen 'netter' te doen dan we tot nu toe geleerd hebben.

Subroutines

Reguliere expressies.

Praktijkvoorbeelden (Apache logfile parsen ofzo) (Jullie mogen ook vragen om specifieke voorbeelden.

CGI

nog veel meer leuks.

Nou, ik wou het er zo een beetje uit laten zien

Dus, ik ga nu even schrijven aan bestanden openen en die zal ik posten, daarna even met mijn
band spelen, en vanavond hoop ik nog aan bestanden openen om naar te schrijven toe te komen...

Tot zo

Bestanden openen zal je veel gebruiken, hier is de allereerste introductie over hoe je een bestand opent om te lezen.

Wat je doet is een speciale variabele 'Filedescriptor' verbinden aan een bestand op je harde schijf.

Het keyword wat we gebruiken om dit te doen is open

Wanneer we klaar zijn met een bestand gebruik je close om het bestand weer te sluiten.

open werkt als volgt:

open <Naam Filedescriptor>, <naam van de file welke je wil openen>

Wanneer Perl het bestand kan openen zal open een positief getal terug geven zo niet, geeft open '0'
terug. Dit kunnen we gebruiken om te zien of een bestand geopend kon worden of niet.

Bij het volgende voorbeeldje heb ik hier een tekstbestandje staan: "c:\lesx.txt" met daar in:
"Hallo dit is een test, en deze regel komt uit een bestand"

Eerst een voorbeeldje van het openen van een bestand wat niet bestaat:

---
#!/usr/bin/perl -w

use strict;

#Ik ga een nieuwe filedescriptor gebruiken welke ik INFILE noem (mag je zelf verzinnen)
#Eerst een voorbeeldje van wat er fout kan gaan:

my $FoutCode=0;

$FoutCode=open INFILE,'c:\lesy.txt';

if ($FoutCode==0)
{
#De foutcode is 0 dus er is iets fout gegaan.
print "Het bestandje c:\\lesy.txt is niet goed geopend!\n";

#Nou moet je weten dat wanneer er iets fout gaat bij het openen Perl ZELF in een speciale
#variabele aangeeft WAAROM het fout ging, deze variable is: $!
print "De reden waarom ik het bestand c:\\lesy.txt niet kon openen is: $!\n";

#We kunnen niet verder dus we verlaten het programma door middel van 'exit'
exit;
} else
{
# Foutcode is niet 0 dus alles is goed gegaan!!
print "Het bestand c:\\lesy.txt is goed geopend!\n";
};
---

En proberen:

Het bestandje c:\lesy.txt is niet goed geopend!
De reden waarom ik het bestand c:\lesy.txt niet kon openen is: No such file or directory


Nou... dat ging fout, maar we kunnen tenminste zien WAT er fout is gegaan.

Nu eens kijken wat er gebeurt wanneer het goed gaat, en we ook wat uit het bestand lezen:
Ik doe het iets anders, maar als jullie de vorige lessen hebben gevolgd zie je dat het best logisch
is, ik laat nu ook het commentaar bij het eerste stukje weg.

---
#!/usr/bin/perl -w

use strict;

#Ik ga een nieuwe filedescriptor gebruiken welke ik INFILE noem (mag je zelf verzinnen)

my $Bestand='c:\lesx.txt';
my $FoutCode=0;

$FoutCode=open INFILE,$Bestand;

if ($FoutCode==0)
{
print "Het bestandje $Bestand is niet goed geopend!\n";
print "De reden waarom ik het bestand $Bestand niet kon openen is: $!\n";
exit;
} else
{
# Foutcode is niet 0 dus alles is goed gegaan!!
print "Het bestand $Bestand is goed geopend!\n";

#Nu kunnen we wat met het geopende bestand gaan doen... weten jullie nog dat we input
#van de gebruiker inlazen met <STDIN> ? Nou, STDIN is eigenlijk ook een Filedescriptor maar
#dan van het toetsenbord, inlezen van een regel uit een bestand gaat dus bijna hetzelfde:
my $Regel=<INFILE>;

#Als het goed is staat nu de 1e regel van het Bestand in $Regel, even kijken:
print "De volgende regel is uit het bestand gelezen: $Regel\n";

#Kijk! dat zou er goed uit moeten zien... wanneer we nou de 2e regel willen lezen doen we gewoon weer
#$Regel=<INFILE>

#We zijn klaar met het bestand, dus nu moeten we het weer sluiten:

close INFILE;
};

---

We draaien het programma en zien:

Het bestand c:\lesx.txt is goed geopend!
De volgende regel is uit het bestand gelezen: Hallo dit is een test, en deze regel komt uit een bestand

HEEEEEEY... dat ziet er niet eens zo slecht uit!

Nou, ik hoop dat dit wat duidelijk maakt over het openen van bestanden... wanneer er vragen zijn aarzel dan alsjeblieft niet ze te stellen.

Ik ga even douchen en dan met mijn band oefenen, maar vanavond gaan we naar bestanden schrijven, en je zal zien dat dat net zo makkelijk is

Mea culpa...

Ben een beetje te vertiefd om nu de volgende les te schrijven, maar morgenochtend kan je `m in dit topic vinden...

Sorry...

GrtZ,

ChOas

Schrijven naar bestanden

Hier gaan we dan... schrijven naar bestanden... bijna hetzefde als lezen uit bestanden met het verschil dat je naar een bestand schrijft in plaat van er uit leest (Haaahhhahahahahahaha ).

We hebben gezien dat je naar het scherm print door middel van:

print "Hey, cool... dit staat op het scherm\n";

Nou komt dit doordat Perl aanneemt dat je naar de speciale filedescriptor STDOUT schrijft (net zoals de standaard input filedescriptor STDIN is)

Wat er eigenlijk staat is:

print STDOUT "Hey, cool... dit staat op het scherm\n";

Wanneer we nou een file door middel van open verbinden aan de filedescriptor UITFILE kunnen we naar dat bestand printen door dit te doen:

print UITFILE "Hey, cool... dit staat in een bestand!\n";

Eerst nog even een leugentje opbiechten, Ik vertelde dat je in Perl zo een bestand opent om te lezen:

open INFILE,"$Bestand";

Dit gaat goed omdat Perl aanneemt dat wanneer je een bestand opent dit doet om te lezen.

Netjes zou je dit zo schrijven:

open INFILE,"<$Bestand";

Het verschil is dus de '<'.

Dit zijn de manieren om een bestand te openen:

< Openen om te lezen

> Openen om te schrijven (truncate)

>> Openen om te schrijven (append)

Verschil tussen > en >> is dat bij > het bestand helemaal leeg wordt gemaakt, en je aan het begin begint met schrijven, en bij >> blijft alles in het bestand staan en voeg je dingen toe.

Nou... dat is de basis... laten we eens wat naar een bestand gaan schrijven:

---
#!/usr/bin/perl -w

use strict;


#Ik ga een nieuwe filedescriptor gebruiken welke ik UITFILE noem (mag je zelf verzinnen)

my $Bestand='uitvoerbestand.txt';
my $FoutCode=0;

$FoutCode=open UITFILE,">$Bestand";

if ($FoutCode==0)
{
print "Het bestandje $Bestand is niet goed geopend om te schrijven!\n";
print "De reden waarom ik het bestand $Bestand niet kon openen is: $!\n";
exit;
} else
{
print "Het bestand $Bestand is goed geopend!\n";

#Nou, nu maar wat naar het bestand schrijven...

print UITFILE "Nou, mijn naam is ChOas, en ik heb geen leven\n";
print UITFILE "Stiekum wel hoor, maar ik verveel me gewoon de tandjes nu \n";

print "Klaar met schrijven!\n";
#We zijn klaar met het bestand, dus nu moeten we het weer sluiten:

close UITFILE;
};
---

En nu uitvoeren:

choas:~ choas$ ./les7
Het bestand uitvoerbestand.txt is goed geopend!
Klaar met schrijven!

Dat is cool ... oh... wacht... heeft het ook gewerkt ? ... we hebben in iedergeval geen waarschuwingen of fouten gezien... even kijken:

choas:~ choas$ cat uitvoerbestand.txt
Nou, mijn naam is ChOas, en ik heb geen leven
Stiekum wel hoor, maar ik verveel me gewoon de tandjes nu
choas:~ choas$

Tadaaaaaaa Cool huh ?

Dat was het einde van dit deel.

Verder wil ik nog even zeggen dat ik er over heb na zitten denken om misschien later aan jullie te laten zien hoe je een IRC bot schrijft... komen we nog wel op...

In het volgende deel ga ik in op een paar eigenaardigheden van Perl die, wanneer je ze onder de knie hebt, alles wat makkelijker maken. In dat topic zal je ook meer kennis maken met mijn stijl van coden waardoor je de code in de latere delen (hopelijk) wat makkelijker leest.

Okay gaan we weer... vindt iedereen het nog leuk ? ... of tenminste 1 iemand ? ... dan ga ik hierna nog door...

Ongeacht dat: Perl weetjes

Ik ga hier wat extra dingen uitleggen over Perl en zal ook uitleggen wat mijn eigen stijl is.

if/else/unless

Ja, je leest het goed, unless. Unless doet eigenlijk precies het tegenovergestelde van een if...
zeg je bij een if 'doe dit als dit waar is' zeg je bij unless 'doe dit behalve wanneer dit waar is'.

Ik heb al uitgelegd dat je een if bijvoorbeeld zo gebruikt:

my $Number=4;
if ($Number>3)
{
print "$Number is groter dan 3\n";
};

Nou kan je bij Perl, wanneer er maar 1 statement binnen je if staat en je geen else gebruikt dit ook anders schrijven, ik doe dit ook altijd, dus bovenstaand vooorbeeld zou ik zo schrijven:

my $Number=4;
print "$Number is groter dan 3\n" if ($Number>3);


En hetzelfde kan je bereiken met unless:

my $Number=4;
print "$Number is groter dan 3\n" unless ($Number<=3);


Nou, dat is al een weetje.

Verder hebbben we nog de impliciete scalar $_ ... $_ is gewoon een variabele zoals je hem zelf ook zou kunnen aanmmaken, maar Perl zorgt ervoor dat $_ de waarde krijgt die je (meestal) verwacht...

Om duidelijk te maken wat ik bedoel zal ik aan behulp van een voorbeeld proberen te laten zien wat dit betekent. We gaan de getallen van 1 tm 10 printen uit een list.

my @Getal=(1,2,3,4,5,6,7,8,9,10);
my $Huidig;
for $Huidig (@Getal)
{
print $Huidig;
};

Nou, dit moet onderhand wel duidelijk zijn. je ziet dat Perl elke keer de waarde van het element uit @Getal aan huidig geeft... laten we nou $Huidig weg, dan zal Perl die waarde toekennen aan de speciale variabele $_, zoals dit:


my @Getal=(1,2,3,4,5,6,7,8,9,10);

for (@Getal)
{
print $_;
};

Je hebt al eerder gezien dat Perl wanneer je print aanneemt dat je naar STDOUT wil printen... nou we kunnen nog een stap verder. Perl neemt ook altijd aan dat wanneer je niets achter print zegt dat je $_ wil printen, we kunnen dit dus ook zo schrijven (Ik pas gelijk de list @Getal even aan) :


my @Getal=(1..10);
for (@Getal)
{
print;
};

Of zelfs (omdat er maar 1 statement in het for lusje zit):

my @Getal=(1..10);
print for (@Getal);

En dan kan je net zo goed dit schrijven:

print for (1..10);

Verder nog wat over bestanden inlezen.

Ik vertelde dat je een regel uit een bestand inleest door <FILEHANDLER>, maar stel nou dat ik de regels uit een bestand allemaal 1 vooor 1 wil bekijken ?

Dat doen we zo:

---
my $File="test.txt";

#Ik doe nog even geen fout afhandeling, we nemen gewoon aan dat het bestand goed geopend wordt.
open INPUT,"<$File";

#Dit wil zoveel zeggen als "Zolang er regels uit de filehandler gelezen kunnen worden"

while(<INPUT>)
{

#We hebben nergens gezegd naar welke variabele we inlezen dus Perl zal de regel in $_ stoppen.

#Afdrukken:

print "Regel gelezen: $_";
};

#Klaar met bestand:

close INPUT;
---

Nou, ik hoop dat hier vragen over komen , of in ieder geval dat jullie het nog volgen... dan gaan we volgende keer beginnen aan subroutines om structuur in ons programma aan te brengen. (Later hoor je ook nog meer over het openen van files, en foutafhandeling door middel van 'die', maar daar komen we nog op...

quote:

Op maandag 7 juni 2004 11:18 schreef bigben04 het volgende:
Moeten de for's in dit voorbeeld niet ook foreach's worden?
Verder, ga zo door in elk geval, ik heb zelf redelijk wat programmeerervaring maar heb nog nooit met perl gewerkt, dus ik vind dit zeker wel interessant.

Heel goed punt!!

Sorry dat is mijn fout. Ik had moeten vertellen dat 'for' en 'foreach' volledig hetzelfde zijn. In het begin zie je mensen vaker foreach gebruiken om over een list heen te lopen, en for in het geval van 'for ($i=0;$i<10;$i++)' loopjes... dat is op zich verstandig omdat je eigenlijk 2 verschillende dingen doet, for/foreach weet echter wat je in welk geval probeert te doen, ze zijn dus volledig uitwisselbaar...

Goed opgemerkt

Subroutines Deel 1: What goes in...

subroutines, de meeste programeer talen hebben ze wel, maar noemen ze misschien procedures, of functies. Doet er niet toe. een subroutine is een stukje code wat je 1 keer schrijf, maar daarna zo vaak als je wil kan gebruiken.

Dit is handig als je bijvoorbeeld een ingewikkelde berekening een aantal keer in je programma moet doen, of om standaard klusjes te doen zoals bestanden in een bepaald formaat inlezen, of data in een bepaald formaat wegschrijven.

zoals ik zei is een subroutine gewoon een stukje code, je definieerd een subroutine als volgt (typedef declaraties kom ik nog een keer op terug) :

sub <Subroutine naam>
{
<CODE>
};

Wanneer je dit gedaan hebt kan je overal in je programma die subroutine gebruiken.

Wat je meestal wil is data meegeven aan je subroutine om er wat mee te doen.

Perl geeft die data mee in een speciale list: @_ dus wanneer ik bijvoorbeeld een subroutine 'subroutX' aandroep met argumenten A B C gebeurt er dit:

Aanroep:
subroutX A,B,C;

En IN je subroutine vind je dan de lijst @_ met elementen A B en C.

Als kort voorbeeldje zal ik een 2 subroutines maken. De eerste berekent het kwadraat van een getal, en de 2e vermenigvuldigt 2 getallen.

Kijkt u mee ?

---

#!/usr/bin/perl -w

use strict;

# Bereken het kwadraat van een getal:
sub Kwadraat
{
#Weet je nog ? .. shift haalt het eerste element van een lijst af en geeft dit terug:
my $Getal=shift @_;

#Bereken het kwadraat:
my $Kwadraat=$Getal * $Getal;

# Druk het af:
print "Het kwadraat van $Getal is $Kwadraat\n";
};

# Vermenigvuldig 2 getallen met elkaar:
sub Vermenigvuldig
{
# @_ wordt als standaard lijst aangenomen, dus je hoeft hem niet te noemen:
my $Getal1=shift;
my $Getal2=shift;

# Vermenigvuldig:
my $Multi=$Getal1 * $Getal2;

# En druk af:
print "$Getal2 x $Getal1 = $Multi\n";
};

#Hier begint je echte programma:

Kwadraat 3;

Vermenigvuldig 6,5;

Kwadraat 5;

Kwadraat 2;

#Lijstje:
Kwadraat $_ for (6..10);

# Tafel van 3:
Vermenigvuldig 3,$_ for (1..10);

---

En de output:

choas:~ choas$ ./les7
Het kwadraat van 3 is 9
5 x 6 = 30
Het kwadraat van 5 is 25
Het kwadraat van 2 is 4
Het kwadraat van 6 is 36
Het kwadraat van 7 is 49
Het kwadraat van 8 is 64
Het kwadraat van 9 is 81
Het kwadraat van 10 is 100
1 x 3 = 3
2 x 3 = 6
3 x 3 = 9
4 x 3 = 12
5 x 3 = 15
6 x 3 = 18
7 x 3 = 21
8 x 3 = 24
9 x 3 = 27
10 x 3 = 30

Leuk he ?

Je kan ook subroutines IN subroutines gebruiken, kijk maar:

---
#!/usr/bin/perl -w

use strict;

sub Vermenigvuldig
{
my $Getal1=shift;
my $Getal2=shift;
my $Multi=$Getal1 * $Getal2;
print "$Getal2 x $Getal1 = $Multi\n";
};

sub Tafel
{
my $Tafel=shift;
print "De Tafel van $Tafel is:\n";
Vermenigvuldig $Tafel,$_ for (1..10);
};

Vermenigvuldig 8,7;

Tafel 10;

Tafel 5;

---

Output:

choas:~ choas$ ./les7
7 x 8 = 56
De Tafel van 10 is:
1 x 10 = 10
2 x 10 = 20
3 x 10 = 30
4 x 10 = 40
5 x 10 = 50
6 x 10 = 60
7 x 10 = 70
8 x 10 = 80
9 x 10 = 90
10 x 10 = 100
De Tafel van 5 is:
1 x 5 = 5
2 x 5 = 10
3 x 5 = 15
4 x 5 = 20
5 x 5 = 25
6 x 5 = 30
7 x 5 = 35
8 x 5 = 40
9 x 5 = 45
10 x 5 = 50

Tadaaaaaaaaaaaaa

Binnenkort deel 2 van subroutines: Subroutines Deel 2: ...must come out

Zoals beloofd: Subroutines Deel 2: ...must come out

(Valt zeker op dat ik een dagje vrij heb ? )

*** Wanneer je nog niet zo gewend bent met programeren is dit een pittige aflevering, laat het me weten als ik te snel ga ***

In het vorige deel hebben we gezien dat we heel makkelijk data aan een subroutine mee kunnen geven, maar zou het niet handig zijn als we ook weer data uit een sub terug kunnen krijgen ?

"Ja ChOas, dat lijkt ons heel handig "

Nou, mij ook, en dit kan ook makkelijk. Het duurde even voor ik een goed praktijk voorbeeld had gevonden, en dit voorbeeld is vrij uitgebreidt, maar je ziet hopelijk gelijk hoe handig dit is.

Ik heb een bestand op mijn schijf staan met daar in de volgende data:

choas:~ choas$ cat test.txt
1 een
2 twee
3 drie
4 vier
5 vijf
6 zes
7 zeven
8 acht
9 negen
0 nul
choas:~ choas$

We gaan een subroutine maken die deze data in kan lezen in een hash, en deze terug geeft aan het hoofdprogramma, we maken er ook een die de informatie uit de hash afdrukt.

---
#!/usr/bin/perl -w

use strict;

# Readfile, deze subroutine heeft 1 argument: De filenaam van het bestand wat ingelezen moet
# worden, het bestand wordt verondersteld in het waarde<spatie>sleutel formaat te zijn.
# Geeft terug: 1 wanneer er een fout optreedt bij het openen van het bestand, of 0 + De file in een
# hash structuur gelezen.
sub ReadFile
{
# Lees de meegegeven filenaam.
my $File=shift;
# Zet alvast de Hash klaar
my %Data;

# Iets nieuws: Hier zeg je tegen Perl : "open het bestand, gaat dit goed, ga door, gaat dit fout,
# geef het getal 1 terug.
open INFILE,"<$File" or return 1;
while (<INFILE>)
{
# Een voor een de regels splitten en de waarden uit de split in 2 losse variabelen stoppen
# (split werkt automatisch op $_ en split automatisch op spatie)
my ($Value,$Key)=split;

# Vul de hash met de data :
$Data{$Key}=$Value;
};
close INFILE;

# Alles wordt verondersteld goed gegaan te zijn, dus we geven 0 en de hash terug
# aan het hoofdprogramma
return (0,%Data);
};

# Subroutine om een hash af te drukken input: hash, output: niets.
sub PrintHash
{
# Ik heb verteld dat je een hash kan schrijven als een lijst met key,value,key,value.
# Dit betekent dat we de hele lijst die we mee hebben gekregen kunnen inlezen als hash
my %Data=@_;
print "$_ als getal is: $Data{$_}\n" for keys %Data;
};

# HOOFDPROGRAMMA

# We hebben gezien wat ReadFile teruggeeft dus we kunnen een scalar Error verwachten en
# een Hash welke we 'Data' noemen (Let wel, dit is een ANDERE Data dan uit de subroutine, ze
# bevatten wel dezelfde informatie, maar het zijn andere variabelen (dit heeft te maken met 'scope'
# hier kom ik nog wel een keer op terug).

my ($Error,%Data)=ReadFile 'test.txt';

# Is error ongelijk aan 0 ?
if ($Error)
{
print "Sorry, fout bij het openen van het bestand: $!\n";
} else
{
PrintHash %Data;
};


---

En de bijbehorende output:

choas:~ choas$ ./les8
negen als getal is: 9
zes als getal is: 6
vier als getal is: 4
acht als getal is: 8
drie als getal is: 3
nul als getal is: 0
vijf als getal is: 5
zeven als getal is: 7
twee als getal is: 2
een als getal is: 1
choas:~ choas$

Zo... dat was hem... zoals gezegd ben ik voor sommigen misschien een beetje te snel gegaan, laat het me dan alsjeblieft weten, dan probeer ik het met een simpeler voorbeeld, maar nu zie je gelijk hoe je dit echt in de praktijk ook kan gebruiken.

Ik zit nog even te denken wat ik voor de volgende keer zal doen, regexps of references... maar daar kom ik wel uit...

Volgende onderdeel is denk ik vanavond, ga nu ff lekker in de tuin zitten met een biertje