Leer hier Perl

Perl Tutorial:

Ik zit ziek thuis en verveel me dus ik ga jullie ook maar vervelen...

Perl is een leuke programeertaal en makkelijk om te leren...

Wanneer Je een unix variant gebruikt staat Perl hoogst waarschijnlijk op je systeem. Wanneer je een MS product gebruikt kan je hier Perl downloaden: http://www.activestate.com/Products/ActivePerl/?_x=1

PHP lijkt een beetje op Perl, met nadruk op 'lijkt'.

Hier de eerste stappen, wanneer iemand meer wil horen/leren laat het dan weten.

Ik neem aan dat waneer je dit leest je een beetje kan programeren, maar zo niet, geen nood, ik hou het in het begin simpel...

Datacontainers:

Perl heeft 3 datacontainers (iets waar je informatie in kan stoppen)

Scalars, aangeduid door een $ <- Hier stop je bijvoorbeeld zinnen of getallen in.

Lists, aangeduid door een @ <- Hier kan je een lijst van dingen scalars instoppen.

Hashes, aangeduid door een % <- Dit is een associatieve lijst, dit leg ik later nog wel uit (als er ooit iemand geinteresseerd is).

Input, Output:

zoals ik zei, in het begin houden we het simpel, output schrijf je naar het scherm doormiddel van print.

Input krijg je van de gebruiker (uitgaande van een toetsenbord in het begin) door <STDIN>.

Regels sluit je af door middel van een ;

Ons eerste programma:

We schrijven een programma wat aan de gebruiker vraagt hoe oud hij/zij is, en dit dan weer afdrukt.

Een Perl programma bestaat uit een text bestand wat geinterpreteerd wordt door Perl...

DE manier om netjes je bestand te beginnen is (buiten dat Perl misschien bij jou op een andere locatie staat) als volgt:

#!/usr/bin/perl -w

use strict;

De -w geeft aan dat je waarschuwingen van Perl wil hebben wanneer er iets fout dreigt te gaan, en 'use strict' geeft aan dat je een standaard module van Perl wil gebruiken welke je helpt fouten sneller op te sporen (Voor de Perlgoden: Ja, ik weet dat het strict namespace, en etc. is, maar ik leg het even zo uit).

Nog even iets... wanneer je in Perl een container wil gebruiken dan zeg je van tevoren tegen Perl dat je WEET dat je die container gaat gebruiken, dit doe je door middel van 'my' ... dus met 'my $Getal;' zeg je tegen Perl, ik ga een Scalar container gebruiken die 'Getal' heet.

Het eerste simpele programma:

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

use strict;

#Maak container leeftijd aan:
my $Leeftijd;

#netjes om je leeftijd vragen:
print "Voer hier je leeftijd in >";

#Leeftijd van de gebruiker inlezen:
$Leeftijd=<STDIN>;

#Antwoord ('\n' betekent 'enter') :
print "Je bent $Leeftijd jaar oud!\n";
---

Wanneer ik dit in een textbestandje 'leeftijd' opsla, en dit uitvoer krijg je dit:

ChOas-Powerbook:~ choas$ ./leeftijd
Voer hier je leeftijd in >28
Je bent 28
jaar oud!
ChOas-Powerbook:~ choas$

Hum.. ziet er bijna goed uit... wat er gebeurt is dat Perl de enter die je intikte toen je je leeftijd invoerde OOK in 'Leeftijd' stopte.

Om een enter van een Scalar af te halen gebruiken we 'chomp'.

Laten we het eens proberen:

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

use strict;

#Maak container leeftijd aan:
my $Leeftijd;

#netjes om je leeftijd vragen:
print "Voer hier je leeftijd in >";

#Leeftijd van de gebruiker inlezen:
$Leeftijd=<STDIN>;

#haal de enter van leeftijd af:
chomp $Leeftijd;

#Antwoord ('\n' betekent 'enter') :
print "Je bent $Leeftijd jaar oud!\n";

---
En het resultaat:

ChOas-Powerbook:~ choas$ ./leeftijd
Voer hier je leeftijd in >27
Je bent 27 jaar oud!
ChOas-Powerbook:~ choas$


Dus... heeft dit zin gehad, of gaan we gelijk naar complexe datastructuren, OO Perl, logs en webpagina's parsen ?... of vind niemand er ene fuck aan ?

In andere woorden: te snel/te langzaam/geen fuck aan ?

[ Bericht 1% gewijzigd door ChOas op 04-06-2004 17:22:13 ]

Nou... positieve reacties tot nu toe, en ik heb geen leven dus deel 2...

Lists

Lists/arrays, eigenlijk hetzelfde ... zoals al uitgelegd is een list een container waar
je scalars in kan stoppen... ik zal nu lists uitleggen en de functie 'split'.

Een simpel programma

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

use strict;

#Scalar container Zinnetje, hier ga ik een zin in stoppen.
my $Zinnetje;

#We vullen zinnetje met iets nuttigs (let wel, quotjes horen erbij)
$Zinnetje="Mijn naam is ChaOs";

#Kijken hoe dat er uit ziet:
print "$Zinnetje\n";
---

Resultaat:

ChOas-Powerbook:~ choas$ ./les2
Mijn naam is ChaOs
ChOas-Powerbook:~ choas$

Perfect!!!... Eeeerm.. nee... wacht eens even... mijn nick is ChOas... foutje...
De zin aanpassen is natuurlijk TE makkelijk, dus we doen het anders

split: split gebruik je om een scalar in stukjes te hakken, en die stukjes kan je
dan weer in een list plaatsen... je gebruikt split zo:

split <waar knip je>,<scalar die je wil verknippen> (<- Voor de Perlgoden, ik weet dat er nog een 3e argument is, maar laten we simpel beginnen)

Nog even iets over lists... ik heb verteld dat een list aangegeven wordt door een @
Nou zijn de ELEMENTEN van een list Scalars, en die geven we aan met een $

Heel belangrijk trouwens, zoals in de meeste computertalen begin je ook bij Perl je lists
te indexeren bij 0... dus het 1e element is 0, het 2e=1, 3e 2, etc...

Stel nou dat ik het 2e element wil hebben uit de list '@Lijst' spreek ik die zo aan: $Lijst[1]

Verward ? ... een voorbeeld:

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

use strict;

#Scalar container Zinnetje, hier ga ik een zin in stoppen.
my $Zinnetje;

#We vullen zinnetje met iets nuttigs (let wel, quotjes horen erbij)
$Zinnetje="Mijn naam is ChaOs";

#List container Woord, hier zetten we de woorden uit de zin in:
my @Woord;

#En nu de split... een zin bestaat uit woorden gescheiden door
#spaties... we gaan dus splitten op spatie:
@Woord=split " ",$Zinnetje;

#Even kijken wat het 2e woord is:
print "Het tweede woord is: $Woord[1]\n";
---
Output:

ChOas-Powerbook:~ choas$ ./les2
Het tweede woord is: naam
ChOas-Powerbook:~ choas$

Hey... dat ziet er nog logisch uit ook!... het 2e woord is inderdaad 'naam'!!

Nou moet je weten dat wanneer je een list tussen quotjes print Perl ZELF spaties tussen
de Elementen zet... dus nu gaan we de zin even GOED in elkaar zetten:

#!/usr/bin/perl -w

use strict;

#Scalar container Zinnetje, hier ga ik een zin in stoppen.
my $Zinnetje;

#We vullen zinnetje met iets nuttigs (let wel, quotjes horen erbij)
$Zinnetje="Mijn naam is ChaOs";

#List container Woord, hier zetten we de woorden uit de zin in:
my @Woord;

#En nu de split... een zin bestaat uit woorden gescheiden door
#spaties... we gaan dus splitten op spatie:
@Woord=split " ",$Zinnetje;

#Even kijken wat de zin nu is:
print "De zin: @Woord\n";

#En nu eventjes de zin herstellen want mijn naam is ChOas, mijn naam
#is het 4e woord dus:
$Woord[3]="ChOas";

#Is het gelukt ?
print "Wat is je naam? : @Woord\n";

Kijken wat dat doet:

ChOas-Powerbook:~ choas$ ./les2
De zin: Mijn naam is ChaOs
Wat is je naam? : Mijn naam is ChOas
ChOas-Powerbook:~ choas$

Kijkerdekijk!!!... dat werkt!!!! ... experimenteer er rustig mee op los, en bij meer positieve reacties ga ik gewoon door

Vragen stellen mag altijd... ben je nou een Perlgod met een vraag kan je die ook altijd stellen en ik zal kijken of ik kan helpen

quote:

Op vrijdag 4 juni 2004 21:36 schreef Repelsteel het volgende:
Goed initiatief ChOas! Perl verdient zeker wat meer aandacht!

Een kleine toevoeging; vergeet niet de -w parameter te verwijderen als je script eenmaal draait.
Mochten er namelijk voor de perl-compiler onlogische stukjes code voorkomen dan geeft hij hier een 'warning' op, terwijl dit eigenlijk helemaal niet onlogisch is. Dit voorkomt mega-grote logfiles.

Wat daarnaast misschien interessant is als kleine toevoeging is het webgeschikt maken van perl-scripts. Met slechts enkele toevoegingen / wijzigingen kun je je scripts online gebruiken en maakt dat perl meteen een stuk interessanter dan puur 'stand-alone-scripts'.

Dus mocht je nog ziek zijn dan hoor ik graag meer over webscripts! Of anders wil ik ook wel een stukje bijdragen aan dit topic. Beterschap!

Thanks Repelsteel!

Perl/CGI kom ik ook zeker nog op... maar eerst even de basis coveren

En daarom... volgt over 30 minuten ofzo (even wat verzinnen) Les 3: ifs, elses, whiles en fors...

Okay...

we kunnen inlezen, we kunnen printen, nu een beetje wiskunde, daarna wat meer over lists in het algemeen en DAARNA hashes... we hebben nog wat lessen te gaan

Basis

< is kleiner dan
> is groter dan
== is gelijk aan
<= is kleiner of gelijk aan
>= is groter of gelijk aan

Nou heb ik in de vorige delen verteld dat je Perl verteld dat je een container (ik ga vanaf nu het woord variabele gebruiken) gaat gebruiken en daarna er pas een waarde er aan geeft dus:

my $Zin;
$Zin="Oh wat een last";

Dit is prima, maar wanneer je meer en meer code schrijft kan je het ook in 1 keer doen:

my $Zin="Oh wat een last";

Is wat makkelijker... dit gaan we vanaf nu gebruiken....

Allereerst... de if ... met een if statement kijk je of iets aan een voorwaarde voldoet, en wanneer dat waar is onderneem je een actie, is dit niet waar onderneem je een andere actie door middel van else. De dingen die je onderneemt bij een van de opties omring je door { en }... voorbeeld:

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

use strict;

my $Number=5;

if ($Number>4)
{
print "$Number is groter dan 4";
} else
{
print "$Number is kleiner dan 4";
}
---

Wanneer je dit programma draait zie je inderdaad 5 is groter dan 4

Verder kunnen we variabelen ophogen, en verlagen dus wanneer we $Number met 6 willen ophogen doen we:

$Number= $Number + 6;

Wannneer we met maar 1 ophogen kunnen we ook schrijven:

$Number++

Wat betekent: Hoog $Number 1 op....

Laten we eens tot 10 gaan tellen

while betekent 'zolang' en je programma zal na een while de code uitvoeren zolang het argument waar is.

Voorbeeld:

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

use strict;

#Nieuwe variabele nummer begint als 1
my $Number=1;

#Zolang nummer kleiner is dan 11 doe het volgende:
while($Number<11)

{
#Print het nummer
print "Nummer = $Number\n";

#Hoog het nummer met 1 op
$Number++;
};

Ook hier geef je weer met { en } aan om welke code het gaat bij je voorwaarde.

De output:

choas:~ choas$ ./les3
Nummer = 1
Nummer = 2
Nummer = 3
Nummer = 4
Nummer = 5
Nummer = 6
Nummer = 7
Nummer = 8
Nummer = 9
Nummer = 10
choas:~ choas$

Dat WERKT!!!! Cooooooooool!!!!

if gehad, while gehad, dan krijgen we nu een 'for'... dit combineert eigenlijk beide...

bij for gebruik je 3 dingen: waar start ik ? ... Is het nog waar ? ... en nu ?

Hopelijk maakt het volgende voorbeeld dit duidelijk:

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

use strict;

#Hier maken we number 15, maar dat maakt niets uit, zie volgend stukje
my $Number=15;

#Hier gebeurt het, wat hier staat is eigenlijk: Number=1, is Number kleiner dan 11 ?
#zo ja: voer code uit en hoog Number op, zo niet.. je bent klaar
for ($Number=1;$Number<11;$Number++)
{
print "Nummer = $Number\n";
};
---

Wanneer je dit voorbeeld uitvoert krijg je weer netjes het lijstje van 1 tm 10....

Hopelijk maakt dit iets duidelijk over ifs, elses, whiles, en fors.... mocht het niet duidelijk zijn laat het me dan gewoon weten (durf je het niet hier te vragen kan je me gewoon op MSN toevoegen (xchoasx@hotmail.com))

Experimenteer ermee tot je er lekker mee om kan gaan, deze functies vormen de kern van bijna elk programma...

Gaan we weer

Nog een lesje over lists

Vorige keer heb je gezien dat je een list kan vullen door middel van split, er zijn echter nog veel meer manieren:

my @Fruit=('Appel','Peer','Banaan','Kiwi');

Kijk!... dat was makkelijk... Let op de woorden moeten wel tussen quotjes staan... (bij getallen hoeft dit niet, maar daar komen we nog op).

We hebben nu een lijst met daarin 4 verschillende vruchten...

Kunnen we die afdrukken ? Tuurlijk:

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

use strict;

#Nieuwe list Fruit
my @Fruit=('Appel','Peer','Banaan','Kiwi');

#Druk af
print "Dit is fruit: @Fruit\n";
---

Output (hopelijk zoals jullie al verwachtte):

choas:~ choas$ ./les4
Dit is fruit: Appel Peer Banaan Kiwi
choas:~ choas$

Nou, ziet er leuk uit, maar laten we eens de vorige lessen met deze combineren en dit op een
iets andere manier schrijven.

We gaan op elke regel een ander vrucht afdrukken.

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

use strict;

#Nieuwe list Fruit
my @Fruit=('Appel','Peer','Banaan','Kiwi');

#nieuwe scalar Index
my $Index;

#We gaan nu Index gebruiken om telkens een ander element uit de
#lijst aan te wijzen... met $Lijst[0] wijzen we zoals we eerder gezien
#hebben naar het 1e element.
#Wanneer we Index nou van 0 tot 3 laten lopen en telkens dat element
#afdrukken gebeurt het volgende:

for($Index=0;$Index<4;$Index++)
{
print "Dit is fruit: $Fruit[$Index]\n";
};
---

En kijken wat er gebeurt:

choas:~ choas$ ./les4
Dit is fruit: Appel
Dit is fruit: Peer
Dit is fruit: Banaan
Dit is fruit: Kiwi
choas:~ choas$

Werkt netjes toch ?

Een stapje verder: foreach

Het vorige voorbeeld werkte prima, maar het kan makkelijker en duidelijker...

Foreach betekent 'voor elke' ... we gaan dit gebruiken om de lijst nogmaals af te drukken, maar
nu eenvoudiger:

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

use strict;

#Nieuwe list Fruit
my @Fruit=('Appel','Peer','Banaan','Kiwi');

#nieuwe scalar Vrucht
my $Vrucht;

# Hier gebeurt het, we zeggen eigenlijk: 'voor elke Vrucht uit de lijst Fruit, doe het volgende:'
# (Perl zal alle elementen uit de lijst Fruit aflopen, ze per keer aan $Vrucht toewijzen, en dan
# het loopje ingaan)

foreach $Vrucht (@Fruit)
{
#$Vrucht is nu de naam van het element uit Fruit waar we naar kijken:
print "Dit is fruit: $Vrucht\n";
};
---

Even proberen:

choas:~ choas$ ./les4
Dit is fruit: Appel
Dit is fruit: Peer
Dit is fruit: Banaan
Dit is fruit: Kiwi
choas:~ choas$

Netjes, en naar mijn mening duidelijker dan doormiddel van de for loop....

Is het allemaal nog te volgen ? ... dan gaan we volgende keer verder met NOG MEER lists (sorry, maar er zijn heel veel mogelijkheden mee, en wanneer je redelijk (makkelijk) wil programmeren zul je er toch een aantal moeten weten...

Daarna 1 of 2 lessen over hashes
en dan gaan we het leuker maken met schrijven naar, en lezen uit bestanden

quote:

Op zaterdag 5 juni 2004 08:41 schreef Hiawatha het volgende:
Als voorproefje van wat er jullie te wachten staat, een DVD-decoder in 7 regels Perl:

$_='while(read+STDIN,$_,2048){$a=29;$b=73;$c=142;$t=255;@t=map{$_%16or$t^=$c^=(
$m=(11,10,116,100,11,122,20,100)[$_/16%8])&110;$t^=(72,@z=(64,72,$a^=12*($_%16
-2?0:$m&17)),$b^=$_%64?12:0,@z)[$_%8]}(16..271);if((@a=unx"C*",$_)[20]&48){$h
=5;$_=unxb24,join"",@b=map{xB8,unxb8,chr($_^$a[--$h+84])}@ARGV;s/...$/1$&/;$
d=unxV,xb25,$_;$e=256|(ord$b[4])<<9|ord$b[3];$d=$d>>8^($f=$t&($d>>12^$d>>4^
$d^$d/8))<<17,$e=$e>>8^($t&($g=($q=$e>>14&7^$e)^$q*8^$q<<6))<<9,$_=$t[$_]^
(($h>>=8)+=$f+(~$g&$t))for@a[128..$#a]}print+x"C*",@a}';s/x/pack+/g;eval

Perl de meest lelijke en krachtigste parsing taal die er bestaat

Die is inderdaad erg cool ja

Hmmmm... misschien (echt misschien) komen we met deze tutorials op een gegeven moment
zo ver dat we die code kunnen gaan ontleden en iedereen het snapt ook

Okidoki...

Nummer 5, nog een beetje over lists, push pop shift unshift

Oh... en de term 'slices' ....

Eerst nog een weetje over hoe je op nog een manier een list kan maken:

my @Getallen=(1..10);
my @Letters=('a'..'z');

We hebben nu 2 nieuwe lists met in Getallen:

1 2 3 4 5 6 7 8 9 10

en in Letters:

a b c d e f g h i j k l m n o p q r s t u v w x y z

We zullen even als voorbeeld @Letters nemen...

We hebben gezien dat we bijvoorbeeld door $Letters[5] te gebruiken het 6e element uit
Letters kunnen aanspreken, maar we kunnen ook meerdere elementen tegelijk aanspreken,
dit heet een 'slice'....

Hopelijk maakt het volgende voorbeeld dit duidelijk:

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

use strict;

# Nieuwe list met alle letters van het alfabet:
my @Letters=('a'..'z');

# Even kijken of ze er allemaal zijn:
print "Letters: @Letters\n";

# De 6e letter, dit hebben we eerder gedaan:
print "6e Letter: $Letters[5]\n";

# Okay, wat nieuws, dit is een slice we selecteren meerdere elementen uit een lijst.
# Let wel dat je hier te maken hebt met meerdere elementen, dus een list.
# We gebruiken dus hier geen $ maar @...
print "6e, 15e en 11e letter: @Letters[5,14,10]\n";

# En nog een stapje verder:
print "4e en 5e letter, en letters 15 tot en met 19: @Letters[3,4,14..18]\n";
---

En de uitvoer:

choas:~ choas$ ./les5
Letters: a b c d e f g h i j k l m n o p q r s t u v w x y z
6e Letter: f
6e, 15e en 11e letter: f o k
4e en 5e letter, en letters 15 tot en met 19: d e o p q r s
choas:~ choas$

Nou dat waren dus slices. Nu nog wat andere manieren om lists te manipuleren:

pop :haal een element van het einde van een lijst af.
push :voeg een element aan het einde van een lijst toe.
shift :haal een element van het begin van een lijst af.
unshift :voeg een element aan het begin van een lijst toe.

Hopelijk laat het volgende voorbeeld deze functies goed zien:
---
#!/usr/bin/perl -w

use strict;

# Nieuwe list met alle letters van het alfabet:
my @Letters=('a'..'z');

# Even kijken of ze er allemaal zijn:
print "Letters: @Letters\n\n";

#Tijdelijke scalar voor letters die we verwijderen.
my $Tijdelijk;

#Tijdelijk krijgt hier de waarde van het element wat we van de list afhalen
$Tijdelijk=pop @Letters;
print "Na pop ->Letters: @Letters\n";

print "Tijdelijk: $Tijdelijk\n";
#Hier zetten we de letter uit tijdelijk weer terug in de lijst
push @Letters, $Tijdelijk;
print "Na push ->Letters: @Letters\n\n";

#En andersom:
$Tijdelijk=shift @Letters;
print "Na shift->Letters: @Letters\n";
print "Tijdelijk: $Tijdelijk\n";
unshift @Letters, $Tijdelijk;
print "Na unshift ->Letters: @Letters\n";
---

Geeft als output:

choas:~ choas$ ./les5
Letters: a b c d e f g h i j k l m n o p q r s t u v w x y z

Na pop ->Letters: a b c d e f g h i j k l m n o p q r s t u v w x y
Tijdelijk: z
Na push ->Letters: a b c d e f g h i j k l m n o p q r s t u v w x y z

Na shift->Letters: b c d e f g h i j k l m n o p q r s t u v w x y z
Tijdelijk: a
Na unshift ->Letters: a b c d e f g h i j k l m n o p q r s t u v w x y z

Dus... is dat een beetje duidelijk ?

Kunnen er mensen voorspellen wat het volgende doet ? :

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

use strict;

# Nieuwe list met alle letters van het alfabet:
my @Letters=('a'..'z');

for (0..26)
{
print "@Letters\n";
my $Tijdelijk=shift @Letters;
push @Letters,$Tijdelijk;
};
---

Probeer maar uit

En nu ga ik even net doen alsof ik een leven heb... maar ik kom terug... met hashes een van de containers van Perl waar je niet zonder kan (wil kunnen).

quote:

Op zaterdag 5 juni 2004 11:17 schreef Hiawatha het volgende:

[..]

Wacht maar tot ie reguliere expressies gaat behandelen. Daar is Perl echt veel krachtiger in.

Yup regexps.. dat gaan wel een paar leuke lesjes worden

Ben er nu even vandoor voor een nieuwe videokaart (oude is letterlijk uitgefikt) en een popfestivalletje in de buurt...

Vanavond volgen hashes... ERG krachtige datacontainer in Perl...

Daarna zoals gezegd files... dan even combinaties en praktijkdingen van alles wat we gedaan hebben.

En dan gaan we over op regexps...

Daarna misschien een beetje OO Perl, en leren gebruik maken van modules en natuurlijk CGI...

Ik heb er zin in!... tot straks!

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