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!