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)
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 ]
Ik wou toch als is met perl gaan stoeien....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
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!
quote:Thanks Repelsteel!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!
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...
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...
Ik ga ze nu ff doen
Lekker simpel uitgelegd
Ik wacht alweer op de volgende les.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
Ga zo door!
Erg handig
...nu eerst even pauze, dan weer een les?!
$_='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
quote:Die is inderdaad erg cool jaOp 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
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
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:Wacht maar tot ie reguliere expressies gaat behandelen. Daar is Perl echt veel krachtiger in.Op zaterdag 5 juni 2004 08:30 schreef Nebu1980 het volgende:
Het heeft inderdaad wat weg van php, zoals je schreef!
Erg handig
...nu eerst even pauze, dan weer een les?!
quote:Yup regexps.. dat gaan wel een paar leuke lesjes wordenOp 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.
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!
Ik hoor het wel ChOas als je m'n hulp nodig hebt!
* Repelsteel met kritisch oogje meekijkt
quote:Ja mag... (doe maar klooncheck) ben niet thuisOp zaterdag 5 juni 2004 14:39 schreef Slarioux het volgende:
ChOas, geef even een gil, hier of in Feedback, of ik je tutorials in een FAQ mag gooien
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:Klopt, dat was ikOp zaterdag 5 juni 2004 17:54 schreef Cunt het volgende:
[..]
Ja mag... (doe maar klooncheck) ben niet thuis
Oh, en ik wil toevoegen dat ik vereerd ben dat jullie hier een FAQ van willen maken
quote:Op zaterdag 5 juni 2004 21:43 schreef ChOas het volgende:
[..]
Klopt, dat was ik
Oh, en ik wil toevoegen dat ik vereerd ben dat jullie hier een FAQ van willen maken
was mijn ideeanders krijg je in dit topic de lessen en de andere reacties door elkaar, en dat is niet zo handig als je hier mee wilt beginnen
(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:
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
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
Bijvoorbeeld perldoc -f open
Zie verder man perldoc.
Ben een beetje te vertiefd om nu de volgende les te schrijven, maar morgenochtend kan je `m in dit topic vinden...
Sorry...
GrtZ,
ChOas
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:
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.
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...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.
quote:Heel goed punt!!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.
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, 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
quote:Gebruikt er dan echt niemandOp maandag 7 juni 2004 12:10 schreef rihago het volgende:
tvp
deze 
Ik vinnum geweldig!Ik wacht met spanning op het hele regex verhaal!
Duidelijk bescheven. Vooral doorgaan ChOas.
quote:neej.. nu staat hij tenminste tussen my active topicsOp maandag 7 juni 2004 12:25 schreef devzero het volgende:
offtopic
[..]
Gebruikt er dan echt niemand [afbeelding] deze
(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
Overigens: bij een implicite return (gewoon het einde van de functie zonder return) wordt $_ gereturned = de waarde van de vorige expressie.
Wat devzero schrijft is grotendeels waar, hij heeft gelijk dat er onderwater bij de return een aantal interessante dingen gebeuren, en die heb ik niet uitgelegd (vooral om het simpel te houden, maar ik heb nog niemand met vragen gehoord... Ja, ik heb het tegen jou, jij, diegene die dit heel interessant vindt maar net niet alles begrijpt en het niet durft te vragen
)...Echter... de impliciete return van een functie is niet $_, maar het resultaat van de laatste uitgevoerde functie/opdracht:
---
#!/usr/bin/perl -w
use strict;
sub Test
{
$_="ladiedadieda";
my $TestWaarde=2 * 333;
};
my $Return=Test;
print "Return: $Return\n";
---
Uitvoer:
choas:~ choas$ ./vooorbeeld
Return: 666
choas:~ choas$
Sorry devzero, moest het even rechtzetten...
Verder heb je absoluut gelijk...
Morgen moet ik even een cursus doen, en dan 's avonds doen we references en misschien een begin van regexps...
quote:AgreeOp maandag 7 juni 2004 23:13 schreef ChOas het volgende:
Echter... de impliciete return van een functie is niet $_, maar het resultaat van de laatste uitgevoerde functie/opdracht:
quote:Morgen moet ik even een cursus doen, en dan 's avonds doen we references en misschien een begin van regexps...
Eerst referencies (niet triviaal, maar te doen voor mensen die niet zoveel van pointers weten) en dan regexps
Hulde aan ChOas trouwens.
Spread the word, mate
Perl is the best!
Jan takke wat is het heet!!!
*naar koud biertje kijkt*
... Ik overleef het wel 
References... wat zijn references ? ... zoals mij ooit verteld is: REFERENCES ZIJN GEEN POINTERS... bullshit, zijn misschien geen pointers, maar je kan ze wel gebruiken als pointers...
Een reference is een scalar welke wijst naar een Perl variabele, zo kan je een reference hebben naar een list, een hash, en ja, ook een scalar (alhoewel je dat laatste niet snel zal gebruiken).
Hoe krijg je een reference naar een list ? heel eenvoudig, je zet er een \ voor.
Ik zal even laten zien hoe dat er uit ziet:
--
#!/usr/bin/perl -w
use strict;
my @Array=(1..10);
# Creeer een reference naar de Array:
my $ArrayRef=\@Array;
#En hoe ziet die reference er dan uit ? :
print "Reference naar de array: $ArrayRef\n";
# En voor een hash:
my %Hash=('appel','groen','banaan','geel');
my $HashRef=\%Hash;
print "Reference naar de hash: $HashRef\n";
---
En wat zien we dan ? (Zier er bij jullie waarschijnlijk iets anders uit) :
choas:~ choas$ ./les10
Reference naar de array: ARRAY(0x80a264)
Reference naar de hash: HASH(0x80cacc)
choas:~ choas$
Nou zijn er meerdere redenen om een reference te gebruiken, in dit deel zal ik uitleggen waarom ze handig zijn wanneer je informatie naar een subroutine wil passen, en in het volgende deel zal ik wat uitleggen over complexe data structuren.
Maar eerst dus subroutines... we hebben gezien dat data naar een subroutine als array wordt aangeleverd... het volgende probleem ontstaat:
---
#!/usr/bin/perl -w
use strict;
sub PrintArray
{
# HIER is het probleem... allebei de arrays zitten in @_, HOE weten we nou
# waar de eerste eindigt, en de 2e begint ?
print "AtUnderscore: @_\n";
};
my @Array1=(1..4);
my @Array2=(5..10);
PrintArray @Array1, @Array2;
---
Output:
choas:~ choas$ ./les10
AtUnderscore: 1 2 3 4 5 6 7 8 9 10
choas:~ choas$
Dat sucked dus... zwaar zelfs... De oplossing voor dit probleem is dus gebruikmaken van references, in plaats van de arrays zelf geven we een reference naar de arrays door aan de functie (dit heeft nog veel meer resource voordelen, maar daar gaan we het niet over hebben).
Gaan we:
---
#!/usr/bin/perl -w
use strict;
sub PrintArray
{
# hebben we de references ?
print "AtUnderscore: @_\n";
};
my @Array1=(1..4);
my @Array2=(5..10);
PrintArray \@Array1, \@Array2;
----
Output:
choas:~ choas$ ./les10
AtUnderscore: ARRAY(0x80ffb4) ARRAY(0x80ca90)
choas:~ choas$
Nou, mooi zo, de references naar de arrays zijn inderdaad in de functie aangekomen, maar hoe de fuck krijgen we daar uit nou weer de originele arrays terug ?
Antwoord: de-refereren
Voor een array als volgt: @{$ArrayRef};
Voor een hash: %{$HashRef};
Kijken of dit werkt ?
---
#!/usr/bin/perl -w
use strict;
sub PrintArray
{
print "AtUnderscore: @_\n";
# Haal de references uit @_
my $Ref1=shift;
my $Ref2=shift;
# de-reference weer naar lists:
my @Arr1=@{$Ref1};
my @Arr2=@{$Ref2};
# Heeft het gewerkt ? :
print "Array 1: @Arr1\n";
print "Array 2: @Arr2\n";
};
my @Array1=(1..4);
my @Array2=(5..10);
PrintArray \@Array1, \@Array2;
---
Output:
choas:~ choas$ ./les10
AtUnderscore: ARRAY(0x80a324) ARRAY(0x80cbb0)
Array 1: 1 2 3 4
Array 2: 5 6 7 8 9 10
choas:~ choas$
En DAT is dus een van de voordelen van references... Hopelijk is dit duidelijk, we gaan dit veel gebruiken.
Bij vragen: Laat het me alsjeblieft weten.
Straks denk ik deel 2 van references: complexe data structuren... wanneer er daarna nog geen vragen zijn is er een van de volgende dingen aan de hand:
Ik hoop dat jullie het nog leuk vinden...
Weet IEMAND trouwens hoeveel van die klote dingen ik nog moet tikken voor ik in dat fucking schouderklopjestopic kom ?
, dus we gaan door met complexe datastructurenWe hebben gezien dat alle variabelen in Perl alleen maar scalars kunnen bevatten, EN we hebben gezien dat de reference naar een hash of array een scalar is... DAAR moeten we wat mee kunnen doen!!!
We gaan een array maken met personen, een persoon is een hash met verschillende eigenschappen, naam, email adres, en eeerm leeftijd ofzo
Eeeeeeeeeeerst de lange uitleg:
---
#!/usr/bin/perl -w
use strict;
# Een lijst om de personen te bewaren:
my @Persoon;
# Hashes voor de personen:
my %P1=('naam','ChOas','email','xchoasx@wanadoo.nl','leeftijd',27);
my %P2=('naam','testpersoon','email','test@inter.net','leeftijd',66);
my %P3=('naam','testpersoon2','email','test2@inter.net','leeftijd',13);
# Maak de references:
my $RefP1=\%P1;
my $RefP2=\%P2;
my $RefP3=\%P3;
# Vul de lijst met de references:
push @Persoon,$RefP1;
push @Persoon,$RefP2;
push @Persoon,$RefP3;
# Kijken wat we in de lijst vinden.
foreach my $Identiteit (@Persoon)
{
# de-refereer de persoon weer naar een hash:
my %PData=%{$Identiteit};
# print informatie over de persoon:
print "Ik ben $PData{'naam'}, ik ben $PData{'leeftijd'} jaar oud, en mijn email adres is: $PData{'email'}\n";
};
---
Nou, dat is hopelijk nog wel te volgen, toch ? ... zo niet, laat het me weten...
De output:
choas:~ choas$ [b ]./les11[/b]
Ik ben ChOas, ik ben 27 jaar oud, en mijn email adres is: xchoasx@wanadoo.nl
Ik ben testpersoon, ik ben 66 jaar oud, en mijn email adres is: test@inter.net
Ik ben testpersoon2, ik ben 13 jaar oud, en mijn email adres is: test2@inter.net
choas:~ choas$
En dan nu hoe je het in de praktijk zal doen (later zal je nog veel ingewikkeldere voorbeelden tegenkomen, maar dit is alvast een begin (we gaan hier hele gave dingen meer doen):
---
#!/usr/bin/perl -w
use strict;
# Een lijst om de personen te bewaren:
my @Persoon;
# Hashes voor de personen:
my %P1=('naam','ChOas','email','xchoasx@wanadoo.nl','leeftijd',27);
my %P2=('naam','testpersoon','email','test@inter.net','leeftijd',66);
my %P3=('naam','testpersoon2','email','test2@inter.net','leeftijd',13);
# Vul de lijst met de references:
push @Persoon,\%P1,\%P2,\%P3;
# Kijken wat we in de lijst vinden.
foreach (@Persoon)
{
# print informatie over de persoon:
print "Ik ben $_->{'naam'}, ik ben $_->{'leeftijd'} jaar oud, en mijn email adres is: $_->{'email'}\n";
};
---
En nakijken:
choas:~ choas$ ./les11
Ik ben ChOas, ik ben 27 jaar oud, en mijn email adres is: xchoasx@wanadoo.nl
Ik ben testpersoon, ik ben 66 jaar oud, en mijn email adres is: test@inter.net
Ik ben testpersoon2, ik ben 13 jaar oud, en mijn email adres is: test2@inter.net
choas:~ choas$
Kijk... dat ziet er al een stuk makkelijker uit (tenminste, wanneer je er aan gewend bent
)Je ziet dus dat je oook doormiddel van '->' een element de-refereren zonder de gehele stuctuur te hoeven aanraken...
Stel nou dat jullie weer zo fantastisch reageren ga ik vanavond een begin maken aan reguliere expressies... prepare to be brainfucked
dit is alles op een goede manier uitgelegd dus heel handig voor de noobs
ik ga er ook mee beginnen binnenkort (alleen dankzij dit topic )quote:Ja, sorry dat ik af en toe zeikOp dinsdag 8 juni 2004 20:14 schreef BaggerUser het volgende:
hey ookal word er niet de hele tijd gereageerd je moet gewoon door gaan ermee
dit is alles op een goede manier uitgelegd dus heel handig voor de noobs
... maar af en toe geef ik cursussen, en dan heb je gelijk commentaar, en vragen enzo... nu vraag ik me af en toe af of ik iets fout doe Straks komt het begin over reguliere expressies... en eeerm ja, ik kan er goed mee om gaan, maar ik ga jullie ook verwijzen naar sites... reguliere expressies zijn ZO krachtig, en je kan er zo veel mee dat het onmogelijk is voor mij om alles uit te leggen...
Maar hopelijk kan ik een aardige fundering leveren...
#!/usr/bin/perl -w
use strict;
sub groet {
my($ptr) = @_;
${$ptr}="Hallo ".${$ptr};
}
my($name) = "Paul";
groet \$name;
print "$name\n";
call by reference kan dus zo worden geimplementeerd.
quote:Precies!Op dinsdag 8 juni 2004 20:41 schreef devzero het volgende:
eens kijken of iedereen nog bij de les is:
#!/usr/bin/perl -w
use strict;
sub groet {
my($ptr) = @_;
${$ptr}="Hallo ".${$ptr};
}
my($name) = "Paul";
groet \$name;
print "$name\n";
call by reference kan dus zo worden geimplementeerd.
... en nu (Ja, ik ben een lul ) waarom werkt het niet wanneer je geen ( en ) om my($ptr) heen hebt in je sub ? Kan trouwens ook nog zo:
sub groet {
${$_[0]}="Hallo ${$_[0]}";
}
Maar dat is Perl... de slogan is: TIMTOWTDI (There Is More Than One Way To Do It) en er is niet echt goed of fout (ja, okay, je hebt efficient en niet efficient) maar meestal is de tradeoff 'leesbaar' of 'niet leesbaar'
quote:Packages ? ... ja... gaan we ook doen... komt bij het OO gedeelte...Op dinsdag 8 juni 2004 20:45 schreef daReaper het volgende:
Ik ga trouwens zeker wel even mee lezen als er uitgelegd gaat worden, hoe je op een goeie manier je eigen modules kan maken. Gaat dat ook nog komen, ChOas?
het is maar goed dat sommige mensen geen leven hebben, kunnen ze ons mooi wat leren
Maar goeie uitleg, ik zal van het weekend alles eens uitproberen.
quote:Ik ga voor deze optieOp dinsdag 8 juni 2004 16:33 schreef ChOas het volgende:Iedereen die dit leest denkt het te snappen
Ik hoop dat jullie het nog leuk vinden...
En 't is zeker wel leuk quote:Packages inderdaadOp dinsdag 8 juni 2004 20:51 schreef ChOas het volgende:
[..]
Packages ? ... ja... gaan we ook doen... komt bij het OO gedeelte...
goed, dan ga ik zeker mee lezen, want die perldocs daarover snap ik echt voor geen meter
Goeie zaak jongen
quote:Hmm, niemandOp dinsdag 8 juni 2004 20:50 schreef ChOas het volgende:
Precies!
iemand een idee als ik
my $ptr = $_[0];
schrijf
quote:Ik weet t wel, maar da's flauw, aangezien ik al 5 jaar PerlOp dinsdag 8 juni 2004 21:22 schreef devzero het volgende:
[..]
Hmm, niemand
iemand een idee als ik
my $ptr = $_[0];
schrijf
Dus ik geef de beginners een kans om te antwoorden
Hebben jullie nog een topic of wat ? ... want hier kunnen we wel een tijdje mee bezig zijn
Mijn plan is om hier 2 posts aan te besteden, en afhankelijk van de vragen extra dingen uit te leggen....
Morgen overdag werk ik weer, en nu begin ik deel een, dus morgenavond kan je pas deel 2 verwachten.
*schraapt keel, en klinkt als professor*
"Hedendaagse programeertalen hebben allemaal wel de mogelijkheid gebruik te maken van reguliere expressies, of ze hebben libraries welke deze ondersteunen. Echter de reguliere expressies van Perl behoren tot de meest krachtige welke je tot je beschikking kan hebben"
Zo... dat was dat
"ChOas ? wat de FUCK is een reguliere expressie ?"
Goeie vraag, en (zoals sommige Perl mensen hier al vaker hebben gemerkt) ik ga deze vraag beantwoorden met een leugen: Een reguliere expressie is een 'pattern match' waarbij je kan kijken of je data aan bepaalde voorwaarden voldoet.
ZO, en dat is het, en niets meer (<- fucking leugen, maar zo gaan we er mee beginnen)
Een reguliere expressie bevindt zich tussen twee '/' tekens, (of, wanneer je 'm' voor match gebruikt elke non bracketing tekens, maar dat gaan we niet doen)
We beginnen even bij het begin... een paar dingen die je moet weten:
We gaan 'simpel' beginnen door een Nederlandse postcode te proberen te ontleden.
De operator die je gebruikt om een reguliere expressie op iets los te laten is =~
Het simpelste voorbeeld:
---
#!/usr/bin/perl -w
use strict;
my $Postcode="2564 SG";
print "Postcode: $Postcode\n";
# Heeft Postcode een teken in zich ?
print "Er staat een teken in $Postcode\n" if ($Postcode=~/./);
print "Er staat een getal in $Postcode\n" if ($Postcode=~/\d/);
print "Er staat een letter in $Postcode\n" if ($Postcode=~/\w/);
Output (zoals hopelijk verwacht) :
choas:~ choas$ ./les13
Postcode: 2564 SG
Er staat een teken in 2564 SG
Er staat een getal in 2564 SG
Er staat een letter in 2564 SG
choas:~ choas$
Maarja, dat zegt nog weinig, A53DFGD555 voldoet ook aan al die voorwaarden.
Dus... wat we eigenlijk zoeken is... 4 getallen, dan een spatie of niet (we weten niet hoe de gebruiker zijn/haar postcode invoert) en dan 2 letters.
Hoe bouwen we dit op ? :
4 getallen: \d{4}
Misschien een spatie ? : \s*
2 Letters: \w{2}
in een reguliere expressie ziet dit er zo uit: /\d{4}\s*\w{2}/;
Dit zorgt er voor dat 1234AZ en 5678 XY Allebei als postcode gezien worden.
Probleem is dat 432145 ook als postcode gezien wordt (4 en 5 zijn tenslotte toch 'word tekens'... maar daar komen we later op, dan gaan we character classes bespreken.
Maar hier is de code:
---
#!/usr/bin/perl -w
use strict;
my $Postcode="2564 SG";
print "Postcode: $Postcode\n";
# Heeft Postcode een teken in zich ?
print "Dit is een postcode!!!\n" if ($Postcode=~/\d{4}\s*\w{2}/);
---
Experimenteer maar met waarden voor $Postcode om te zien of het aan je verwachtingen voldoet.
Nou... ik ben niet eens op een 10e gekomen van wat eigenlijk mijn plan waqs... regexps zijn tricky, en hier moeten we een hoop aandacht aan besteden... ik hoop dat dit een goede start was.
[ Bericht 0% gewijzigd door ChOas op 08-06-2004 21:46:25 ]
quote:*mompelt iets over list in scalar context*Op dinsdag 8 juni 2004 21:27 schreef daReaper het volgende:
[..]
Ik weet t wel, maar da's flauw, aangezien ik al 5 jaar Perl
Dus ik geef de beginners een kans om te antwoorden
Pfff... dat soort dingen wil ik eigenlijk ook wel graag behandelen... maar het is moeilijk wanneer je geen directe feedback kan krijgen....
Ik moet trouwens nog een hoop over scalar en list context uitleggen... hmmmm... na regexps gaan we misschien maar weer even een paar stappen terug...
quote:Mensen die het echt willen weten moeten maar een boek over finite automaten aanschaffenOp dinsdag 8 juni 2004 21:41 schreef ChOas het volgende:
ZO, en dat is het, en niets meer (<- fucking leugen, maar zo gaan we er mee beginnen)
plug: Derick Wood-Theory of Computation is een goede starter
Ik ben benieuwd naar de volgende les. Pattern matching is de kracht van perl. Wat nu: metacharacters of string replacements.
Nog wat syntactic sugar voor het volgende pilsje en Dr. Phil
$_ = "Hallo ChOas";
print "Wie??\n" if(/ChOas/);
Aangezien gematcht wordt met $_ mag je de =~ operator direct weglaten.
quote:Op dinsdag 8 juni 2004 22:50 schreef devzero het volgende:
[..]
Mensen die het echt willen weten moeten maar een boek over finite automaten aanschaffen
plug: Derick Wood-Theory of Computation is een goede starter
Ik ben benieuwd naar de volgende les. Pattern matching is de kracht van perl. Wat nu: metacharacters of string replacements.
Nog wat syntactic sugar voor het volgende pilsje en Dr. Phil
$_ = "Hallo ChOas";
print "Wie??\n" if(/ChOas/);
Aangezien gematcht wordt met $_ mag je de =~ operator direct weglaten.
en weer heb je gelijk Ik ga even planten water geven bij de buren en dan mijn greppel in...
Morgen meer regexps, lookaheads, captures, replacements, hoe wel en hoe NIET regexps te gebruiken, etc...
Gaan wel een aantal posts worden
Vorige keer hebben we gezien dat /\d{4}\s*\w{2}/
Goed matched op de postcode, probleem is alleen dat 0 tm 9 ook onder word characters vallen dus 1234 56 ook als valide postcode werd gezien.
De oplossing hiervoor: character classes
Een character class plaats je tussen '[' en ']'
Voorbeeldjes:
[abcd] betekent het teken 'a' of 'b' of 'c' of 'd'
[54fer] betekent of 5 of 4 of 'e' of 'f' of 'r'
Maar ook:
[a-z] tekens a t/m z
[0-9] tekens 0 t/m 9
Kijken of dit helpt ?
---
#!/usr/bin/perl -w
use strict;
my $Postcode="2564 56";
print "Postcode: $Postcode\n";
# Fout:
print "Dit is een postcode!!!\n" if ($Postcode=~/\d{4}\s*\w{2}/);
#Goed:
print "Oh nee, toch niet!!!\n\n" unless ($Postcode=~/\d{4}\s*[a-z]{2}/);
$Postcode="2564 AB";
print "Postcode: $Postcode\n";
print "Test 1: Dit is een postcode!!!\n\n" if ($Postcode=~/\d{4}\s*[a-z]{2}/);
# Hmmmmm waarom wordt dat nou niet als postcode gezien ?... Ooooooh!!! Caps gevoeligheid!
# De character class kijkt naar a-z en AB staat in hoofdletters, dus dat matched niet...
# Nu kunnen we de charclass uitbereiden met A-Z zodat hoofdletters ook herkend worden, maar
# we kunnen de regexp ook ongevoelig maken voor hoofd/kleine letters door er een 'i' achter
# te zetten (Ignore case):
print "Test 2: Dit is een postcode!!!\n\n" if ($Postcode=~/\d{4}\s*[a-z]{2}/i);
---
Output:
choas:~ choas$ ./les14
Postcode: 2564 56
Dit is een postcode!!!
Oh nee, toch niet!!!
Postcode: 2564 AB
Test 2: Dit is een postcode!!!
choas:~ choas$
Yup, werkt... straks meer delen...
quote:Hoeveel wil je er hebben? Mail maar op bofh apendingetje meanframe punt comOp woensdag 9 juni 2004 18:45 schreef ChOas het volgende:
Heeft iemand misschien een paar regels Apache logging ?
Maareh, vallen er nog wat praktijkvoorbeelden te geven voor pointers, pardon references? Ik denk het te snappen, maar ik zie het wezelijke nut nog niet echt
Oftewel: Meester, ik snap het wel, maar ik weet niet waarom
quote:Dan ga ik eerst nog wat meer uitleggen over referencesOp woensdag 9 juni 2004 19:26 schreef TimberWolf het volgende:
[..]
Hoeveel wil je er hebben? Mail maar op bofh apendingetje meanframe punt com
Maareh, vallen er nog wat praktijkvoorbeelden te geven voor pointers, pardon references? Ik denk het te snappen, maar ik zie het wezelijke nut nog niet echt
Oftewel: Meester, ik snap het wel, maar ik weet niet waarom
... Waar zat het probleem ? variabelen passen naar een functie, of meer het complexe datastructuren gedeelte ? ... of allebei ?Oh.. mailtje komt er aan
quote:Op woensdag 9 juni 2004 19:26 schreef TimberWolf het volgende:
[..]
Hoeveel wil je er hebben? Mail maar op bofh apendingetje meanframe punt com
Maareh, vallen er nog wat praktijkvoorbeelden te geven voor pointers, pardon references? Ik denk het te snappen, maar ik zie het wezelijke nut nog niet echt
Oftewel: Meester, ik snap het wel, maar ik weet niet waarom
quote:Alsjeblieft. Ik heb hier een variabele aangepast met behulp van een functie, zonder van die functie een return te gebruiken. Output van deze code is "12"sub alter {
my ($arg) = @_;
${$arg} = 2
};
my $test = 1;
my $ref = \$test;
print $test;
alter($ref);
print $test;
ik heb er nu alleen effe geen tijd voor, tvp dus
quote:Ah. Eh. Nu ga ik inderdaad de domme cursist moeten zijn, want:Op woensdag 9 juni 2004 19:31 schreef daReaper het volgende:
Alsjeblieft. Ik heb hier een variabele aangepast met behulp van een functie, zonder van die functie een return te gebruiken. Output van deze code is "12"
A - Why? Waarom is dat handig?
B - Ik had nooit gedacht dat ik van zo weinig regels code, zo weinig zou snappen
Kan iemand me een real-world voorbeeld doen van het nut van pointers? I've gone stupid, blijkbaar
my $test = 1;
De variabele test wordt aangemaakt, en gevuld met 1. Clear
my $ref = \$test;
Er wordt een reference gemaakt voor test, die noemen we ref. Die wijst dus
naar de variabele met de waarde 1. Clear
print $test;
Duh.
alter($ref);
Voer de functie uit
print $test;
Laat test zien
sub alter {
my ($arg) = @_;
Vul $arg met de te verwachten waarde. Hier ben ik um kwijt
${$arg} = 2
Not a fucking clue. Sorry...
};
Wat mis ik hier nu aan? Ik schaam me dood dat ik het niet snap namelijk
[ Bericht 1% gewijzigd door TimberWolf op 09-06-2004 19:54:09 (Bollocks, de code tag werkt niet.) ]
quote:Komt ie...Op woensdag 9 juni 2004 19:48 schreef TimberWolf het volgende:
[..]
Ah. Eh. Nu ga ik inderdaad de domme cursist moeten zijn, want:
A - Why? Waarom is dat handig?
B - Ik had nooit gedacht dat ik van zo weinig regels code, zo weinig zou snappen
Kan iemand me een real-world voorbeeld doen van het nut van pointers? I've gone stupid, blijkbaar
SPOILERPfff... dat was even snel codenStel je voor, je bent leraar in je klas, en je wil informatie over je studenten opslaan...
Je weet een aantal dingen over je studenten, bijvoorbeeld studentennummer (uniek),naam, het vak wat ze doen, en het cijfer wat ze staan voor dat vak...
Stel je voor dat dit in een bestand staat als dit (iedereen doet maar 3 vakken):
10 ChOas WIS 9 NAT 8 ENG 10
20 Giegel FRA 5 SCH 2 ECO 7
30 Timber ENG 7 FRA 4 DUI 6
Hier is dan een programma wat je kan gebruiken om informatie over een student op te vragen:
---
#!/usr/bin/perl -w
use strict;
sub ReadFile
{
my $File=shift;
my %Student;
open INPT,"<$File" or die "Aaaaaaarg!!! *hoest*: $!\n";
while (<INPT>)
{
my ($StudentId,$Naam,$Vak1,$Cijf1,$Vak2,$Cijf2,$Vak3,$Cijf3)=split;
$Student{$StudentId}{'Naam'}=$Naam;
push @{$Student{$StudentId}{'vak'}},"$Vak1: $Cijf1";
push @{$Student{$StudentId}{'vak'}},"$Vak2: $Cijf2";
push @{$Student{$StudentId}{'vak'}},"$Vak3: $Cijf3";
};
close INPT;
return %Student;
};
my %Database=ReadFile 'student.txt';
# En NU hebben we in %Database een interesante hash die er zo uitziet:
# De key is het UserId, elke user heeft 2 andere structuren in zich, Naam: een scalar
# en vak: een lijst van de cijfers die ze voor een bepaald vak hebben.
# Hoe bekijken we dit ?:
foreach my $StudentId (keys %Database)
{
print "$Database{$StudentId}{'Naam'} heeft als studentennummer: $StudentId\n";
print "De cijfers voor zijn/haar vakken zijn: \n";
print "\t$_\n" for (@{$Database{$StudentId}{'vak'}});
};
---
zo kan je dus hele ingewikkelde dingen bouwen... (stel alsjeblieft vragen wanneer je wil dat ik dit uitschrijf met wat minder shortcuts)
Output:
choas:~ choas$ ./test1
Giegel heeft als studentennummer: 20
De cijfers voor zijn/haar vakken zijn:
FRA: 5
SCH: 2
ECO: 7
Timber heeft als studentennummer: 30
De cijfers voor zijn/haar vakken zijn:
ENG: 7
FRA: 4
DUI: 6
ChOas heeft als studentennummer: 10
De cijfers voor zijn/haar vakken zijn:
WIS: 9
NAT: 8
ENG: 10
choas:~ choas$
Misschien ging ik daar over een paar dingen een beetje te snel... dus besteed er nog maar geen aandacht aan... ik heb hieronder even het gedeelte wat niet helemaal duidelijk was geprobeert uit te leggen, helpt dat ?
[ Bericht 1% gewijzigd door ChOas op 09-06-2004 20:20:18 ]
Leuk, die mensen zonder leven
quote:aaaaaah... wat hier staat:Op woensdag 9 juni 2004 19:53 schreef TimberWolf het volgende:
Even pogen deze stap voor stap te doen. Ik move de functie even na de code:
my $test = 1;
De variabele test wordt aangemaakt, en gevuld met 1. Clear
my $ref = \$test;
Er wordt een reference gemaakt voor test, die noemen we ref. Die wijst dus
naar de variabele met de waarde 1. Clear
print $test;
Duh.
alter($ref);
Voer de functie uit
print $test;
Laat test zien
sub alter {
my ($arg) = @_;
Vul $arg met de te verwachten waarde. Hier ben ik um kwijt
${$arg} = 2
Not a fucking clue. Sorry...
};
Wat mis ik hier nu aan? Ik schaam me dood dat ik het niet snap namelijk
my ($arg)=@_;
is hetzelfde als : my $arg=shift;
Dus: Het eerste element in @_ (De reference die aan de functie is meegegeven)...
${$arg}=2 betekent dat je 2 stopt in de scalar variabele waar $arg naar wijst.
Al beter ? zo niet zeg het, leg ik het op een andere manier uit...
quote:Ah, dat snap ik inderdaad dan beterOp woensdag 9 juni 2004 20:12 schreef ChOas het volgende:
[..]
aaaaaah... wat hier staat:
my ($arg)=@_;
is hetzelfde als : my $arg=shift;
Dus: Het eerste element in @_ (De reference die aan de functie is meegegeven)...
${$arg}=2 betekent dat je 2 stopt in de scalar variabele waar $arg naar wijst.
Al beter ? zo niet zeg het, leg ik het op een andere manier uit...
Die hele 'do what i mean' variable in perl is krachtig zat, maar leuk verwarrend bovendien.In jouw voorbeeld zie ik momenteel zelfs de hele pointers over het hoofd, maar dat kan door de warmte komen
Ik pak dadelijk een biertje en een half uurtje rust, en dan komt het vast goed Ga voor de rest overigens vooral verder, ik blaat er af en toe wel tussendoor! Zou zonde zijn als ik de cursus stagneer tenslotte quote:Pjee!!... je stagneert helemaal niets!!.. dan heeft de rest maar wat meer geduld!Op woensdag 9 juni 2004 20:20 schreef TimberWolf het volgende:
[..]
Ah, dat snap ik inderdaad dan beter
In jouw voorbeeld zie ik momenteel zelfs de hele pointers over het hoofd, maar dat kan door de warmte komen
Dat voorbeeld heb ik inderdaad maar even gespoilered, ging een beetje te snel, er zitten daar een hoop impliciete references in...
Maar, DE reden voor references is (buiten parameters naar functies passen) dat je in een Perl variabele alleen maar een scalar kan stoppen, en daar kan je niet veel mee want je zal ZO VAAK tegenkomen "Had ik maar een lijst met hashes" enzo... dat kan je alleen met references oplossen.
mocht je ergens mee zitten ben ik ook op MSN te bereiken hoor (xchoasx@hotmail.com)
quote:'t is maar goed dat dit ChOas' topic is, en niet die van mij, of niet dan?Op woensdag 9 juni 2004 20:20 schreef TimberWolf het volgende:
[..]
Ah, dat snap ik inderdaad dan beter
In jouw voorbeeld zie ik momenteel zelfs de hele pointers over het hoofd, maar dat kan door de warmte komen
Ik ben echt bijzonder slecht in uitleggen SPOILERHé ik ben goed in scheikunde
#!/usr/bin/perl -w
use strict;
use Tk;
sub KeyPress;
my $MW=MainWindow->new;
my $AsList;
my %Border=qw(-relief raised);
my %Fill=qw(-fill both);
my $Top =$MW->Frame->pack(-side=>'top');
my $TopLeft =$Top->Frame(%Border)->pack(-side=>'left');
my $TopRight =$Top->Frame(%Border)->pack(-side=>'left');
my $RegLabel=$TopLeft->Label(%Border,-text=>'RegExp')->pack(%Fill);
my $TextLabel=$TopLeft->Label(%Border,-text=>'Text')->pack(%Fill);
my $AsListBox=$Top->Checkbutton(-text=>'List context',-variable=>\$AsList,-command=>\&KeyPress)->pack();
$Border{-bd}=1;
my $RegExp=$TopRight->Entry(-width=>30)->pack();
my $Text=$TopRight->Entry(-width=>30)->pack();
my $ResultTextFrame =$MW->Frame(%Border)->pack(-side=>'left');
my $ResultTextLabel=$ResultTextFrame->Label(-justify=>'left',-text=>"PreMatch:\nMatch:\nPostMatch:\nResult:\n\$1..n")->pack(%Fill);
my $ResultFrame =$MW->Frame(%Border)->pack(-side=>'left',%Fill);
my $ResultLabel=$ResultFrame->Label(-justify=>'left',-text=>"none\nnone\nnone\nnone")->pack(%Fill);
$MW->bind('all', '<KeyPress>', \&KeyPress);
MainLoop();
sub KeyPress
{
local $^W=0;
my $RegEx=$RegExp->get;
my $Text =$Text->get;
my (@Dollar,@Result,$Result,$Match,$PreMatch,$PostMatch);
my $Function;
my $FieldCodes=join "",'$Match=$&;',
'$PreMatch=$`;',
"\$PostMatch=\$';",
"\$Dollar[0]=\$1;",
"\$Dollar[1]=\$2;",
"\$Dollar[2]=\$3;",
"\$Dollar[3]=\$4;",
"\$Dollar[4]=\$5;";
if (!$AsList)
{
$Function=join "",'($Result=$Text)=~',"$RegEx;",$FieldCodes;
}
else
{
$Function=join "",'@Result=($Text=~',"$RegEx);",$FieldCodes;
};
eval $Function;
$Result||=join "|",@Result;
$Match||='none'; $PreMatch||='none'; $PostMatch||='none';
$ResultLabel->configure(-text=>"$PreMatch\n$Match\n$PostMatch\n$Result\n@Dollar");
$ResultLabel->update;
};
Experimenteer er maar mee...
Nee, dit was geen les
quote:Het kan ook gewoon zijn dat ik een klein snappertje heb voor dit soort dingenOp woensdag 9 juni 2004 20:36 schreef daReaper het volgende:
[..]
't is maar goed dat dit ChOas' topic is, en niet die van mij, of niet dan?
Ben ooit begonnen met C, maar daar haakte ik ook af bij pointers. Op een of andere manier snap ik het doel gewoon niet. Maargoed, het begin helderder te worden. En als Choas met zijn cursus verder gaat, wat ik wel hoop, ga ik vast nog meer praktijkvoorbeelden tegenkomen. Ik verheug me op het volgende deel, en de rest vast ook, hoewel er maar weinig reageren leuke tutorials, over een tijdje ook dat 'ie bijvoorbeeld HTML pagina's uitgeeft en/of met een database kan praten hoop ik?
quote:Volgende deel regexps ga ik je apache logging gebruikenOp woensdag 9 juni 2004 22:31 schreef TimberWolf het volgende:
Ah, en chOas, de regexp uitleg is tot nu toe glashelder
Maar dat wordt morgen... 2 termen die je dan gaat tegenkomen zijn 'greedy matching' en 'negated character classes' ... wordt tricky, wordt leuk
quote:Right thenOp woensdag 9 juni 2004 22:42 schreef ChOas het volgende:
Volgende deel regexps ga ik je apache logging gebruiken
Mocht je meer of andere logs nodig hebben weet je me te vinden. Mijn Linux doosje spuugt kilo's van die troep uit elke dag Het volgende heb ik gemaak en het werkt niet
quote:De fout die ik krijd is.#!/usr/bin/perl -w
use strict;
my $Number;
print "Voer een getal in onder de 10: ";
#krijg invoer van het toetsenbord (gebruiker)
$Number=<STDIN>;
#Enter uit $Number halen
chomp $Number;
if($Number>10)
{
print "Het nummer is groter dan 10 dus we gaan niet tellen\n";
}else{
print "het nummer is kleiner dan 10. We gaan tot 25 tellen\n";
#We gaan tot 25 tellen, met een for lus
for($Number;$Number<25;$Number++)
}
quote:Wat doe ik fout want ik zie het echt niet. Het enige dat ik denk te weten is dat de fout in de for lus zit.syntax error at ./test line 22, near ")
}"
Execution of ./test aborted due to compilation errors.
quote:Je doet nix in de for loop... Sterker nog, je hebt geen { en } er achter gezetOp donderdag 10 juni 2004 14:21 schreef Wouta het volgende:
Ik heb de eerste drie hoodfstukken gelezen en dacht laat ik is iets zinloos gaan maken.
Het volgende heb ik gemaak en het werkt niet
[..]
De fout die ik krijd is.
[..]
Wat doe ik fout want ik zie het echt niet. Het enige dat ik denk te weten is dat de fout in de for lus zit.
quote:#!/usr/bin/perl -w
use strict;
my $Number;
print "Voer een getal in onder de 10: ";
#krijg invoer van het toetsenbord (gebruiker)
$Number=<STDIN>;
#Enter uit $Number halen
chomp $Number;
if($Number>10)
{
print "Het nummer is groter dan 10 dus we gaan niet tellen\n";
}else{
print "het nummer is kleiner dan 10. We gaan tot 25 tellen\n";
#We gaan tot 25 tellen, met een for lus
for($Number;$Number<25;$Number++) {
print "$Number\n";
}
}
quote:Dat het ik zelf moeten kunnen verzinnen.....Op donderdag 10 juni 2004 14:27 schreef daReaper het volgende:
[..]
Je doet nix in de for loop... Sterker nog, je hebt geen { en } er achter gezet
[..]
Ik heb een vraag over het volgende voorbeeld:
quote:Dat werkt gewoon wat ik me nu af vraag is waarom er een $ staat ipv een @ als je de fruit soorten gaat printen. Ik heb er een @ neergezet en toen ging perl heel bijdehand mij vertellen dat ik beter een $ kon gebruken. Maar helemaal snappen waarom ik geen @ moeten gebruiken daar doe ik niet.#!/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";
};
Iemand die dat even wat wil verhelderen ?
[ Bericht 5% gewijzigd door Wouta op 10-06-2004 15:35:59 (quote gefixt) ]
quote:Eerst de cursus afmaken en misschien dat we een dig-mod zover krijgen dat je naam in de hall of fame komtOp woensdag 9 juni 2004 22:43 schreef ChOas het volgende:
Oh, en ik vraag me af wie ik moet pijpen voor een fucking schouderklopje, maar daar kom ik nog wel achter
quote:Inderdaad, wat CybErik zegt. Je hebt het over een element uit de list, wat een scalar is, en geen list...Op donderdag 10 juni 2004 15:34 schreef Wouta het volgende:
Sorry hoor dat ik weer een vraag ga stellen....
Ik heb een vraag over het volgende voorbeeld:
[..]
Dat werkt gewoon wat ik me nu af vraag is waarom er een $ staat ipv een @ als je de fruit soorten gaat printen. Ik heb er een @ neergezet en toen ging perl heel bijdehand mij vertellen dat ik beter een $ kon gebruken. Maar helemaal snappen waarom ik geen @ moeten gebruiken daar doe ik niet.
Iemand die dat even wat wil verhelderen ?
Dus:
@List <- List
$List[<getal>] <- Element uit een list
@List[3,4] <- Elementen 3 en 4 uit een list (en het zijn meerdere elementen, dus da's dan weer een list
Ik ga even een stukje schrijven over om een Apache log te parsen met behulp van regexps.
quote:Een ander voorbeeld/Op donderdag 10 juni 2004 15:34 schreef Wouta het volgende:
Ik heb een vraag over het volgende voorbeeld:
#!/usr/bin/perl -w
use strict;
# een array met references naar een "anonieme" hash. Anoniem want er is alleen de referentie
# geen "echte" variabele
my @Fruit = ( {'Naam' => 'Appel', 'Prijs' => 1.23},
{'Naam' => 'Peer', 'Prijs' => 2.24});
my $index;
# by elke iteratie refereert $index naar een van de hashes uit de lijst
foreach $index(@Fruit) {
# en de waarde wordt toegekent aan %veld
my %veld = %{$index};
print "Ik heb zin in een $veld{'Naam'} en dat kost me $veld{'Prijs'}\n";
}
# doet het zelfde
foreach (@Fruit) { print "Ik heb zin in een ${$_}{'Naam'} en dat kost me ${$_}{'Prijs'}\n"; }
Er zit echter 1 verschil tussen beide methods. Bij methode 1 druk je een copie af van @Fruit en bij methode 2 de werkelijke waardes. Voor afdrukken maakt dat niets uit, maar als je dingen (zoals de prijs) wil veranderen dan werkt methode 1 niet, want na iedere iteratie gooi je %veld weer weg.
Bijvoorbeeld
my $index;
foreach $index(@Fruit) {
my %veld = %{$index};
# verandert alleen $veld{'Prijs'} en niet @Fruit
$veld{'Prijs'}=$veld{'Prijs'}*2;
print "Ik heb zin in een $veld{'Naam'} en dat kost me $veld{'Prijs'}\n";
}
foreach (@Fruit) { print "Ik heb zin in een ${$_}{'Naam'} en dat kost me ${$_}{'Prijs'}\n"; }
geeft als uitvoer
Ik heb zin in een Appel en dat kost me 2.46
Ik heb zin in een Peer en dat kost me 4.48
Ik heb zin in een Appel en dat kost me 1.23
Ik heb zin in een Peer en dat kost me 2.24
Okay... we willen wat nuttige informatie uit een logfile van Apache halen...
Eerst het ALLERbelangrijkste van programeren: Data analyse
Dit wil zeggen: HOE ziet onze data er uit, en HOE willen we hem hebben om te bewerken.
Dus... bij deze, een paar regeltjes log:
213.84.91.93 - - [09/Jun/2004:15:24:59 +0200] "GET /Includes/header.inc.php HTTP/1.0" 200 1340 "-" "PHP/4.2.2"
213.84.91.93 - - [09/Jun/2004:15:24:59 +0200] "GET /Includes/footer.inc.php HTTP/1.0" 200 18 "-" "PHP/4.2.2"
209.237.238.176 - - [09/Jun/2004:15:24:59 +0200] "GET /help/homepage.php HTTP/1.0" 200 2488 "-" "ia_archiver"
218.24.32.56 - - [09/Jun/2004:17:58:46 +0200] "GET /default.ida?XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX%u9090%u6858%ucbd3%u7801%u9090%u6858%ucbd3%u7801%u9090%u6858%ucbd3%u7801%u9090%u9090%u8190%u00c3%u0003%u8b00%u531b%u53ff%u0078%u0000%u00=a HTTP/1.0" 404 285 "-" "-"
192.168.0.9 - - [09/Jun/2004:19:39:10 +0200] "GET / HTTP/1.1" 200 3283 "-" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"
192.168.0.9 - - [09/Jun/2004:19:39:10 +0200] "GET /include/valid-html401 HTTP/1.1" 200 2948 "http://xyz.meanframe.com/" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"
192.168.0.9 - - [09/Jun/2004:19:39:10 +0200] "GET /include/vcss HTTP/1.1" 200 1547 "http://xyz.meanframe.com/" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"
192.168.0.9 - - [09/Jun/2004:19:39:11 +0200] "GET /back.gif HTTP/1.1" 200 525 "http://xyz.meanframe.com/" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"
192.168.0.9 - - [09/Jun/2004:19:39:13 +0200] "GET /adddomain.php HTTP/1.1" 200 3503 "http://xyz.meanframe.com/" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"
192.168.0.9 - - [09/Jun/2004:19:39:17 +0200] "POST /adddomain.php HTTP/1.1" 200 3563 "http://xyz.meanframe.com/adddomain.php" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"
Kijk nou maar eens rustig 5 minuutjes hier naar, en probeer te ontdekken wat het patroon is in de logfiles.
...
*naar koelkast loopt*
*biertje scoort*
...
Klaar ?
Okay... dit zie ik: Ik kan geen split gebruiken want ik zou dan op spatie willen splitten, maar dat kan niet omdat ik dan ook elementen splits zoals "GET /include/vcss HTTP/1.1" en dat willen we niet....
Dan maar eens kijken hoe we hier een regexp op kunnen matchen die ook geldt voor alle andere regels:
192.168.0.9 - - [09/Jun/2004:19:39:10 +0200] "GET / HTTP/1.1" 200 3283 "-" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"
classes gebruiken moeten we een '\' voor deze characters zetten. dit wordt: \[.*\]
Nou!... koekie toch ?
Hoe ziet de regexp er nu uit ? :
/\S+\s+\S+\s+\S+\s+\[.*\]\s+".*"\s+\d+\s+\d+\s+".*"\s+".*"/
Lekker hoor
Kijken of het werkt ?
---
#!/usr/bin/perl -w
use strict;
my @Data;
$Data[0]='213.84.91.93 - - [09/Jun/2004:15:24:59 +0200] "GET /Includes/header.inc.php HTTP/1.0" 200 1340 "-" "PHP/4.2.2"';
$Data[1]='213.84.91.93 - - [09/Jun/2004:15:24:59 +0200] "GET /Includes/footer.inc.php HTTP/1.0" 200 18 "-" "PHP/4.2.2"';
$Data[2]='209.237.238.176 - - [09/Jun/2004:15:24:59 +0200] "GET /help/homepage.php HTTP/1.0" 200 2488 "-" "ia_archiver"';
$Data[3]='218.24.32.56 - - [09/Jun/2004:17:58:46 +0200] "GET /default.ida?XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX%u9090%u6858%ucbd3%u7801%u9090%u6858%ucbd3%u7801%u9090%u6858%ucbd3%u7801%u9090%u9090%u8190%u00c3%u0003%u8b00%u531b%u53ff%u0078%u0000%u00=a HTTP/1.0" 404 285 "-" "-"';
$Data[4]='192.168.0.9 - - [09/Jun/2004:19:39:10 +0200] "GET / HTTP/1.1" 200 3283 "-" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"';
$Data[5]='192.168.0.9 - - [09/Jun/2004:19:39:10 +0200] "GET /include/valid-html401 HTTP/1.1" 200 2948 "http://xyz.meanframe.com/" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"';
$Data[6]='192.168.0.9 - - [09/Jun/2004:19:39:10 +0200] "GET /include/vcss HTTP/1.1" 200 1547 "http://xyz.meanframe.com/" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"';
$Data[7]='192.168.0.9 - - [09/Jun/2004:19:39:11 +0200] "GET /back.gif HTTP/1.1" 200 525 "http://xyz.meanframe.com/" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"';
$Data[8]='192.168.0.9 - - [09/Jun/2004:19:39:13 +0200] "GET /adddomain.php HTTP/1.1" 200 3503 "http://xyz.meanframe.com/" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"';
$Data[9]='192.168.0.9 - - [09/Jun/2004:19:39:17 +0200] "POST /adddomain.php HTTP/1.1" 200 3563 "http://xyz.meanframe.com/adddomain.php" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"';
my $i=0;
for (@Data)
{
print "$i is een Apache logregel!\n" if (/\S+\s+\S+\s+\S+\s+\[.*\]\s+".*"\s+\d+\s+\d+\s+".*"\s+".*"/);
$i++;
};
---
En tadaaaa:
choas:~ choas$ ./les15
0 is een Apache logregel!
1 is een Apache logregel!
2 is een Apache logregel!
3 is een Apache logregel!
4 is een Apache logregel!
5 is een Apache logregel!
6 is een Apache logregel!
7 is een Apache logregel!
8 is een Apache logregel!
9 is een Apache logregel!
choas:~ choas$
En het kloterige is dat ik ook greedy matching uit wou leggen in deze les, maar mijn regexp was te goed
En waarom de regexp die we net hebben gezien volkomen klote is, zien we straks
[ Bericht 2% gewijzigd door ChOas op 10-06-2004 18:12:16 ]
Overigens leuk te zien: Regel 4 is een of andere dwaas die een populair exploit voor IIS probeert uit te voeren. Dat gebeurd wel meer
Wellicht is het leuk om via een regex de IP adressen uit de logfile te toveren? IP adressen zijn altijd wel leuk voor regex uitleg volgens mij
quote:Even een hele snelle:Op donderdag 10 juni 2004 21:08 schreef TimberWolf het volgende:
Even wat uitleg over de log, voor het geval begrip indeze handig is. Een apache log regel bestaat uit een vast aantal elementen, Beginnend met het 'Request IP', oftewel het IP adres van de webbrowser die de pagina opvraagt. Dan '\ \-\ \-\ ', oftewel spatie min spatie min spatie. Dan de datum, tijd en tijdzone-modifier tussen blokhaken. Als laatste de request zelf, dus de GETs en POSTs. Deze staan tussen quotes.
Overigens leuk te zien: Regel 4 is een of andere dwaas die een populair exploit voor IIS probeert uit te voeren. Dat gebeurd wel meer
Wellicht is het leuk om via een regex de IP adressen uit de logfile te toveren? IP adressen zijn altijd wel leuk voor regex uitleg volgens mij
Je moet weten dat $& de match is van een reguliere expressie.. en als het goed is kan jij me uitleggen wat dit programma doet (Neem aan dat INPT de geopende filehandle van je Apache log is):
---
my %Once;
while (<INPT>)
{
if (/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/) {$Once{$&}++};
};
Wat staat er nu in de hash %Once ?
[ Bericht 0% gewijzigd door ChOas op 10-06-2004 22:01:16 ]
quote:N.B. Denk er wel aan dat dat afhankelijk is van je logformaat in je httpd.conf. Er zijn wel een aantal "standaard" logformaten (bv LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined) maar de machine waarop je je paginaatje host kan een andere methode hebben.Op donderdag 10 juni 2004 21:08 schreef TimberWolf het volgende:
Even wat uitleg over de log, voor het geval begrip indeze handig is. Een apache log regel bestaat uit een vast aantal elementen,
quote:Mits HostnameLookups Off in httpd.conf:Wellicht is het leuk om via een regex de IP adressen uit de logfile te toveren? IP adressen zijn altijd wel leuk voor regex uitleg volgens mij
awk '{print $1}' /var/log/httpd-access.log | sort | uniq -c | sort -n
quote:Perl!Op donderdag 10 juni 2004 22:02 schreef devzero het volgende:
[..]
N.B. Denk er wel aan dat dat afhankelijk is van je logformaat in je httpd.conf. Er zijn wel een aantal "standaard" logformaten (bv LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined) maar de machine waarop je je paginaatje host kan een andere methode hebben.
[..]
Mits HostnameLookups Off in httpd.conf:
awk '{print $1}' /var/log/httpd-access.log | sort | uniq -c | sort -n
perl -e '$x{substr $_,0,index $_," "}++ while<>;print join"\n",keys %x,"\n"' /var/log/httpd-access.log
Ik gok dat het sneller is
quote:Op donderdag 10 juni 2004 22:15 schreef ChOas het volgende:
Perl!
Moest even trollen. Maar perl is hier sneller, maar je gaat awk ook niet gebruiken om 1 string af te drukken.quote:Overigens nog wat meer roet: vergeet niet dat je naast ipv4 nummers ook ipv6 nummers hebt. Bijvoorbeeld:if (/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/) {$Once{$&}++};
quote:2001:838:9999:1234:201:2ff:fe10:62ca - - [10/Jun/2004:22:24:31 +0200] "GET / HTTP/1.1" 200 213 "-" "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7b) Gecko/20040421"
quote:Dan gebruik je dezeOp donderdag 10 juni 2004 22:28 schreef devzero het volgende:
[..]
[..]
Overigens nog wat meer roet: vergeet niet dat je naast ipv4 nummers ook ipv6 nummers hebt. Bijvoorbeeld:
[..]
: ++$Once{substr $_,0,index $_," "}
Is sowieso takke sneller omdat je geen regex machine ingaat... je gaat er alleen maar vanuit dat het eerste element voor de spatie het adres is
quote:Ok, daar heb je gelijk mee. Ik kan me alleen wel applicaties voorstellen waar je niet het hele address maar alleen het netwerk wil hebben (wat bij ipv6 makkelijk is, ipv4 hak je maar in het wilde weg zonder netmask, bv in squid.conf "client_netmask").Op donderdag 10 juni 2004 22:32 schreef ChOas het volgende:
++$Once{substr $_,0,index $_," "}
Is sowieso takke sneller omdat je geen regex machine ingaat... je gaat er alleen maar vanuit dat het eerste element voor de spatie het adres is
quote:Op gevoel zeg ik dat er de ip-adressen in staan (dat is wat de regex matched). De constructie $once{regexresultaat}++ snap ik zeg maar bijnaOp donderdag 10 juni 2004 21:41 schreef ChOas het volgende:
my %Once;
while (<INPT>)
{
if (/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/) {$Once{$&}++};
};
Wat staat er nu in de hash %Once ?
quote:Vanzelfsprekend. Maar er is natuurlijk via een regex-match wel te kijken welk logformat er gebruikt wordt. Aan het 'uiterlijk' van de data valt redelijk simpel te herkennen wat voor data het is tenslotte. Dit is overigens, voor zover ik weet, zo'n beetje de Apache default.Op donderdag 10 juni 2004 22:02 schreef devzero het volgende:
N.B. Denk er wel aan dat dat afhankelijk is van je logformaat in je httpd.conf. Er zijn wel een aantal "standaard" logformaten (bv LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined) maar de machine waarop je je paginaatje host kan een andere methode hebben.
quote:En die zijn leuker, want die bestaan niet altijd uit even veel octetsOverigens nog wat meer roet: vergeet niet dat je naast ipv4 nummers ook ipv6 nummers hebt.
Nouja, ze worden niet altijd getoond zeg maar. Dus ipv6 maakt het regex matchen wel een stuk spannender Hoedanook, ik wacht gespannen op de volgende les
Stelt niet veel voor, maar werkt wel:#!/usr/bin/perl -w
use strict;
# Subs
sub CheckLine
{
# Flikker het zoekwoord in een var
my $Zoek=shift;
# En de uitgelezen regel ook maar
my $Regel=shift;
# Controleer of het zoekwoord in de regel zit.
if ($Regel =~ $Zoek)
{
print $Regel;
}
}
# Definities
my $Bestandsnaam='/var/log/httpd/access_log';
my $ZoekTerm;
my $Paniek =0;
# Open het accesslog bestand
$Paniek=open LOGFILE,$Bestandsnaam;
if (!$Paniek)
{
print "Help! Er ging iets mis met het openen van het bestand!\n";
exit;
}
# Vraag input
print "Waar gaan we naar zoeken? ";
$ZoekTerm = <STDIN>;
# Vieze enters eraf slopen
chomp $ZoekTerm;
# Lees het bestand regel voor regel
while (<LOGFILE>)
{
CheckLine $ZoekTerm,$_;
}
close LOGFILE;
Het kan allemaal vast veel makkelijker en mooier, maargoed
quote:Cooool!... gefeliciteerd!!!Op vrijdag 11 juni 2004 08:50 schreef TimberWolf het volgende:
Hah. Net mijn eerste Perl programma gemaakt. Ik ben zo blij
[ code ]
Nou, dat we regexps op een scalar kunnen loslaten is natuurlijk al erg mooi, maar nog beter,
we kunnen informatie uit de scalar halen met dezelfde regexp.
Wanneer je ( en ) om een item in je regexp zet zal deze gecaptured worden naar een Perl
variabele... de eerste () komt in $1, de tweede $2, etc...
Ik zal dit laten zien aan de hand van het loopje uit het laatste voorbeeld:
---
for (@Data)
{
# We willen weten WIE ons bezocht, om hoe laat, en welke browser deze persoon gebruikte
# Dus we zetten ( en ) om de velden die die informatie bevatten:
if (/(\S+)\s+\S+\s+\S+\s+\[(.*)\]\s+".*"\s+\d+\s+\d+\s+".*"\s+"(.*)"/)
{
my ($IPaddress,$Time,$Browser)=($1,$2,$3);
# werkte het ?:
print "Op $Time bezocht een gebruiker met adres $IPaddress deze site met de volgende browser: $Browser\n";
};
};
En testen:
ChOas-Computer:~ choas$ ./les17
Op 09/Jun/2004:15:24:59 +0200 bezocht een gebruiker met adres 213.84.91.93 deze site met de volgende browser: PHP/4.2.2
Op 09/Jun/2004:15:24:59 +0200 bezocht een gebruiker met adres 213.84.91.93 deze site met de volgende browser: PHP/4.2.2
Op 09/Jun/2004:15:24:59 +0200 bezocht een gebruiker met adres 209.237.238.176 deze site met de volgende browser: ia_archiver
Op 09/Jun/2004:17:58:46 +0200 bezocht een gebruiker met adres 218.24.32.56 deze site met de volgende browser: -
Op 09/Jun/2004:19:39:10 +0200 bezocht een gebruiker met adres 192.168.0.9 deze site met de volgende browser: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)
Op 09/Jun/2004:19:39:10 +0200 bezocht een gebruiker met adres 192.168.0.9 deze site met de volgende browser: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)
Op 09/Jun/2004:19:39:10 +0200 bezocht een gebruiker met adres 192.168.0.9 deze site met de volgende browser: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)
Op 09/Jun/2004:19:39:11 +0200 bezocht een gebruiker met adres 192.168.0.9 deze site met de volgende browser: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)
Op 09/Jun/2004:19:39:13 +0200 bezocht een gebruiker met adres 192.168.0.9 deze site met de volgende browser: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)
Op 09/Jun/2004:19:39:17 +0200 bezocht een gebruiker met adres 192.168.0.9 deze site met de volgende browser: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)
ChOas-Computer:~ choas$
Nou... is dat handig, of is dat handig ????
---
my %Browsers;
for (@Data)
{
# We willen weten WIE ons bezocht, om hoe laat, en welke browser deze persoon gebruikte
# Dus we zetten ( en ) om de velden die die informatie bevatten:
if (/(\S+)\s+\S+\s+\S+\s+\[(.*)\]\s+".*"\s+\d+\s+\d+\s+".*"\s+"(.*)"/)
{
my ($IPaddress,$Time,$Browser)=($1,$2,$3);
# werkte het ?:
$Browsers{$Browser}{$IPaddress}++;
# print "Op $Time bezocht een gebruiker met adres $IPaddress deze site met de volgende browser: $Browser\n";
};
};
for my $Browser (keys %Browsers)
{
print "Gebruikers met een $Browser browser:\n";
print "$_ : $Browsers{$Browser}{$_} keer\n" for keys %{$Browsers{$Browser}};
};
Output:
ChOas-Computer:~ choas$ ./les17b
Gebruikers met een Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1) browser:
192.168.0.9 : 6 keer
Gebruikers met een ia_archiver browser:
209.237.238.176 : 1 keer
Gebruikers met een PHP/4.2.2 browser:
213.84.91.93 : 2 keer
Gebruikers met een - browser:
218.24.32.56 : 1 keer
ChOas-Computer:~ choas$
[ Bericht 96% gewijzigd door ChOas op 11-06-2004 16:17:44 ]
Leuk dit topic!
Geen vrees, hierna kom ik terug en gaan we gewoon door.
Misschien ben ik in staat om tussendoor een paar vraagjes te beantwoorden, maar
reken er niet op. Ik heb al gezien dat er hier al een x aantal andere Perl programeurs
zijn die in die gevallen ook kunnen helpen... thanks
Tot de volgende les!
Als ik klaar ben met me repetitieweek ga ik ook maar eens Perl proberen
quote:Je hebt hardgenoeg gezogen schouderklopjes :')Op woensdag 9 juni 2004 22:43 schreef ChOas het volgende:
Oh, en ik vraag me af wie ik moet pijpen voor een fucking schouderklopje, maar daar kom ik nog wel achter
quote:Jij ook al?Op zaterdag 12 juni 2004 10:53 schreef Ferdy het volgende:
Zeer interessant topic!
Als ik klaar ben met me repetitieweek ga ik ook maar eens Perl proberen
.Na de 22e ga ik lekker klooien
ik snap d'r nu geen f*ck van, maar dat komt vast als ik er aan begin. ken nu geen enkele programeertaal trouwens
Dus dat je net zoals bij Maple kan zeggen van ik wil dat random 1 of 2 gekozen wordt (of 0 of 1, etc
) en een scalar wordt? quote:Dit is de Fisher-Yates shuffle.use strict;
sub fisher_yates_shuffle {
my $list = shift;
my $i = @{$list};
while ( $i-- ) {
my $j = int rand( $i );
@{$list}[$i,$j] = @{$list}[$j,$i];
}
}
Als je nu een list maakt
quote:En daar de functie op loslaat...my @numbers = ( 0 .. 2 );
fisher_yates_shuffle(\@numbers);
quote:woeiiiiiimy $my_number = shift @numbers;
"Het getal is $my_number";
oftewel:
quote:sub fisher_yates_shuffle {
my $list = shift;
my $i = @{$list};
while ( $i-- ) {
my $j = int rand( $i );
@{$list}[$i,$j] = @{$list}[$j,$i];
}
}
my @numbers = ( 0 .. 2 );
fisher_yates_shuffle(\@numbers);
my $my_number = shift @numbers;
"Het getal is $my_number";
quote:Goed gevonden! maar fisher-yates is een beetje overkill om alleen een random getal te vinden. Je gebruikt het eerder om een lijst te randomizen...Op zondag 13 juni 2004 02:32 schreef CybErik het volgende:
Ik heb misschien wel een manier gevonden
[..]
Dit is de Fisher-Yates shuffle.
Als je nu een list maakt
[..]
En daar de functie op loslaat...
[..]
woeiiiiii
oftewel:
[..]
kijk maar:
---
#!/usr/bin/perl -w
use strict;
sub fisher_yates_shuffle {
my $list = shift;
my $i = @{$list};
while ( $i-- ) {
my $j = int rand( $i );
@{$list}[$i,$j] = @{$list}[$j,$i];
}
}
my @List=('a'..'z');
print @List,"\n";
fisher_yates_shuffle \@List;
print @List,"\n";
---
ChOas-Computer:~ choas$ ./randfok
abcdefghijklmnopqrstuvwxyz
zpkqbiyluevtfdwhrmxoajsgnc
wat je moet weten is dat rand <getal> een random getal tussen de 0 en <getal> terug geeft... is
handig, maar het getal is een float, dus dat betekent dat je bijvoorbeeld ook 1.463434242 terug kan krijgen.
Hier heeft Perl de functie int voor, die neemt dan alleen het gedeelte voor de .
Wil je nu bijvoorbeeld een paar getallen tussen de 0 en 10 doe je dit zo:
---
#!/usr/bin/perl -w
use strict;
for (1..5)
{
my $Number=int rand 11;
print "$Number\n";
};
---
Output:
ChOas-Computer:~ choas$ ./randfok
3
10
9
4
2
ChOas-Computer:~ choas$
Iemand zin om de fisher-yates shuffle uit te leggen ? ... zo niet heb ik er misschien later vandaag wel tijd voor, maar ik beloof niets...
[ Bericht 1% gewijzigd door ChOas op 13-06-2004 05:15:16 ]
quote:Zo ingewikkeld is het niet. Waar het in feite op neer komt is dat je de lijst afloopt en ieder element met een willekeurig gekozen ander element omwisselt. (kleine verandering op fisher-yates tov ChOas:while($i--) wordt while(--$i), het is niet interresant om element 0 met zichzelf te wisselenOp zondag 13 juni 2004 05:07 schreef ChOas het volgende:
Iemand zin om de fisher-yates shuffle uit te leggen ?
).sub fisher_yates_shuffle {
# $list is een reference naar de array die je wil shuffelen
my $list = shift;
# het aantal elementen in de array wordt toegekent aan $i
my $i = @{$list};
# loop door de lus van $i-1 tot en met 1 (array loopt van 0...aantal elementen, maar laatste element
# shufflen met zichzelf heeft weinig zin
while ( --$i ) {
# genereer een random getal tussen 0 en $i
my $j = int rand( $i );
# @{$list}[$j,$i] geeft een lijst met 2 waardes: @{$list}[$j] en @{$list}[$i]
# deze wordt toegekend aan de lijst op posities $i en $j
# $list is een referentie en daarom schrijven we @{$list}[..]
@{$list}[$i,$j] = @{$list}[$j,$i];
}
}
Een voorbeeld shuffle:
lijst bij start: 'a','b','c','d'
quote:iteratie 1: i=3, j=2 en de lijst wordt a b d c
iteratie 2: i=2, j=1 en de lijst wordt a d b c
iteratie 3: i=1, j=0 en de lijst wordt d a b c
quote:iteratie 1: i=3, j=0 en de lijst wordt d b c a
iteratie 2: i=2, j=1 en de lijst wordt d c b a
iteratie 3: i=1, j=0 en de lijst wordt c d b a
De vraag: Schrijf een functie die 4 letters als argumenten meekrijgt en alle mogelijke combinaties van deze letters afdrukt.
dus
AAAA
AAAB
AAAC
AAAD
AABA
AABB
...
ik weet wel hoe het moet, het klinkt eenvoudig, maar ik kom er niet uit
quote:wat dacht je hier van:Op donderdag 24 juni 2004 17:29 schreef -DailaLama- het volgende:
Weten jullie hier wat op?
De vraag: Schrijf een functie die 4 letters als argumenten meekrijgt en alle mogelijke combinaties van deze letters afdrukt.
dus
AAAA
AAAB
AAAC
AAAD
AABA
AABB
...
ik weet wel hoe het moet, het klinkt eenvoudig, maar ik kom er niet uit
sub combi {
my @letters = split(//, $_[0]);
foreach my $a (@letters) {
foreach my $b (@letters) {
foreach my $c (@letters) {
foreach my $d (@letters) {
print "$a$b$c$d\n";
}
}
}
}
}
misschien wat omslachtig, maar het werkt
Ik ga er eens aan beginnen.
Sommige oenen draaien nog steeds databases op Windows
, dus is wel handig als je scripts kunt maken die op unix en op windows draaien. Was al langer van plan eens naar Perl te kijken.Ik ga het eens proberen
quote:Omslachtig? Dat is nog niets ...Op donderdag 24 juni 2004 19:40 schreef daReaper het volgende:
[..]
wat dacht je hier van:
sub combi {
my @letters = split(//, $_[0]);
foreach my $a (@letters) {
foreach my $b (@letters) {
foreach my $c (@letters) {
foreach my $d (@letters) {
print "$a$b$c$d\n";
}
}
}
}
}
misschien wat omslachtig, maar het werkt
Ik had er gister een hele ingewikkelde bagger van met for en while lusjes.
Bedankt!
Waarom werkt dit veelgebruikte voorbeeld op internet niet?:
#!/usr/bin/perl
use strict;
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);
print $mon;
Overigens doet ie het wel als ik use strict uit zet. En als ik localtime in een array dump (my @ltime = localtime()) doet ie het ook natuurlijk. Maar wat is er zo fout aan het gegeven voorbeeld?
Is 'use strict' perse noodzakelijk?
quote:use strict is datgene wat mist in php, een voorwaarde voor een serieuze taal, de constructie die mannen van jongens scheidt en/of schijdtOp maandag 5 juli 2004 09:29 schreef TimberWolf het volgende:
Is 'use strict' perse noodzakelijk?
Met strict moet je alle variabelen declareren bijvoorbeeld dmv my of local. In jouw voorbeeld declareer je variabelen niet en dus is dat fout.
#!/usr/bin/perl -w
use strict;
my($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);
print $mon;
zal dus wel werken. (Die -w bij de eerste regels is om wat meer "info" te gereneren, daarnaast kun je ook "use warnings" gebruiken.)
quote:MaarEn als ik localtime in een array dump (my @ltime = localtime()) doet ie het ook natuurlijk.
my @ltime = localtime();
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)=@ltime
zal niet werken, maar
my @ltime = localtime();
my($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)=@ltime wel
quote:output = "51010"#!/usr/bin/perl -w
use strict;
my $a = 5;
sub functie1 {
$a = 10;
}
sub functie2 {
my $a = 20;
}
print $a;
functie1();
print $a;
functie2();
print $a;
quote:output = "51020"#!/usr/bin/perl -w
$a = 5;
sub functie1 {
$a = 10;
}
sub functie2 {
$a = 20;
}
print $a;
functie1();
print $a;
functie2();
print $a;
Inmiddels heb ik mijn eerste echt nuttige script werkend 160 regels code (om en nabij) inclusief commentaar. Doet automatisch een bos plaatjes downloaden van een website (dagelijks dus) en daar automatisch een eigen pagina en archieven van maken enzo. Geeft vast nogal load op de server van de ontvangende partij, dus ik plaats um maar niet Ben ik overigens de enige die chOas mist?
quote:sleep int rand(3);Op dinsdag 6 juli 2004 14:55 schreef TimberWolf het volgende:
Geeft vast nogal load op de server van de ontvangende partij
oftewel wacht 0,1 of 2 seconden voor je het volgende plaatje ophaalt.
quote:We missen hem allemaalBen ik overigens de enige die chOas mist?
quote:Ah, lief plan. Bouwen we wel in !Op dinsdag 6 juli 2004 15:35 schreef devzero het volgende:
sleep int rand(3);
oftewel wacht 0,1 of 2 seconden voor je het volgende plaatje ophaalt.
Overigens zullen ze ook minder blij zijn met de verminderde bannerviews, but I could not care less
quote:*snif*We missen hem allemaal
and counting ...use strict;
$|++;@_=split//,
"|Just Another Perl Hacker|";
sub ll{select(undef,undef,undef,
0.05);}; my @l;$"="";for(0..12){
ll;splice@l,@l/2, 0,@_[$_,-$_-1]
;print' 'x13,"@l\r";};while (1){
@l=@_;for(0..11){pop@l;shift@l;
ll;print "\r",' 'x(13+$_)," @l "
;};ll;ll;ll;for(reverse 1..12){
splice@l,-1,0,$_[$_-1];splice@l,
0,0,$_[-$_-1];ll;print"\r",' 'x(
13+$_), "@l \b\b\b ";};ll;ll;
ll;@_=reverse@_;};
Oftewel... IK BEN ER WEER!!!!!
Zo... vragen ? .... wat gaan we doen ? ... Ik heb er weer zin in
[ Bericht 8% gewijzigd door ChOas op 06-07-2004 21:02:46 ]
[code]
\\\\\\\'test\\\\\\\'
[/code]
[php]
\\\'test2\\\'
[/php]
Ooooooooooooooooh wat sucked dat verschrikkelijk... zo is er geen beginnen aan
Dus... wat gaan we nu doen ?
quote:OOOp dinsdag 6 juli 2004 21:03 schreef ChOas het volgende:
escape probleem is gefixed, bovenstaande obfuscated code werkt weer
Dus... wat gaan we nu doen ?
quote:Op dinsdag 6 juli 2004 21:23 schreef daReaper het volgende:
[..]
OO
Ja, jij bent er wel klaar voor
OO it is...
Maar dan moet ik wel gaan vooorbereiden...
Okay... bij geen tegenstemmen is de volgende les: Packages!!!!!!!
Eeeerm... wacht... misschien moet ik eerst iets meer over scope gaan uitleggen (zag dat jullie dat ook al een begin gemaakt hadden)
Eerst scope, en dan packages/OO Perl
(Jah, allemaal dingen die ik inmiddels zelf ontdekt heb
)quote:Die dingen pak ik er ook nog wel even bijOp dinsdag 6 juli 2004 23:16 schreef TimberWolf het volgende:
En wie weet iets over het outputten van HTML? De 'print <<DINGES;" constructie? Het escapen van lastige codes? Wanneer wel en wanneer niet escapen enzo? Het verschil tussen "$string" en '$string'?
(Jah, allemaal dingen die ik inmiddels zelf ontdekt heb
*noteert 'here docs', escapen codes, interpolatie*
Allereerst: Here documents
Stel nou dat ik wat HTML uit een Perl programma wil printen... dan kan dat zo:
---
#!/usr/bin/perl -w
use strict;
my $Name='ChOas';
print "<HTML>\n";
print " <H1> Hi there, my name is $Name </H1>\n";
print "</HTML>\n";
---
Nou, dat ziet er makkelijk uit (had ook op 1regel kunnen staan, maar dit vind ik netter...
Output:
ChOas-Computer:~/fok choas$ ./les18
<HTML>
<H1> Hi there, my name is ChOas </H1>
</HTML>
Dat het werkt hadden we wel kunnen raden, maar de HTML code is niet echt duidelijk te zien
tussen de code dus dat sucked... een oplossing daarvoor zijn zogenaamde 'here documents'
Bij een here document geef je door een markering bij de print aan tot waar je wil printen, wanneer Perl dan de markering die je hebt opgegeven tegenkomt stopt het printen...
Als voorbeeldmarkering gebruik ik hier: EINDHTML
---
print <<ENDHTML;
<HTML>
<H1> Hi there, my name is $Name </H1>
</HTML>
ENDHTML
---
En je zal zien dat de output gelijk is aan het vorige voorbeeld... Je HTML code is zo veel beter te zien, en te onderhouden. Dit zijn dus here documents in het kort...
Nu iets over interpolatie.
We hebben gezien dat we de meeste waarden van dingen (behalve getallen) meestal tussen dubbele quotes zetten, dubbele quotes betekent dat Perl variabelen in die string interpoleert, en ze vervangt door de waarde van die variabelen. Wanneer we echter het zooitje tussen enkele quotes gooien dan wordt dit niet gedaan. Zie dit voorbeeld:
---
#!/usr/bin/perl -w
use strict;
my $Name='ChOas';
print "My name is $Name\n";
print 'My name is $Name\n';
---
Output:
ChOas-Computer:~/fok choas$ ./les19
My name is ChOas
My name is $Name\nChOas-Computer:~/fok choas$
Je ziet dus uit het voorgaande voorbeeld dat zelfs de \n niet naar een enter wordt geinterpoleerd, maar echt als \ n gezien wordt.
Nog een voorbeeldje:
---
#!/usr/bin/perl -w
use strict;
my @Colour=('Red','Black','Grey','Green');
print "Colour-double_quote: @Colour";
print "\n";
print 'Colour-single_quote: @Colour';
print "\n";
print 'Colour-no_quote: ';
print @Colour;
print "\n";
---
Ik heb de losse enters er even tussen gezet om het wat duidelijker te maken.
Output:
ChOas-Computer:~/fok choas$ ./les19
Colour-double_quote: Red Black Grey Green
Colour-single_quote: @Colour
Colour-no_quote: RedBlackGreyGreen
ChOas-Computer:~/fok choas$
Hier zie je dus dat Perl een array met dubbele quotes interpoleert door een spatie tussen de elementen te zetten, met gebruik van een enkele quote wordt er niets geinterpoleerd, en zonder quotes worden de waarden uit de array zonder spatie afgedrukt.
Nou, dat was alvast 2 vragen
En dan nu... hoe ga ik in godsnaam uitleggen wat je wel en niet moet escapen ???
Eeerm mijn tip: Probeer eerst zonder iets te escapen, en werkt dat niet, doe het dan wel
Sorry, maar er zijn ZO VEEL verschillende gevallen... ik kan je alleen maar vertellen dat je er gevoel voor moet krijgen. Op een gegeven moment weet je precies wat je waar moet gebruiken.
Als ik wat goeds kan verzinnen over escapen laat ik het weten... maar vooralsnog gaan we hierna eerst het begrip 'scope' behandelen... dingen weten over scope is handig voor wanneer we straks *diepe zucht* packages en OO-Perl gaan behandelen...
let er op dat je het einde aan het begin van de regel zet:
goed:
-----
print <<END;
<html>
<h1>tekstje</h1>
</html>
END
-----
goed fout:
-----
print <<END;
<html>
<h1>tekstje</h1>
</html>
END
-----
Dat "END", of wat je dan ook hebt gekozen als delimiter, moet dus aan het begin van de regel staan
Maarrrrrr... ik proberen vanavond het eerste gedeelte van object georienteerd programeren in Perl te posten...
GrtZ!
*gespannen afwacht*
"Trust in me... said the devil" [ChOas]
We kunnen het hierna veel ingewikkelder maken, maar eerst een korte uitleg wat OO programeren eigenlijk is.
Wat is een object ? ... nou, kijk om je heen, alles bestaat uit objecten, objecten hebben eigenschappen die verbonden zijn aan een object (e.g. een blikje bier (*grin*, ja ik ben om me heen aan het kijken) kan je weggooien, crushen, leegdrinken. Een tv kan je ook weggooien, maar crushen wordt al wat lastiger, en leegdrinken raad ik echt niet aan. Wat het echter wel allebei zijn is gebruiksvoorwerpen.
Dus als we object georienteerd gaan denken hebben we een classe van 'gebruiksvoorwerpen' waar 'blikjes' en 'tvs' deel van uitmaken. blikjes hebben de eigenschap dat ze leeggedronken kunnen worden, en tvs hebben de eigenschap dat ze aan en uit gezet kunnen worden.
Volgen we het nog ?
Mooi, ga ik ff een biertje halen.
... Zo...
Voor de rest van deze uitleg ga ik gebruikmaken van Randal Schwartz's perlboot (OO programeren voor beginners) het zal geen rechtstreekse vertaling zijn, maar ik ga zijn voorbeelden gebruiken, want het tekent hier zo lastig op een bord
.Op de boerderij!
We gaan een aantal subroutines maken om het geluid van verschillende dieren aan te geven, dat doen we als volgt... eerste gedeelte van de naam is de naam van het dier, dan :: en dan het woord geluid (waarom we het zo doen kom ik nog op). Al in de war ? ... Misschien maakt dit het duidelijk:
---
#!/usr/bin/perl -w
use strict;
sub Schaap::geluid
{
print "Een schaap maakt dit geluid: Beeeeeeh\n";
};
sub Koe::geluid
{
print "Een koe maakt dit geluid: Boeoeoeoe\n";
};
sub Kip::geluid
{
print "Een kip maakt dit geluid: Tok Tok Tok\n";
};
Schaap::geluid
Koe::geluid
Kip::geluid
---
BRILJANT!!!... ik kan niet anders zeggen!!!... En de output:
---
ChOas-Computer:~/fok choas$ ./oo1
Een schaap maakt dit geluid: Beeeeeeh
Een koe maakt dit geluid: Boeoeoeoe
Een kip maakt dit geluid: Tok Tok Tok
ChOas-Computer:~/fok choas$
---
Tot zover niets aan de hand...
Dus laten we wat nieuws proberen...
---
#!/usr/bin/perl -w
use strict;
#no strict 'refs';
sub Schaap::geluid
{
print "Een schaap maakt dit geluid: Beeeeeeh\n";
};
sub Koe::geluid
{
print "Een koe maakt dit geluid: Boeoeoeoe\n";
};
sub Kip::geluid
{
print "Een kip maakt dit geluid: Tok Tok Tok\n";
};
for my $Dier ('Koe','Schaap','Koe','Schaap','Kip')
{
&{$Dier . "::geluid"};
};
---
Wat je moet weten is dit... we hebben het al gehad over de-refereren toch ? ... no, zoals je een scalar mer ${} de-refereert, een array met @{}, en een hash met %{} de-refereer je een subroutine met &{}.
Dus in het loopje wat je ziet zal elke keer een nieuw dier voor $_ worden ingevuld, en de functie die daar bij hoort worden uitgevoerd.
...
NOT! Jullie die deze code hebben geprobeert zullen zien dat Perl zo'n soort klacht geeft wanneer we dit proberen: Can't use string ("Koe::geluid") as a subroutine ref while "strict refs" in use at ./oo1 line 22.
Om dit voorbeeld toch te laten werken voegen spelen we even vals, en voegen we "no strict 'refs'" toe onder 'use strict' ... tis valsspelen, en de mensen die geinteresseerd zijn waarom we dit moeten doen moeten het maar vragen...
Maar.. we zien dat de code werkt.
Latgen we het netter doen... Jullie hebben namelijk net jullie eerste 3 objecten gemaakt...
IS DAT ZO CHOAS ????
Ja klas, dat is zo
Door de dubbele punt in de functienaam geef je eigenlijk aan: object :: eigenschap ...
Dat is cool!.. en het leuke is dat je ook direct van eigenschappen gebruik kan maken zonder dat omslachtige de-refereren (waar use strict zo over ging zeiken)
Een eigenschap van een object gebruiken doen we zo object->eigenschap.
Even laten zien:
---
#!/usr/bin/perl -w
use strict;
sub Schaap::geluid
{
print "Een schaap maakt dit geluid: Beeeeeeh\n";
};
sub Koe::geluid
{
print "Een koe maakt dit geluid: Boeoeoeoe\n";
};
sub Kip::geluid
{
print "Een kip maakt dit geluid: Tok Tok Tok\n";
};
for my $Dier ('Koe','Schaap','Koe','Schaap','Kip')
{
$Dier->geluid;
};
---
Output:
---
ChOas-Computer:~/fok choas$ ./oo1
Een koe maakt dit geluid: Boeoeoeoe
Een schaap maakt dit geluid: Beeeeeeh
Een koe maakt dit geluid: Boeoeoeoe
Een schaap maakt dit geluid: Beeeeeeh
Een kip maakt dit geluid: Tok Tok Tok
ChOas-Computer:~/fok choas$
---
Nou, dat was het allereerste gedeeltje object georienteerd programeren... deze voorbeelden waren nog totaal nutteloos, maar ik zal later laten zien hoe we door een nieuw object 'Dier' te maken we hier de code kunnen vereenvoudigen, en nog veel meer leuke dingen kunnen doen.
Nu eerst mijn biertje opdrinken, en misschien zo nog een deel
Jaaaaa ??
Wanneer we de eigenschap van een object aanroepen, staat er dan net zoals bij een functie wat in
@_ ???? ...
Nou... laten we eens kijken:
---
[i]#!/usr/bin/perl -w
use strict;
sub Schaap::geluid
{
print "\@_ is: @_\n";
print "Een schaap maakt dit geluid: Beeeeeeh\n";
};
sub Koe::geluid
{
print "\@_ is: @_\n";
print "Een koe maakt dit geluid: Boeoeoeoe\n";
};
sub Kip::geluid
{
print "\@_ is: @_\n";
print "Een kip maakt dit geluid: Tok Tok Tok\n";
};
for my $Dier ('Koe','Schaap','Kip')
{
$Dier->geluid;
};
---
En de output:
---
ChOas-Computer:~/fok choas$ ./oo2
@_ is: Koe
Een koe maakt dit geluid: Boeoeoeoe
@_ is: Schaap
Een schaap maakt dit geluid: Beeeeeeh
@_ is: Kip
Een kip maakt dit geluid: Tok Tok Tok
ChOas-Computer:~/fok choas$
---
Hmmmmmmm is dat eens interessant, het eerste elemennt van @_ is het type object wat we aanroepen...
Laten we de code eens zo herschrijven:
---
#!/usr/bin/perl -w
use strict;
sub Schaap::geluid
{
my $DitDier=shift;
print "Een $DitDier maakt dit geluid: Beeeeeeh\n";
};
sub Koe::geluid
{
my $DitDier=shift;
print "Een $DitDier maakt dit geluid: Boeoeoeoe\n";
};
sub Kip::geluid
{
my $DitDier=shift;
print "Een $DitDier maakt dit geluid: Tok Tok Tok\n";
};
for my $Dier ('Koe','Schaap','Kip')
{
$Dier->geluid;
};
---
Met de output:
---
ChOas-Computer:~/fok choas$ ./oo2
Een Koe maakt dit geluid: Boeoeoeoe
Een Schaap maakt dit geluid: Beeeeeeh
Een Kip maakt dit geluid: Tok Tok Tok
ChOas-Computer:~/fok choas$
---
Hmmmmmm... ziet er goed uit... de functies van de dieren gaan meer en meer op elkaar lijken...
Nog een stapje verder, we maken voor elk dier een subroutine 'lawaai' welke alleen maar het lawaai van het dier teruggeeft... maarja, elke subroutine 'lawaai' moet iets specifieks voor een bepaald dier terug geven. en hoe weet Perl nou welk 'lawaai' bij welk dier hoort ?
Antwoord: packages...
Ik ga even niet in op de details (vragen staat vrij), maar een package is een specifieke namespace voor een object waarbinnen alle variabelen en functies alleen maar toepassing hebben op dat specifieke object (heb je 'm nog?) ... is zo heel moeilijk uitleggen dit, maar neem dit van me aan:
We zeggen eigenlijk dat een package een object is... dus een Koe omschrijven we zo:
{
package Schaap;
sub Lawaai { return 'Beeeeeeh' };
sub Geluid
{
my $DitDier=shift;
print "Een $DitDier maakt dit geluid: ", $DitDier->Lawaai, "!\n";
}
};
Dus het object Schaap heeft 2 aan zich verbonden eigenschappen: Lawaai en Geluid.
Weer even de totale code zoals we hem dan nu hebben:
---
#!/usr/bin/perl -w
use strict;
{
package Schaap;
sub Lawaai { return 'Beeeeeeh' };
sub Geluid
{
my $DitDier=shift;
print "Een $DitDier maakt dit geluid: ", $DitDier->Lawaai, "!\n";
}
};
{
package Koe;
sub Lawaai{ return 'Boeoeoeoe' };
sub Geluid
{
my $DitDier=shift;
print "Een $DitDier maakt dit geluid: ", $DitDier->Lawaai, "!\n";
}
};
{
package Kip;
sub Lawaai{ return 'Tok Tok Tok' };
sub Geluid
{
my $DitDier=shift;
print "Een $DitDier maakt dit geluid: ", $DitDier->Lawaai, "!\n";
}
};
for my $Dier ('Koe','Schaap','Kip')
{
$Dier->Geluid;
};
---
Het lijkt wel of we alleen maar meer en meer code schrijven he ? ... klopt ... maar wat valt er nou op aan de code die we nu hebben ?
Nou... dat Geluid universeel is... stel je voor dat we een varken toevoegen, verandert Lawaai wel, maar Geluid is ook weer voor een varken precies hetzelfde... Sterker nog... Geluid zou voor elk dier hetzelfde zijn, het is alleen maar het Lawaai wat varieert...
Wacht eens even... ELK DIER produceert geluid, dus geluid is eigenlijk een hogere functie welke dieren met elkaar delen!!!
DAAR GAAN WE GEBRUIK VAN MAKEN!!!
@ISA
Dit moet je lezen als IS A (Is een) ... We gaan een package 'Dier' maken met als eigenschap 'Geluid', en dan hoeven wel alleen maar tegen de kip, koe, en het schaap te zeggen dat ze een dier zijn!!!
Dus we gaan zeggen een Koe IS EEN Dier...
Verward ?
De code:
---
#!/usr/bin/perl -w
use strict;
{
package Dier;
sub Geluid
{
my $DitDier=shift;
print "Een $DitDier maakt dit geluid: ", $DitDier->Lawaai, "!\n";
}
};
{
package Schaap;
@Schaap::ISA='Dier';
sub Lawaai { return 'Beeeeeeh' };
};
{
package Koe;
@Koe::ISA='Dier';
sub Lawaai{ return 'Boeoeoeoe' };
};
{
package Kip;
@Kip::ISA='Dier';
sub Lawaai{ return 'Tok Tok Tok' };
};
for my $Dier ('Koe','Schaap','Kip')
{
$Dier->Geluid;
};
---
Dit heet erven, sinds een Koe een dier is, erft een Koe de eigenschap 'Geluid' van Dier...
Tot nu toe heb je hier nog helemaal niets aan, maar binnenkort (waarschijnlijk zaterdag ochtend) zal ik het volgende deel schrijven en dan gaan we nog wat leuke en interessante dingetjes bekijken bij objecten...
Ik weet dat deze laatste 2 dingen vrij lastig te volgen waren, maar geloof me, het gaat echt logischer worden...
Komende dagen heb ik hopelijk wel tijd om vragen te beantwoorden, dus mocht er iets zijn: Vraag het
Ik ga werken, kijk vanavond wel of er vragen zijn, en MISSCHIEN (afhankelijk van alcohol gebruik nog een 3e deel OO programeren...
quote:Hebben we het over de-refereren gehad?Op woensdag 14 juli 2004 21:11 schreef ChOas het volgende:
Wat je moet weten is dit... we hebben het al gehad over de-refereren toch ? ... no, zoals je een scalar mer ${} de-refereert, een array met @{}, en een hash met %{} de-refereer je een subroutine met &{}.
Verder denk ik gewoon duidelijk. Is alleen in deze context wel lastig om te zien wat daar een praktische toepassing van zou zijn. De laatste keer dat ik snel moest uitzoeken wat voor geluid een boerderijdier maakte was ik ongeveer 3
Niets ten nadele overigens, de uitleg is prima. Misschien is het handig om bij dit soort onderwerpen aan te geven waarvoor het gebruikt kan worden? (Template engines bijvoorbeeld)Ben blij dat ik het concept van OO al begrijp
Als ik vanmiddag terug kom van mn werk ga ik het meteen ff een beetje uitproberen!
thanks Ch0as!
Hierin wordt heel gedetailleerd het wat, hoe en waarom uitgelegd. Da's waar ik het zelf ook uit heb geleerd
quote:JaOp donderdag 15 juli 2004 08:11 schreef TimberWolf het volgende:
[..]
Hebben we het over de-refereren gehad?
:quote:Uit: Leer hier Perl (8 Juni)Antwoord: de-refereren
Voor een array als volgt: @{$ArrayRef};
Voor een hash: %{$HashRef};
quote:Ho, pardon
Was niet blijven hangen Hele OO gebeuren fascineert me mateloos. Hergebruiken van code, en het hele object gebeuren, super!
Los vraagje: Gaan we het op een gegeven moment ook nog over sockets hebben? Lijkt me namelijk ook wel stoer
quote:Ja, we gaan het over sockets hebbenOp vrijdag 16 juli 2004 00:25 schreef TimberWolf het volgende:
[..]
Ho, pardon
Hele OO gebeuren fascineert me mateloos. Hergebruiken van code, en het hele object gebeuren, super!
Los vraagje: Gaan we het op een gegeven moment ook nog over sockets hebben? Lijkt me namelijk ook wel stoer
... Komt hierna Bij het hoofdstuk 'gebruik van modules' ... Sockets, CGI, etc, etc, etc... Ik zit er over te denken om (lijkt me leuk samen met mensen die het leuk lijken) een IRC-bot te bouwen ofzo... dus dat jullie features aandragen en ideeeen om ze te implementeren en dan kijken hoe dat het beste te doen, inclusief webstats bijhouden enzo...
Lijkt jullie dat wat ?
quote:Heb ik helaas al gedaanOp vrijdag 16 juli 2004 06:29 schreef ChOas het volgende:
[..]
Ja, we gaan het over sockets hebben
Bij het hoofdstuk 'gebruik van modules' ... Sockets, CGI, etc, etc, etc... Ik zit er over te denken om (lijkt me leuk samen met mensen die het leuk lijken) een IRC-bot te bouwen ofzo... dus dat jullie features aandragen en ideeeen om ze te implementeren en dan kijken hoe dat het beste te doen, inclusief webstats bijhouden enzo...
Lijkt jullie dat wat ?
In low-level sockets nog wel
Eentje die tegerlijk ook nog allemaal ftpconnecties open had enzo. Met nonblocking sockets, waarbij hij ze allemaal 1 voor 1 steeds langs ging om te kijken of er nog iets nieuws wasquote:Op vrijdag 16 juli 2004 08:34 schreef daReaper het volgende:
[..]
Heb ik helaas al gedaan
In low-level sockets nog wel
Okay, wat wil JIJ dan doen ?
Ik probeer ook maar wat te verzinnen, input is welkom hoor...
Hou je er wel rekening mee dat er een aantal mensen zijn die dit topic volgen tot 1.5 maand
geleden dachten dat iemand het over een brillenzaak had wanneer je 'Perl' zei ?
quote:Nee sockets zijn goed hoorOp vrijdag 16 juli 2004 08:51 schreef ChOas het volgende:
[..]
Okay, wat wil JIJ dan doen ?
Ik probeer ook maar wat te verzinnen, input is welkom hoor...
Hou je er wel rekening mee dat er een aantal mensen zijn die dit topic volgen tot 1.5 maand
geleden dachten dat iemand het over een brillenzaak had wanneer je 'Perl' zei ?
Ik geef alleen te kennen dat ik ze al ken Mij hoor je verder niet klagen Je doet het zeer goed. Iedereen wil altijd maar PHP leren, omdat het makkeliker is, terwijl Perl gewoon beter is. Goeie zaak 
quote:Als er geen select-achtige (ala select(2)) functie in perl zit, is het imho geen geschikte taal voor socketsOp vrijdag 16 juli 2004 08:34 schreef daReaper het volgende:
nonblocking sockets, waarbij hij ze allemaal 1 voor 1 steeds langs ging om te kijken of er nog iets nieuws was
en die is er gelukkig wel, scheelt een hoop werk Voor het vervolg van de cursus zou gedacht kunnen worden aan bv
Iemand nog meer ideeen?
irc.fok.nl / #leerhierperl
Ben een beetje aan het experimenteren daar
met dat gefork enzo
die mag ook nog wel
Modules, roll your own
(Net mijn eerste gemaakt, yay!)Kort langs de belangrijke modules (LWP, CGI, TK, enz)
Sockets
Overigens lijkt me het bouwen van een IRC botje (En dan meteen met stat-logging naar een database, heb je dat ook gehad) erg leuk. Ik wil, tijd en werk permitterend, zelf wel helpen knutselen
Misschien leuk om eens een perl script van een van de meelezers (ik heb wel wat liggen ook) door te werken om te kijken hoe het beter kan ofzo?
quote:Die van mijn site kan ongetwijfeld beterOp zaterdag 17 juli 2004 00:35 schreef TimberWolf het volgende:
Qua dingen die lang kunnen komen:
Modules, roll your own
Kort langs de belangrijke modules (LWP, CGI, TK, enz)
Sockets
Overigens lijkt me het bouwen van een IRC botje (En dan meteen met stat-logging naar een database, heb je dat ook gehad) erg leuk. Ik wil, tijd en werk permitterend, zelf wel helpen knutselen
Misschien leuk om eens een perl script van een van de meelezers (ik heb wel wat liggen ook) door te werken om te kijken hoe het beter kan ofzo?
Ik ben er mee begonnen toen ik nog niet heel goed Perl kon... Ik zit alleen ff te denken of ik die, al dan niet als geheel, wil gaan vrij geven ...
Kan ik delen van een module importeren? Dus iets als 'use Image::Magick(Crop, Ping, Read, Write);' ofzo?
quote:Sorry, sterfgeval in de familie, ik kom over een tijdje weer actief posten...Op woensdag 28 juli 2004 13:55 schreef TimberWolf het volgende:
Vraagje, en schop:
Kan ik delen van een module importeren? Dus iets als 'use Image::Magick(Crop, Ping, Read, Write);' ofzo?
antwoord: Ja
use Image::Magick qw/Crop Ping Read Write/;
qw is eigenlijk 'quote word' dus er had ook kunnen staan:
use Image::Magick ('Crop', 'Ping', 'Read', 'Write');
quote:Sterkte man. Ik weet hoe moeilijk het is.Op woensdag 28 juli 2004 13:59 schreef ChOas het volgende:
Sorry, sterfgeval in de familie, ik kom over een tijdje weer actief posten...
quote:Thanks! Dat scheelt wellicht in geheugengebruikuse Image::Magick qw/Crop Ping Read Write/;
Zijn perl variabelen altijd global? Dus is het altijd zo dat een variabele in het lopende programma ook beschikbaar is voor de subroutines in dat programma? Ik denk, ik vraag het maar voor ik me gigantisch in mijn vingers snijdt
Ik weet namelijk dat het wel zo werkt (ze lijken global te zijn), maar of dat zo hoort is me onduidelijk.quote:als je hem met `my` definieert, is hij alleen toegankelijk vanuit het blok waarin je dat doet + zijn subblokkenOp vrijdag 30 juli 2004 11:23 schreef TimberWolf het volgende:
Kee, nog een vraag (Hier maar even, wegens geen groot perl vragentopic).
Zijn perl variabelen altijd global? Dus is het altijd zo dat een variabele in het lopende programma ook beschikbaar is voor de subroutines in dat programma? Ik denk, ik vraag het maar voor ik me gigantisch in mijn vingers snijdt
#####################
use strict;
my $a = 5;
{
my $b = 10;
print $a+$b; # goed
}
print $a+$b; # niet goed, want $b kent hij niet
#####################
als je `use strict;` gebruikt, verplicht hij je het gebruik van `my`
#####################
$a = 5;
{
$b = 10;
print $a+$b; # goed
}
print $a+$b; # goed
Oftewel: Vars die global moeten zijn, moet je buiten een blok definieren. Nu nog wat andere probleempjes oplossen, en ik kan weer verder spelen quote:preciesOp vrijdag 30 juli 2004 14:31 schreef TimberWolf het volgende:
Helemaal duidelijk
succes
#!/usr/bin/perl -w
use strict;
my $a=5
print "a: $a\n";
{
local $a=10;
print "a: $a\n";
};
print "a: $a\n";
Ik heb een lijst met hardware adressen van netwerkkaarten, maar wil deze in een ander formaat hebben. Ik weet dat ik dit kan doen met Perl, maar het lukt me niet.
Dit is het huidige formaat: 0008.021d.53c0
En dit zou het moeten worden: 00:08:02:1d:53:c0
Kan iemand me hierbij helpen?
quote:Nou dat wist ik alOp vrijdag 4 juni 2004 20:01 schreef ChOas het volgende:
Nou... positieve reacties tot nu toe, en ik heb geen leven dus deel 2...
Maarre leuk geschreven. Kheb er een bookmarkje van gemaakt dus zal hem thuis eens lezen tvpje dus
quote:als alle adressen bestaan uit 4x cijfer/letter, punt, 4x cijfer/letter, punt, 4x cijfer/letter, zou dit moeten werken:Op woensdag 23 februari 2005 15:44 schreef Werewolf het volgende:
Hallo,
Ik heb een lijst met hardware adressen van netwerkkaarten, maar wil deze in een ander formaat hebben. Ik weet dat ik dit kan doen met Perl, maar het lukt me niet.
Dit is het huidige formaat: 0008.021d.53c0
En dit zou het moeten worden: 00:08:02:1d:53:c0
Kan iemand me hierbij helpen?
$address =~ s/^(\w{2})(\w{2})\.(\w{2})(\w{2})\.(\w{2})(\w{2})$/$1:$2:$3:$4:$5:$6/;
succes
quote:of (wanneer je zeker bent van je input)Op woensdag 23 februari 2005 17:53 schreef daReaper het volgende:
[..]
als alle adressen bestaan uit 4x cijfer/letter, punt, 4x cijfer/letter, punt, 4x cijfer/letter, zou dit moeten werken:
$address =~ s/^(\w{2})(\w{2})\.(\w{2})(\w{2})\.(\w{2})(\w{2})$/$1:$2:$3:$4:$5:$6/;
succes
$Address=~s/(\w{2})\.?/$1:/g;
chop $Address;
Is waarschijnlijk niet efficienter, maar geen zin om te benchmarken
Cool dat het topic nog loopt
Al verteld dat ik een vriendin heb ?
quote:Nuecken is aanzienlijk leuker dan Perl
Overigens zou het volgens mij ook wel met iets printf-erigs kunnen. En tsja, sed en awk zijn ook je vriendjes. Alsmede de global-replace van vi(m). En als ik me gek maak verzin ik nog wel een niet-perl methode, die aanzienlijk meer 'hacker' is
Overigens verlate dank voor de cursus
Mijn eerste programma is volledig in gebruik, en werkt geweldig Nu nog een mailinterface intergreren in de code, zonder commandline functionaliteit te verliezen. Fun project! (Je kunt wel zien, ik heb geen vriendin...)quote:Kan ze ook Perl?Op woensdag 23 februari 2005 18:56 schreef ChOas het volgende:
[..]
of (wanneer je zeker bent van je input)
$Address=~s/(\w{2})\.?/$1:/g;
chop $Address;
Is waarschijnlijk niet efficienter, maar geen zin om te benchmarken
Cool dat het topic nog loopt
Al verteld dat ik een vriendin heb ?
Of is ze een
PHP 'er ?als het kan met database en zo
thx
<skippy> use IO::Socket;
<skippy> my $sock = new IO::Socket::INET (
<skippy> PeerAddr => '10.0.0.6',
<skippy> PeerPort => '80',
<skippy> Proto => 'tcp',
<skippy> );
<skippy> wat doe ik hoer fout
<skippy> hier
<skippy>
<skippy> ./test.pl: line 3: use: command not found
<skippy> ./test.pl: line 4: syntax error near unexpected token `('
<skippy> ./test.pl: line 4: `my $sock = new IO::Socket::INET ('
<skippy> skippy@debian:~/perl1$
Wat doe ik fout ??
quote:Tot nu toe niets.. doe eens 'which perl' op je commandline ?
quote:TeringOp vrijdag 4 juni 2004 15:52 schreef ChOas het volgende:
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 ?
quote:
quote:Whehehe
quote:Maar heb je er nou wat van geleerd ?
quote:Nee Gijs.. na 3 zinnen viel ik in slaapOp vrijdag 21 september 2007 20:49 schreef ChOas het volgende:
[..]
Maar heb je er nou wat van geleerd ?
Maar leuk initiatief
quote:Wou al zeggen... jij en programmeren.. nou is perl natuurlijk geen programmeren he... of wel scriptkiddie choasOp vrijdag 21 september 2007 21:00 schreef Bastard het volgende:
[..]
Nee Gijs.. na 3 zinnen viel ik in slaap
Maar leuk initiatief
Perl Er bestaat geen mooiere taal. Alle andere programmeertalen staan in de schaduw van Perl.
quote:*Kuch* Lisp *Kuch*Op zondag 23 september 2007 14:06 schreef Farenji het volgende:
Er bestaat geen mooiere taal. Alle andere programmeertalen staan in de schaduw van Perl.
Niets ten nadele van Perl uiteraard.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | APPEAL: listen (please, please); open yourself, wide; join (you, me), connect (us,together), tell me. do something if distressed; @dawn, dance; @evening, sing; read (books,$poems,stories) until peaceful; study if able; write me if-you-please; sort your feelings, reset goals, seek (friends, family, anyone); do*not*die (like this) if sin abounds; keys (hidden), open (locks, doors), tell secrets; do not, I-beg-you, close them, yet. accept (yourself, changes), bind (grief, despair); require truth, goodness if-you-will, each moment; select (always), length(of-days) # listen (a perl poem) # Sharon Hopkins # rev. June 19, 1995 |
quote:Dat kan ik ook.Op zondag 23 september 2007 16:07 schreef Farenji het volgende:
Een taal waar je gedichten mee kan schrijven, die nog compileren ook, daar kan zelfs Lisp (Lost Inside Stupid Parentheses) niet aan tippen.
[ code verwijderd ]
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | (cond ((not (fast? code)) (must-be 'lisp)) ((out-of-memory-again?) (must-be 'lisp)) ((cant-optimise? code) (must-be 'lisp)) ((cant-change? variables) (must-be 'lisp)) ((hard-to-do? almost-everything) (must-be 'lisp)) ((no-arrays? (only lists)) (must-be 'lisp)) ((by-value-only? (even multi-megabyte-lists)) (must-be 'lisp)) ((and (equal? (sizeof integer) 1000000) (equal? (sizeof integer) (loadavg))) (must-be 'lisp)) ((because? no-I/O? (evil? side-effects))) (must-be 'lisp)) ((cant-find? missing-parenthesis) (must-be 'lisp)) (if (and (brain-dead? your-compiler) (nonexistent? '(for while do socket fork IPC etc etc etc)) (pulled-from-head? your-hair)) (lost-in-stupid-parentheses again))) |
En
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | birthday: ((I m a g i n e) (shriram@cs.rice.edu) (((Imagine there's no FORTRAN) (It's easy if you try) (No SML below us) (Above us only Y) (Imagine all the people) (Living for their Chez)) ((Imagine there's no memory leaks) (It isn't hard to do) (Nothing to malloc(3) or free(3) for) (And no (void *) too) (Imagine all the people) (Living in parentheses)) ((You may say I'm a Schemer) (But I'm not the only one) (I hope someday you'll join us) (And the world will be as (lambda (f) (lambda (x) (f x))))) ((Imagine those continuations) (I wonder if you can) (No need for C or pointers) (A brotherhood of Dan) (Imagine all the people) (GCing all the world)) ((You may say I'm a Schemer) (But I'm not the only one) (I hope someday you'll join us) (And the world will be as (lambda (f) (lambda (x) (f x))))))) 'shriram |
Wel toepasselijk:
TVP dus
Maar als k m dan uitvoer, vraagt ie om mn leeftijd, dan typ ik die in en dan valt ie gewoon weg. Hoe kan dit?
Ik gebruik Windows
/edit
Met batch scripts heb ik dit ook.
quote:Inderdaad! of even <STDIN>; aan het einde van je prog zetten, quick 'n dirty manier dat je nog een keer op enter moet raggen voor je programma/dosbox sluitOp donderdag 27 september 2007 12:11 schreef Farenji het volgende:
Je moet eerst een cmd venstertje openen en dan pas het script runnen; het is standaard dat een command line programmavenster wordt gesloten als het programma is afgelopen/wordt afgesloten.
quote:K zal die wel gebruiken, werkt wat fijner/snellerOp donderdag 27 september 2007 12:35 schreef ChOas het volgende:
[..]
Inderdaad! of even <STDIN>; aan het einde van je prog zetten, quick 'n dirty manier dat je nog een keer op enter moet raggen voor je programma/dosbox sluit
Bedankt. Nu de rest doornemen
quote:LeukOp zondag 23 september 2007 16:07 schreef Farenji het volgende:
Een taal waar je gedichten mee kan schrijven, die nog compileren ook, daar kan zelfs Lisp (Lost Inside Stupid Parentheses) niet aan tippen.
[ code verwijderd ]