FOK!forum / Digital Corner / Leer hier Perl
ChOasvrijdag 4 juni 2004 @ 15:52
Perl Tutorial:

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

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

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

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

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

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

Datacontainers:

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

  • Scalars, aangeduid door een $ <- Hier stop je bijvoorbeeld zinnen of getallen in.
  • Lists, aangeduid door een @ <- Hier kan je een lijst van dingen scalars instoppen.
  • Hashes, aangeduid door een % <- Dit is een associatieve lijst, dit leg ik later nog wel uit (als er ooit iemand geinteresseerd is).

    Input, Output:

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

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

    Regels sluit je af door middel van een ;

    Ons eerste programma:

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

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

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

    #!/usr/bin/perl -w

    use strict;


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

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

    Het eerste simpele programma:

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

    use strict;

    #Maak container leeftijd aan:
    my $Leeftijd;

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

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

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

    ---

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

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


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

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

    Laten we het eens proberen:

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

    use strict;

    #Maak container leeftijd aan:
    my $Leeftijd;

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

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

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

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


    ---
    En het resultaat:

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



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

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

    [ Bericht 1% gewijzigd door ChOas op 04-06-2004 17:22:13 ]
  • hielkejvrijdag 4 juni 2004 @ 16:52
    Ik zal dit binnenkort zeker een keer proberen
    gielingvrijdag 4 juni 2004 @ 18:21
    Leuk geschreven choas, érg duidelijk!
    Woutavrijdag 4 juni 2004 @ 19:14
    het is zeker duidelijk geschreven Ik wou toch als is met perl gaan stoeien....
    ChOasvrijdag 4 juni 2004 @ 20:01
    Nou... positieve reacties tot nu toe, en ik heb geen leven dus deel 2...

    Lists

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

    Een simpel programma

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

    use strict;

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

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

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

    ---

    Resultaat:

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


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

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

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

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

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

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

    Verward ? ... een voorbeeld:

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

    use strict;

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

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

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

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

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

    ---
    Output:

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


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

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

    #!/usr/bin/perl -w

    use strict;

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

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

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

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

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

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

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


    Kijken wat dat doet:

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


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

    Vragen stellen mag altijd... ben je nou een Perlgod met een vraag kan je die ook altijd stellen en ik zal kijken of ik kan helpen
    gielingvrijdag 4 juni 2004 @ 20:14
    *positieve reactie*
    DaMadKowvrijdag 4 juni 2004 @ 20:23
    Ga door!
    Repelsteelvrijdag 4 juni 2004 @ 21:36
    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!
    ChOasvrijdag 4 juni 2004 @ 23:40
    quote:
    Op vrijdag 4 juni 2004 21:36 schreef Repelsteel het volgende:
    Goed initiatief ChOas! Perl verdient zeker wat meer aandacht!

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

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

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

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

    En daarom... volgt over 30 minuten ofzo (even wat verzinnen) Les 3: ifs, elses, whiles en fors...
    Lightvrijdag 4 juni 2004 @ 23:51
    Nuttig en interessant topic
    ChOaszaterdag 5 juni 2004 @ 00:09
    Okay...

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

    Basis

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

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

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


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

    my $Zin="Oh wat een last";

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

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

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

    use strict;

    my $Number=5;

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

    ---

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

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

    $Number= $Number + 6;

    Wannneer we met maar 1 ophogen kunnen we ook schrijven:

    $Number++

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

    Laten we eens tot 10 gaan tellen

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

    Voorbeeld:

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

    use strict;

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

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

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

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


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

    De output:

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


    Dat WERKT!!!! Cooooooooool!!!!

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

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

    Hopelijk maakt het volgende voorbeeld dit duidelijk:

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

    use strict;

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

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

    ---

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

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

    Experimenteer ermee tot je er lekker mee om kan gaan, deze functies vormen de kern van bijna elk programma...
    gielingzaterdag 5 juni 2004 @ 00:15
    Gewoon uitermate goed beschreven: erg simpel en leuk
    CybErikzaterdag 5 juni 2004 @ 01:49
    Leuk
    Ik ga ze nu ff doen
    Nebu1980zaterdag 5 juni 2004 @ 02:01
    Doe je goed ChOas!!
    Lekker simpel uitgelegd Ik wacht alweer op de volgende les.
    ChOaszaterdag 5 juni 2004 @ 08:07
    Gaan we weer

    Nog een lesje over lists

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

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

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

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

    Kunnen we die afdrukken ? Tuurlijk:

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

    use strict;

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

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

    ---

    Output (hopelijk zoals jullie al verwachtte):

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


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

    We gaan op elke regel een ander vrucht afdrukken.

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

    use strict;

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

    #nieuwe scalar Index
    my $Index;

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

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

    ---

    En kijken wat er gebeurt:

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


    Werkt netjes toch ?

    Een stapje verder: foreach

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

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

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

    use strict;

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

    #nieuwe scalar Vrucht
    my $Vrucht;

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

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

    ---

    Even proberen:

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


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

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

    Daarna 1 of 2 lessen over hashes
    en dan gaan we het leuker maken met schrijven naar, en lezen uit bestanden
    ToBezaterdag 5 juni 2004 @ 08:16
    Dit is leuk!!!

    Ga zo door!
    Nebu1980zaterdag 5 juni 2004 @ 08:30
    Het heeft inderdaad wat weg van php, zoals je schreef!
    Erg handig
    ...nu eerst even pauze, dan weer een les?!
    Hiawathazaterdag 5 juni 2004 @ 08:41
    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))[email protected][128..$#a]}print+x"C*",@a}';s/x/pack+/g;eval

    Perl de meest lelijke en krachtigste parsing taal die er bestaat
    ChOaszaterdag 5 juni 2004 @ 08:49
    quote:
    Op zaterdag 5 juni 2004 08:41 schreef Hiawatha het volgende:
    Als voorproefje van wat er jullie te wachten staat, een DVD-decoder in 7 regels Perl:

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

    Perl de meest lelijke en krachtigste parsing taal die er bestaat
    Die is inderdaad erg cool ja

    Hmmmm... misschien (echt misschien) komen we met deze tutorials op een gegeven moment
    zo ver dat we die code kunnen gaan ontleden en iedereen het snapt ook
    ChOaszaterdag 5 juni 2004 @ 09:32
    Okidoki...

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

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

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

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


    We hebben nu 2 nieuwe lists met in Getallen:

    1 2 3 4 5 6 7 8 9 10

    en in Letters:

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

    We zullen even als voorbeeld @Letters nemen...

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

    Hopelijk maakt het volgende voorbeeld dit duidelijk:

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

    use strict;

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

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

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

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

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

    ---

    En de uitvoer:

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


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

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

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

    use strict;

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

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

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

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

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

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

    ---

    Geeft als output:

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

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

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


    Dus... is dat een beetje duidelijk ?

    Kunnen er mensen voorspellen wat het volgende doet ? :

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

    use strict;

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

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

    ---

    Probeer maar uit

    En nu ga ik even net doen alsof ik een leven heb... maar ik kom terug... met hashes een van de containers van Perl waar je niet zonder kan (wil kunnen).
    Hiawathazaterdag 5 juni 2004 @ 11:17
    quote:
    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?!
    Wacht maar tot ie reguliere expressies gaat behandelen. Daar is Perl echt veel krachtiger in.
    ChOaszaterdag 5 juni 2004 @ 11:45
    quote:
    Op zaterdag 5 juni 2004 11:17 schreef Hiawatha het volgende:

    [..]

    Wacht maar tot ie reguliere expressies gaat behandelen. Daar is Perl echt veel krachtiger in.
    Yup regexps.. dat gaan wel een paar leuke lesjes worden

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

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

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

    En dan gaan we over op regexps...

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

    Ik heb er zin in!... tot straks!
    gielingzaterdag 5 juni 2004 @ 12:34
    stay tuned
    compufreak88zaterdag 5 juni 2004 @ 13:01
    Hey, erg leuke tutorial. Ik wist niet dat perl zo makkelijk was. Ik dacht dat het veel moeilijker was. Ik kan niet wachten tot de volgende tutorials
    Repelsteelzaterdag 5 juni 2004 @ 14:12
    Zozo, het wordt een complete cursus
    Ik hoor het wel ChOas als je m'n hulp nodig hebt!

    * Repelsteel met kritisch oogje meekijkt
    Sanderzaterdag 5 juni 2004 @ 14:39
    ChOas, geef even een gil, hier of in Feedback, of ik je tutorials in een FAQ mag gooien
    Cuntzaterdag 5 juni 2004 @ 17:54
    quote:
    Op 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
    Ja mag... (doe maar klooncheck) ben niet thuis
    ChOaszaterdag 5 juni 2004 @ 21:43
    Zo ben ik weer... en zo blauw als een tientje twintigje...

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

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

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

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

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

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

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

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

    $UserId{'ChOas'}=693;

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

    Voor een hash zijn er 2 belangrijke functies:

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

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

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

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

    use strict;

    #Nieuwe hash variabele UserId:
    my %UserId;

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

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

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

    #En nog een voorbeeldje:

    my $Ik="ChOas";

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

    ---

    Dit geeft als output:

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


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

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

    [ Bericht 0% gewijzigd door ChOas op 05-06-2004 21:49:06 ]
    ChOaszaterdag 5 juni 2004 @ 21:43
    quote:
    Op zaterdag 5 juni 2004 17:54 schreef Cunt het volgende:

    [..]

    Ja mag... (doe maar klooncheck) ben niet thuis
    Klopt, dat was ik

    Oh, en ik wil toevoegen dat ik vereerd ben dat jullie hier een FAQ van willen maken
    gielingzaterdag 5 juni 2004 @ 22:48
    ga zo door gijs!
    SHERMANzaterdag 5 juni 2004 @ 22:51
    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 idee
    anders 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
    ChOaszondag 6 juni 2004 @ 10:14
    Zooooooooo... gaan we weer

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

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

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

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

    use strict;

    #Nieuwe hash variabele UserId:
    my %UserId;

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

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

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

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

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

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

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

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

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


    ---

    En de output van dit programma:

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

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

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


    Nou, hopelijk maakt dit weer wat duidelijk...

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

    Volgende lessen:

  • Bestand openen om te lezen.
  • Bestand openen om te schrijven.
  • Perl weetjes zoals de 'jeweetwelvariabele' en wat meer manieren om dingen 'netter' te doen dan we tot nu toe geleerd hebben.
  • Subroutines
  • Reguliere expressies.
  • Praktijkvoorbeelden (Apache logfile parsen ofzo) (Jullie mogen ook vragen om specifieke voorbeelden.
  • CGI
  • nog veel meer leuks.

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

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

    Tot zo
  • R-Monzondag 6 juni 2004 @ 10:23
    Wauw, leuk man!
    ChOaszondag 6 juni 2004 @ 10:57
    Bestanden openen zal je veel gebruiken, hier is de allereerste introductie over hoe je een bestand opent om te lezen.

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

    Het keyword wat we gebruiken om dit te doen is open

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

    open werkt als volgt:

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

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

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

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

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

    use strict;

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

    my $FoutCode=0;

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

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

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

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

    ---

    En proberen:

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


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

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

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

    use strict;

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

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

    $FoutCode=open INFILE,$Bestand;

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

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

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

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

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

    close INFILE;
    };

    ---

    We draaien het programma en zien:

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


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

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

    Ik ga even douchen en dan met mijn band oefenen, maar vanavond gaan we naar bestanden schrijven, en je zal zien dat dat net zo makkelijk is
    devzerozondag 6 juni 2004 @ 13:11
    een tip tussendoor: onder unix heb je het commando perldoc. Zoals de naam al zegt kun je hier documentatie van perlcommando's opvragen.
    Bijvoorbeeld perldoc -f open
    Zie verder man perldoc.
    ChOaszondag 6 juni 2004 @ 22:52
    Mea culpa...

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

    Sorry...

    GrtZ,

    ChOas
    BaggerUserzondag 6 juni 2004 @ 22:56
    *bookmarked
    ChOasmaandag 7 juni 2004 @ 09:00
    Schrijven naar bestanden

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

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

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

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

    Wat er eigenlijk staat is:

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

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

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

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

    open INFILE,"$Bestand";

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

    Netjes zou je dit zo schrijven:

    open INFILE,"<$Bestand";

    Het verschil is dus de '<'.

    Dit zijn de manieren om een bestand te openen:

  • < Openen om te lezen
  • > Openen om te schrijven (truncate)
  • >> Openen om te schrijven (append)

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

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

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

    use strict;


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

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

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

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

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

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

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

    close UITFILE;
    };

    ---

    En nu uitvoeren:

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


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

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


    Tadaaaaaaa Cool huh ?

    Dat was het einde van dit deel.

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

    In het volgende deel ga ik in op een paar eigenaardigheden van Perl die, wanneer je ze onder de knie hebt, alles wat makkelijker maken. In dat topic zal je ook meer kennis maken met mijn stijl van coden waardoor je de code in de latere delen (hopelijk) wat makkelijker leest.
  • ChOasmaandag 7 juni 2004 @ 11:01
    Okay gaan we weer... vindt iedereen het nog leuk ? ... of tenminste 1 iemand ? ... dan ga ik hierna nog door...

    Ongeacht dat: Perl weetjes

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

    if/else/unless

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

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

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


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

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


    En hetzelfde kan je bereiken met unless:

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


    Nou, dat is al een weetje.

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

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

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


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


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

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


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


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


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

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


    En dan kan je net zo goed dit schrijven:

    print for (1..10);

    Verder nog wat over bestanden inlezen.

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

    Dat doen we zo:

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

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

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

    while(<INPUT>)
    {

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

    #Afdrukken:

    print "Regel gelezen: $_";
    };

    #Klaar met bestand:

    close INPUT;

    ---

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

    bigben04maandag 7 juni 2004 @ 11:18
    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.
    ChOasmaandag 7 juni 2004 @ 11:25
    quote:
    Op maandag 7 juni 2004 11:18 schreef bigben04 het volgende:
    Moeten de for's in dit voorbeeld niet ook foreach's worden?
    Verder, ga zo door in elk geval, ik heb zelf redelijk wat programmeerervaring maar heb nog nooit met perl gewerkt, dus ik vind dit zeker wel interessant.
    Heel goed punt!!

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

    Goed opgemerkt
    ChOasmaandag 7 juni 2004 @ 12:02
    Subroutines Deel 1: What goes in...

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

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

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

    sub <Subroutine naam>
    {
    <CODE>
    };


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

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

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

    Aanroep:
    subroutX A,B,C;

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

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

    Kijkt u mee ?

    ---

    #!/usr/bin/perl -w

    use strict;

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

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

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

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

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

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

    #Hier begint je echte programma:

    Kwadraat 3;

    Vermenigvuldig 6,5;

    Kwadraat 5;

    Kwadraat 2;

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

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

    ---

    En de output:

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


    Leuk he ?

    Je kan ook subroutines IN subroutines gebruiken, kijk maar:

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

    use strict;

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

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

    Vermenigvuldig 8,7;

    Tafel 10;

    Tafel 5;

    ---

    Output:

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


    Tadaaaaaaaaaaaaa

    Binnenkort deel 2 van subroutines: Subroutines Deel 2: ...must come out
    rihagomaandag 7 juni 2004 @ 12:10
    tvp
    devzeromaandag 7 juni 2004 @ 12:25
    offtopic
    quote:
    Op maandag 7 juni 2004 12:10 schreef rihago het volgende:
    tvp
    Gebruikt er dan echt niemand deze
    TimberWolfmaandag 7 juni 2004 @ 13:06
    Bij deze de aanmoediging vooral verder te gaan Ik vinnum geweldig!

    Ik wacht met spanning op het hele regex verhaal!
    Windsurfbartmaandag 7 juni 2004 @ 13:14
    Als enthousiast perl gebruiker, zit ik hier heerlijk te genieten.
    Duidelijk bescheven. Vooral doorgaan ChOas.
    -DailaLama-maandag 7 juni 2004 @ 13:16
    *tvp
    rihagomaandag 7 juni 2004 @ 13:33
    quote:
    Op maandag 7 juni 2004 12:25 schreef devzero het volgende:
    offtopic
    [..]

    Gebruikt er dan echt niemand [afbeelding] deze
    neej.. nu staat hij tenminste tussen my active topics
    ChOasmaandag 7 juni 2004 @ 13:59
    Zoals beloofd: Subroutines Deel 2: ...must come out

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

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

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

    "Ja ChOas, dat lijkt ons heel handig "

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

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

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


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

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

    use strict;

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

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

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

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

    # Subroutine om een hash af te drukken input: hash, output: niets.
    sub PrintHash
    {
    # Ik heb verteld dat je een hash kan schrijven als een lijst met key,value,key,value.
    # Dit betekent dat we de hele lijst die we mee hebben gekregen kunnen inlezen als hash
    my %[email protected]_;
    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

    TimberWolfmaandag 7 juni 2004 @ 14:07
    Glashelder. En proost
    devzeromaandag 7 juni 2004 @ 19:53
    Het lijkt me sterk dat niemand hier vragen over heeft. Die return van sub ReadFile geeft een list terug, die je expliciet splits door my($error, %Data)=ReadFile "text.txt";. Ik weet niet of iedereen direct in de gaten heeft dat je naast scalars ook lists kunt teruggeven.

    Overigens: bij een implicite return (gewoon het einde van de functie zonder return) wordt $_ gereturned = de waarde van de vorige expressie.
    ChOasmaandag 7 juni 2004 @ 23:13
    Ooooohkay, ben weer kachel... zal ook niet een vervolg schrijven...

    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...
    devzerodinsdag 8 juni 2004 @ 00:31
    quote:
    Op 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:
    Agree
    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
    daReaperdinsdag 8 juni 2004 @ 00:33
    Mijn hele site is in Perl geschreven. Ben ik nu geslaagd?

    Hulde aan ChOas trouwens.
    Spread the word, mate

    Perl is the best!
    capetoniandinsdag 8 juni 2004 @ 00:57
    tvp (jaaa, .. ik wil geen bookmark, .. maar een tvp)
    ChOasdinsdag 8 juni 2004 @ 16:33
    References

    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 @[email protected]{$Ref1};
    my @[email protected]{$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:

  • Iedereen snapt het zonder enig probleem
  • Niemand leest dit
  • Iedereen die dit leest denkt het te snappen
  • Nobody gives a fuck



    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 ?
  • ChOasdinsdag 8 juni 2004 @ 19:59
    Nou, het enthousiasme is weer overweldigend , dus we gaan door met complexe datastructuren

    We 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','[email protected]','leeftijd',27);
    my %P2=('naam','testpersoon','email','[email protected]','leeftijd',66);
    my %P3=('naam','testpersoon2','email','[email protected]','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: [email protected]
    Ik ben testpersoon, ik ben 66 jaar oud, en mijn email adres is: [email protected]
    Ik ben testpersoon2, ik ben 13 jaar oud, en mijn email adres is: [email protected]
    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','[email protected]','leeftijd',27);
    my %P2=('naam','testpersoon','email','[email protected]','leeftijd',66);
    my %P3=('naam','testpersoon2','email','[email protected]','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: [email protected]
    Ik ben testpersoon, ik ben 66 jaar oud, en mijn email adres is: [email protected]
    Ik ben testpersoon2, ik ben 13 jaar oud, en mijn email adres is: [email protected]
    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
    BaggerUserdinsdag 8 juni 2004 @ 20:14
    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 ik ga er ook mee beginnen binnenkort (alleen dankzij dit topic )
    ChOasdinsdag 8 juni 2004 @ 20:41
    quote:
    Op 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 ik ga er ook mee beginnen binnenkort (alleen dankzij dit topic )
    Ja, sorry dat ik af en toe zeik ... 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...
    devzerodinsdag 8 juni 2004 @ 20:41
    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.
    daReaperdinsdag 8 juni 2004 @ 20:45
    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?
    ChOasdinsdag 8 juni 2004 @ 20:50
    quote:
    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.
    Precies! ... 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'
    ChOasdinsdag 8 juni 2004 @ 20:51
    quote:
    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?
    Packages ? ... ja... gaan we ook doen... komt bij het OO gedeelte...
    kareltje_de_grotedinsdag 8 juni 2004 @ 20:53
    /me=* bookmarked

    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.
    Lightdinsdag 8 juni 2004 @ 20:54
    quote:
    Op 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...
  • Ik ga voor deze optie En 't is zeker wel leuk
    daReaperdinsdag 8 juni 2004 @ 21:11
    quote:
    Op dinsdag 8 juni 2004 20:51 schreef ChOas het volgende:

    [..]

    Packages ? ... ja... gaan we ook doen... komt bij het OO gedeelte...
    Packages inderdaad
    goed, dan ga ik zeker mee lezen, want die perldocs daarover snap ik echt voor geen meter

    Goeie zaak jongen
    devzerodinsdag 8 juni 2004 @ 21:22
    quote:
    Op dinsdag 8 juni 2004 20:50 schreef ChOas het volgende:
    Precies! ... en nu (Ja, ik ben een lul ) waarom werkt het niet wanneer je geen ( en ) om my($ptr) heen hebt in je sub ?
    Hmm, niemand

    iemand een idee als ik
    my $ptr = $_[0];
    schrijf
    daReaperdinsdag 8 juni 2004 @ 21:27
    quote:
    Op dinsdag 8 juni 2004 21:22 schreef devzero het volgende:

    [..]

    Hmm, niemand

    iemand een idee als ik
    my $ptr = $_[0];
    schrijf
    Ik weet t wel, maar da's flauw, aangezien ik al 5 jaar Perl
    Dus ik geef de beginners een kans om te antwoorden
    ChOasdinsdag 8 juni 2004 @ 21:41
    reguliere expressies

    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:

  • . elk teken, wat dan ook
  • + 1 of meerdere
  • * 0 of meerdere
  • ? Misschien
  • \s whitespace (spatie, tab, watdanook)
  • \d een getal tussen de 0 en 10
  • \D alles BEHALVE een getal tussen 0 en 10.
  • \w Woord teken dus A tm Z, 0 tm 9
  • \W alles BEHALVE een woord teken
  • {x} Hoeveelheid x
  • {x,y} x tot hoeveelheid y
  • Nog veeeeeeeel meer dingen waar we op terug gaan komen

    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 ]
  • ChOasdinsdag 8 juni 2004 @ 21:43
    quote:
    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
    *mompelt iets over list in scalar context*

    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...
    devzerodinsdag 8 juni 2004 @ 22:50
    quote:
    Op 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)
    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.
    ChOasdinsdag 8 juni 2004 @ 22:53
    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
    ChOaswoensdag 9 juni 2004 @ 17:30
    Vervolg op reguliere expressies

    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...
    ChOaswoensdag 9 juni 2004 @ 18:45
    Heeft iemand misschien een paar regels Apache logging ?
    TimberWolfwoensdag 9 juni 2004 @ 19:26
    quote:
    Op woensdag 9 juni 2004 18:45 schreef ChOas het volgende:
    Heeft iemand misschien een paar regels Apache logging ?
    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
    ChOaswoensdag 9 juni 2004 @ 19:30
    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
    Dan ga ik eerst nog wat meer uitleggen over references ... Waar zat het probleem ? variabelen passen naar een functie, of meer het complexe datastructuren gedeelte ? ... of allebei ?

    Oh.. mailtje komt er aan
    daReaperwoensdag 9 juni 2004 @ 19:31
    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:
    sub alter {
    my ($arg) = @_;
    ${$arg} = 2
    };

    my $test = 1;
    my $ref = \$test;
    print $test;
    alter($ref);
    print $test;
    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"
    whoopswoensdag 9 juni 2004 @ 19:38
    Hey dit is echt cool!!! Na een jaar of twee/drie ervaring met PHP moet het niet zo lastig zijn om Perl te leren a.d.h. van deze handleiding

    ik heb er nu alleen effe geen tijd voor, tvp dus
    TimberWolfwoensdag 9 juni 2004 @ 19:48
    quote:
    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"
    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
    TimberWolfwoensdag 9 juni 2004 @ 19:53
    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

    [ Bericht 1% gewijzigd door TimberWolf op 09-06-2004 19:54:09 (Bollocks, de code tag werkt niet.) ]
    ChOaswoensdag 9 juni 2004 @ 20:08
    quote:
    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
    Komt ie...
    SPOILER
    Stel 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$
    Pfff... dat was even snel coden

    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 ]
    Deevaywoensdag 9 juni 2004 @ 20:11
    Dit topic ga ik zeker in de gaten houden


    Leuk, die mensen zonder leven
    ChOaswoensdag 9 juni 2004 @ 20:12
    quote:
    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
    aaaaaah... wat hier staat:

    my ($arg)[email protected]_;

    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...
    TimberWolfwoensdag 9 juni 2004 @ 20:20
    quote:
    Op woensdag 9 juni 2004 20:12 schreef ChOas het volgende:

    [..]

    aaaaaah... wat hier staat:

    my ($arg)[email protected]_;

    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...
    Ah, dat snap ik inderdaad dan beter 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
    ChOaswoensdag 9 juni 2004 @ 20:25
    quote:
    Op woensdag 9 juni 2004 20:20 schreef TimberWolf het volgende:

    [..]

    Ah, dat snap ik inderdaad dan beter 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
    Pjee!!... je stagneert helemaal niets!!.. dan heeft de rest maar wat meer geduld!

    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 ([email protected])
    daReaperwoensdag 9 juni 2004 @ 20:36
    quote:
    Op woensdag 9 juni 2004 20:20 schreef TimberWolf het volgende:

    [..]

    Ah, dat snap ik inderdaad dan beter 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
    't is maar goed dat dit ChOas' topic is, en niet die van mij, of niet dan? Ik ben echt bijzonder slecht in uitleggen
    gielingwoensdag 9 juni 2004 @ 20:55
    offtopic:
    SPOILER
    Hé ik ben goed in scheikunde
    ChOaswoensdag 9 juni 2004 @ 21:51
    Voor de mensen die Tk hebben geinstalleerd (zit standaard bij Activestate Perl), en willen experimenteren met regexps, dit heb ik ooit geschreven... :

    #!/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\[email protected]");
    $ResultLabel->update;
    };


    Experimenteer er maar mee...

    Nee, dit was geen les
    TimberWolfwoensdag 9 juni 2004 @ 22:29
    quote:
    Op 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? Ik ben echt bijzonder slecht in uitleggen
    Het kan ook gewoon zijn dat ik een klein snappertje heb voor dit soort dingen 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.
    TimberWolfwoensdag 9 juni 2004 @ 22:31
    Ah, en chOas, de regexp uitleg is tot nu toe glashelder Ik verheug me op het volgende deel, en de rest vast ook, hoewel er maar weinig reageren
    CybErikwoensdag 9 juni 2004 @ 22:36
    Ik verheug me er ook op hoor
    leuke tutorials, over een tijdje ook dat 'ie bijvoorbeeld HTML pagina's uitgeeft en/of met een database kan praten hoop ik?
    ChOaswoensdag 9 juni 2004 @ 22:42
    quote:
    Op woensdag 9 juni 2004 22:31 schreef TimberWolf het volgende:
    Ah, en chOas, de regexp uitleg is tot nu toe glashelder Ik verheug me op het volgende deel, en de rest vast ook, hoewel er maar weinig reageren
    Volgende deel regexps ga ik je apache logging gebruiken

    Maar dat wordt morgen... 2 termen die je dan gaat tegenkomen zijn 'greedy matching' en 'negated character classes' ... wordt tricky, wordt leuk
    ChOaswoensdag 9 juni 2004 @ 22:43
    Oh, en ik vraag me af wie ik moet pijpen voor een fucking schouderklopje, maar daar kom ik nog wel achter
    TimberWolfwoensdag 9 juni 2004 @ 23:24
    quote:
    Op woensdag 9 juni 2004 22:42 schreef ChOas het volgende:
    Volgende deel regexps ga ik je apache logging gebruiken
    Right then 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
    Woutadonderdag 10 juni 2004 @ 14:21
    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
    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++)
    }
    De fout die ik krijd is.
    quote:
    syntax error at ./test line 22, near ")
    }"
    Execution of ./test aborted due to compilation errors.
    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.
    daReaperdonderdag 10 juni 2004 @ 14:27
    quote:
    Op 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.
    Je doet nix in de for loop... Sterker nog, je hebt geen { en } er achter gezet
    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";
    }

    }
    Woutadonderdag 10 juni 2004 @ 14:32
    quote:
    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
    [..]
    Dat het ik zelf moeten kunnen verzinnen.....
    classpcdonderdag 10 juni 2004 @ 14:33
    Erg goed. Ik wil nu ook wel Perl scripten.
    Woutadonderdag 10 juni 2004 @ 15:34
    Sorry hoor dat ik weer een vraag ga stellen....

    Ik heb een vraag over het volgende voorbeeld:
    quote:
    #!/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";
    };
    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 ?

    [ Bericht 5% gewijzigd door Wouta op 10-06-2004 15:35:59 (quote gefixt) ]
    CybErikdonderdag 10 juni 2004 @ 16:06
    Ik denk omdat je steeds een scalar uit de list print en niet meteen de hele list... denk ik
    devzerodonderdag 10 juni 2004 @ 16:54
    quote:
    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
    Eerst de cursus afmaken en misschien dat we een dig-mod zover krijgen dat je naam in de hall of fame komt
    ChOasdonderdag 10 juni 2004 @ 17:12
    quote:
    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 ?
    Inderdaad, wat CybErik zegt. Je hebt het over een element uit de list, wat een scalar is, en geen list...

    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.
    devzerodonderdag 10 juni 2004 @ 17:31
    quote:
    Op donderdag 10 juni 2004 15:34 schreef Wouta het volgende:
    Ik heb een vraag over het volgende voorbeeld:
    Een ander 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
    ChOasdonderdag 10 juni 2004 @ 17:53
    -edit-
    ChOasdonderdag 10 juni 2004 @ 18:03
    This lesson was sponsored by TimberWolf's logging

    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)"

  • IP adres, simpel: \S+ < alles wat geen spatie is.
  • een of meerdere whitespaces: \s+
  • Teken, ik weet niet of dit altijd een '-' is, maar ik neem geen risico, dus weer: \S+
  • een of meerdere whitespaces: \s+
  • Teken, ik weet niet of dit altijd een '-' is, maar ik neem geen risico, dus weer: \S+
  • een of meerdere whitespaces: \s+
  • Leuke ... '[' gevolgd door watdanook en dan een ']' , aangezien we [ en ] voor character
    classes gebruiken moeten we een '\' voor deze characters zetten. dit wordt: \[.*\]
  • een of meerdere whitespaces: \s+
  • Bijna als de een na laatste: " gevolgd door watdanook, gevolgd door " doen we zo: ".*"
  • een of meerdere whitespaces: \s+
  • Getal: \d+
  • een of meerdere whitespaces: \s+
  • Getal: \d+
  • een of meerdere whitespaces: \s+
  • al gezien: ".*"
  • een of meerdere whitespaces: \s+
  • al gezien: ".*"

    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 ]
  • TimberWolfdonderdag 10 juni 2004 @ 21:08
    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
    ChOasdonderdag 10 juni 2004 @ 21:41
    quote:
    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
    Even een hele snelle:

    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 ]
    devzerodonderdag 10 juni 2004 @ 22:02
    quote:
    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,
    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:
    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
    Mits HostnameLookups Off in httpd.conf:
    awk '{print $1}' /var/log/httpd-access.log | sort | uniq -c | sort -n
    ChOasdonderdag 10 juni 2004 @ 22:15
    quote:
    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!

    perl -e '$x{substr $_,0,index $_," "}++ while<>;print join"\n",keys %x,"\n"' /var/log/httpd-access.log

    Ik gok dat het sneller is
    devzerodonderdag 10 juni 2004 @ 22:28
    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:
    if (/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/) {$Once{$&}++};
    Overigens nog wat meer roet: vergeet niet dat je naast ipv4 nummers ook ipv6 nummers hebt. Bijvoorbeeld:
    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"
    ChOasdonderdag 10 juni 2004 @ 22:32
    quote:
    Op donderdag 10 juni 2004 22:28 schreef devzero het volgende:

    [..]

    Moest even trollen. Maar perl is hier sneller, maar je gaat awk ook niet gebruiken om 1 string af te drukken.
    [..]

    Overigens nog wat meer roet: vergeet niet dat je naast ipv4 nummers ook ipv6 nummers hebt. Bijvoorbeeld:
    [..]
    Dan gebruik je deze :

    ++$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
    devzerodonderdag 10 juni 2004 @ 22:35
    quote:
    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
    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").
    TimberWolfvrijdag 11 juni 2004 @ 07:49
    quote:
    Op 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 ?
    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 bijna
    quote:
    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.
    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.
    quote:
    Overigens nog wat meer roet: vergeet niet dat je naast ipv4 nummers ook ipv6 nummers hebt.
    En die zijn leuker, want die bestaan niet altijd uit even veel octets 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
    TimberWolfvrijdag 11 juni 2004 @ 08:50
    Hah. Net mijn eerste Perl programma gemaakt. Ik ben zo blij 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
    ChOasvrijdag 11 juni 2004 @ 15:54
    quote:
    Op vrijdag 11 juni 2004 08:50 schreef TimberWolf het volgende:
    Hah. Net mijn eerste Perl programma gemaakt. Ik ben zo blij Stelt niet veel voor, maar werkt wel:

    [ code ]
    Cooool!... gefeliciteerd!!!
    ChOasvrijdag 11 juni 2004 @ 16:03
    Capturen uit regexps

    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 ????
    ChOasvrijdag 11 juni 2004 @ 16:10
    Kan ook:

    ---
    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 ]
    Werewolfvrijdag 11 juni 2004 @ 16:34
    Ben sinds kort ook begonnen met Perl.

    Leuk dit topic!
    ChOaszaterdag 12 juni 2004 @ 00:12
    Om persoonlijke redenen zal ik hier de komende 1.5 week niet kunnen zijn.

    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!
    Joenezaterdag 12 juni 2004 @ 10:18
    tvp
    Ferdyzaterdag 12 juni 2004 @ 10:53
    Zeer interessant topic!

    Als ik klaar ben met me repetitieweek ga ik ook maar eens Perl proberen
    devzerozaterdag 12 juni 2004 @ 11:03
    quote:
    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
    Je hebt hardgenoeg gezogen schouderklopjes :')
    gielingzaterdag 12 juni 2004 @ 11:39
    quote:
    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
    Jij ook al?
    GHans7zaterdag 12 juni 2004 @ 13:18
    Wie is de man? Juistem .

    Na de 22e ga ik lekker klooien
    FlyingFoxzaterdag 12 juni 2004 @ 13:30
    Het heeft wel wat weg van WireFusion.
    erikkllzaterdag 12 juni 2004 @ 13:51
    tvp
    ik snap d'r nu geen f*ck van, maar dat komt vast als ik er aan begin. ken nu geen enkele programeertaal trouwens
    CybErikzondag 13 juni 2004 @ 02:08
    Is er eigenlijk ook een standaardfunctie voor random?
    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?
    CybErikzondag 13 juni 2004 @ 02:32
    Ik heb misschien wel een manier gevonden
    quote:
    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];
    }
    }
    Dit is de Fisher-Yates shuffle.
    Als je nu een list maakt
    quote:
    my @numbers = ( 0 .. 2 );
    fisher_yates_shuffle(\@numbers);
    En daar de functie op loslaat...
    quote:
    my $my_number = shift @numbers;
    print
    "Het getal is $my_number";
    woeiiiiii

    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;
    print
    "Het getal is $my_number";
    ChOaszondag 13 juni 2004 @ 05:07
    quote:
    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:
    [..]
    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...

    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 ]
    Detroitzondag 13 juni 2004 @ 14:25
    Leuke cursus ChOas!
    devzerozondag 13 juni 2004 @ 16:12
    quote:
    Op zondag 13 juni 2004 05:07 schreef ChOas het volgende:
    Iemand zin om de fisher-yates shuffle uit te leggen ?
    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 wisselen ).

    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
    -DailaLama-donderdag 24 juni 2004 @ 17:29
    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
    daReaperdonderdag 24 juni 2004 @ 19:40
    quote:
    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
    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
    Ruudboyvrijdag 25 juni 2004 @ 11:25
    Hey.. ik kom pas net dit topic tegen... super!
    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
    -DailaLama-vrijdag 25 juni 2004 @ 14:45
    quote:
    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
    Omslachtig? Dat is nog niets ...
    Ik had er gister een hele ingewikkelde bagger van met for en while lusjes.

    Bedankt!
    TimberWolfmaandag 5 juli 2004 @ 09:29
    Schopje doormiddel van vraagje:

    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?
    Lightmaandag 5 juli 2004 @ 09:49
    Ik geloof dat 'use strict' ervoor zorgt dat alleen vooraf gedefinieerde variabelen mogen worden gebruikt. Absoluut vereist is het dus niet, maar wel sterk aan te raden. Je kunt er hele vage dingen mee voorkomen.
    devzeromaandag 5 juli 2004 @ 11:17
    quote:
    Op maandag 5 juli 2004 09:29 schreef TimberWolf het volgende:
    Is 'use strict' perse noodzakelijk?
    use strict is datgene wat mist in php, een voorwaarde voor een serieuze taal, de constructie die mannen van jongens scheidt en/of schijdt

    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:
    En als ik localtime in een array dump (my @ltime = localtime()) doet ie het ook natuurlijk.
    Maar
    my @ltime = localtime();
    ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)[email protected]

    zal niet werken, maar
    my @ltime = localtime();
    my($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)[email protected]
    wel
    daReapermaandag 5 juli 2004 @ 14:11
    om het verschil aan te geven:
    quote:
    #!/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;
    output = "51010"
    quote:
    #!/usr/bin/perl -w

    $a = 5;

    sub functie1 {
    $a = 10;
    }

    sub functie2 {
    $a = 20;
    }

    print $a;
    functie1();
    print $a;
    functie2();
    print $a;
    output = "51020"
    TimberWolfdinsdag 6 juli 2004 @ 14:55
    Helemaal duidelijk. Dank 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?
    Oscar.dinsdag 6 juli 2004 @ 15:07
    tvp
    devzerodinsdag 6 juli 2004 @ 15:35
    quote:
    Op dinsdag 6 juli 2004 14:55 schreef TimberWolf het volgende:
    Geeft vast nogal load op de server van de ontvangende partij
    sleep int rand(3);
    oftewel wacht 0,1 of 2 seconden voor je het volgende plaatje ophaalt.
    quote:
    Ben ik overigens de enige die chOas mist?
    We missen hem allemaal
    TimberWolfdinsdag 6 juli 2004 @ 16:23
    quote:
    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.
    Ah, lief plan. Bouwen we wel in !

    Overigens zullen ze ook minder blij zijn met de verminderde bannerviews, but I could not care less
    quote:
    We missen hem allemaal
    *snif*
    daReaperdinsdag 6 juli 2004 @ 16:50
    mijn site bestaat ondertussen uit 233 kB perl code and counting ...
    ChOasdinsdag 6 juli 2004 @ 17:14
    [i]#!/usr/bin/perl -w

    use strict;
    $|++;@_=split//,
    "|Just Another Perl Hacker|";
    sub ll{select(undef,undef,undef,
    0.05);}; my @l;$"="";for(0..12){
    ll;[email protected],@l/2, 0,@_[$_,-$_-1]
    ;print' 'x13,"@l\r";};while (1){
    @[email protected]_;for(0..11){[email protected];[email protected];
    ll;print "\r",' 'x(13+$_)," @l "
    ;};ll;ll;ll;for(reverse 1..12){
    [email protected],-1,0,$_[$_-1];[email protected],
    0,0,$_[-$_-1];ll;print"\r",' 'x(
    13+$_), "@l \b\b\b ";};ll;ll;
    ll;@[email protected]_;};

    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 ]
    ChOasdinsdag 6 juli 2004 @ 17:16
    Kut... forum gaat opeens allerlei dingen escapen

    [code]
    \\\\\\\'test\\\\\\\'
    [/code]

    [php]
    \\\'test2\\\'
    [/php]

    Ooooooooooooooooh wat sucked dat verschrikkelijk... zo is er geen beginnen aan
    ChOasdinsdag 6 juli 2004 @ 21:03
    escape probleem is gefixed, bovenstaande obfuscated code werkt weer

    Dus... wat gaan we nu doen ?
    daReaperdinsdag 6 juli 2004 @ 21:23
    quote:
    Op 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 ?
    OO
    ChOasdinsdag 6 juli 2004 @ 21:50
    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
    TimberWolfdinsdag 6 juli 2004 @ 23:16
    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 )
    devzerowoensdag 7 juli 2004 @ 00:56
    packages lijkt me een prima idee. Misschien als "case-study" CGI?
    ChOaswoensdag 7 juli 2004 @ 06:21
    quote:
    Op 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 )
    Die dingen pak ik er ook nog wel even bij

    *noteert 'here docs', escapen codes, interpolatie*
    ChOasdonderdag 8 juli 2004 @ 17:36
    Okay, even ingaan op de opmerkingen van TimberWolf:

    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...

    daReaperdonderdag 8 juli 2004 @ 17:55
    nog even over die "here documents":

    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
    devzerodonderdag 8 juli 2004 @ 20:08
    Even pietleut mode aan: de "<<" input redirector operator komt oorspronkelijk uit de borne-shell (en zit in veel moderne shells zoals bash of tcsh). Net als enkele en dubbele quotes. Voor meer informatie hierover kun je dus ook zoeken in de manual van sh (onder linux is dat meestal de borne-again-shell).
    TimberWolfdonderdag 8 juli 2004 @ 23:52
    Het is ook goed op te merken dan 'print << END;' niet hetzelfde is als 'print <<END;'. De eerste variant werkt niet, de 2e wel.
    ChOaswoensdag 14 juli 2004 @ 17:38
    Ik heb hier heel erg tegenop gezien omdat het concept voor een hoop mensen moeilijk te begrijpen is...

    Maarrrrrr... ik proberen vanavond het eerste gedeelte van object georienteerd programeren in Perl te posten...

    GrtZ!
    TimberWolfwoensdag 14 juli 2004 @ 19:59
    Yay! Ik ben erg benieuwd!

    *gespannen afwacht*
    ChOaswoensdag 14 juli 2004 @ 21:11
    Okay... hier gaan we dan, ik ben meer gewend dit uit te leggen op een bord enzo, met tekeningetjes, dus dit gaat lastig worden... ik ga jullie een aantal dingen vertellen en jullie moeten me maar gewoon geloven dat het waar is. bij vragen zal ik dieper ingaan op begrippen zoals namespace enzo.

    "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
    ChOaswoensdag 14 juli 2004 @ 22:01
    ChOas, ChOas!!!

    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
    ChOasdonderdag 15 juli 2004 @ 07:43
    Dat enthousiasme!

    Ik ga werken, kijk vanavond wel of er vragen zijn, en MISSCHIEN (afhankelijk van alcohol gebruik nog een 3e deel OO programeren...
    TimberWolfdonderdag 15 juli 2004 @ 08:11
    quote:
    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 &{}.
    Hebben we het over de-refereren gehad?

    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)
    daReaperdonderdag 15 juli 2004 @ 08:13
    Eindelijk OO

    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!
    daReaperdonderdag 15 juli 2004 @ 08:17
    Voor de mensen die nog steeds nix snappen van het hele OO concept heb ik hier hoofdstuk 1 uit een C++ tutorial: http://www.briceg.com/ticpp/one/Chapter01.html

    Hierin wordt heel gedetailleerd het wat, hoe en waarom uitgelegd. Da's waar ik het zelf ook uit heb geleerd
    ChOasdonderdag 15 juli 2004 @ 22:33
    quote:
    Op donderdag 15 juli 2004 08:11 schreef TimberWolf het volgende:

    [..]

    Hebben we het over de-refereren gehad?
    Ja :
    quote:
    Antwoord: de-refereren

    Voor een array als volgt: @{$ArrayRef};
    Voor een hash: %{$HashRef};
    Uit: Leer hier Perl (8 Juni)
    ChOasdonderdag 15 juli 2004 @ 22:43
    Ben trouwens niet coherent genoeg voor deel 3 van OO programeren, dus dat volgt Zaterdag ochtend...
    devzerodonderdag 15 juli 2004 @ 23:03
    Mensen die ongeduldig zijn kunnen overigens ook man perlboot doen.
    TimberWolfvrijdag 16 juli 2004 @ 00:25
    quote:
    Op donderdag 15 juli 2004 22:33 schreef ChOas het volgende:

    [..]

    Ja :
    [..]

    Uit: Leer hier Perl (8 Juni)
    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
    ChOasvrijdag 16 juli 2004 @ 06:29
    quote:
    Op vrijdag 16 juli 2004 00:25 schreef TimberWolf het volgende:

    [..]

    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
    Ja, we gaan het over sockets hebben ... 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 ?
    daReapervrijdag 16 juli 2004 @ 08:34
    quote:
    Op vrijdag 16 juli 2004 06:29 schreef ChOas het volgende:

    [..]

    Ja, we gaan het over sockets hebben ... 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 ?
    Heb ik helaas al gedaan
    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 was
    ChOasvrijdag 16 juli 2004 @ 08:51
    quote:
    Op vrijdag 16 juli 2004 08:34 schreef daReaper het volgende:

    [..]

    Heb ik helaas al gedaan
    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 was


    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 ?
    daReapervrijdag 16 juli 2004 @ 08:55
    quote:
    Op 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 ?
    Nee sockets zijn goed hoor 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
    The_Hivesvrijdag 16 juli 2004 @ 11:11
    tvp
    devzerovrijdag 16 juli 2004 @ 11:35
    quote:
    Op 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
    Als er geen select-achtige (ala select(2)) functie in perl zit, is het imho geen geschikte taal voor sockets en die is er gelukkig wel, scheelt een hoop werk

    Voor het vervolg van de cursus zou gedacht kunnen worden aan bv
  • verder gaan met OO, ik weet niet of dat te hoog gegrepen is
  • sockets, is imho niet zo interresant onderwerp. Stream-sockets zijn als ze geopened zijn net filedescriptors. Wordt interresant als je er een applicatie omheen hangt, zoals bv een chat-servertje, maar dan wordt het weer te lang.
  • databases, misschien leuk, misschien niet. Vraagt alleen wel van de student dat hij bv mysql heeft geinstalleerd.
  • cgi, kan ook leuk zijn, maar erg praktisch gericht.

    Iemand nog meer ideeen?
  • ChOasvrijdag 16 juli 2004 @ 16:12
    Voor de IRCers:

    irc.fok.nl / #leerhierperl



    Ben een beetje aan het experimenteren daar
    daReapervrijdag 16 juli 2004 @ 19:17
    server sockets heb ik trouwens nog niet zo onder de knie
    met dat gefork enzo

    die mag ook nog wel
    TimberWolfzaterdag 17 juli 2004 @ 00:35
    Qua dingen die lang kunnen komen:

    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?
    daReaperzaterdag 17 juli 2004 @ 00:37
    quote:
    Op zaterdag 17 juli 2004 00:35 schreef TimberWolf het volgende:
    Qua dingen die lang kunnen komen:

    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?
    Die van mijn site kan ongetwijfeld beter
    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 ...
    TimberWolfwoensdag 28 juli 2004 @ 13:55
    Vraagje, en schop:

    Kan ik delen van een module importeren? Dus iets als 'use Image::Magick(Crop, Ping, Read, Write);' ofzo?
    ChOaswoensdag 28 juli 2004 @ 13:59
    quote:
    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?
    Sorry, sterfgeval in de familie, ik kom over een tijdje weer actief posten...

    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');
    TimberWolfwoensdag 28 juli 2004 @ 14:15
    quote:
    Op woensdag 28 juli 2004 13:59 schreef ChOas het volgende:
    Sorry, sterfgeval in de familie, ik kom over een tijdje weer actief posten...
    Sterkte man. Ik weet hoe moeilijk het is.
    quote:
    use Image::Magick qw/Crop Ping Read Write/;
    Thanks! Dat scheelt wellicht in geheugengebruik
    TimberWolfvrijdag 30 juli 2004 @ 11:23
    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 Ik weet namelijk dat het wel zo werkt (ze lijken global te zijn), maar of dat zo hoort is me onduidelijk.
    daReapervrijdag 30 juli 2004 @ 13:10
    quote:
    Op 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 Ik weet namelijk dat het wel zo werkt (ze lijken global te zijn), maar of dat zo hoort is me onduidelijk.
    als je hem met `my` definieert, is hij alleen toegankelijk vanuit het blok waarin je dat doet + zijn subblokken

    #####################
    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
    TimberWolfvrijdag 30 juli 2004 @ 14:31
    Helemaal duidelijk Oftewel: Vars die global moeten zijn, moet je buiten een blok definieren. Nu nog wat andere probleempjes oplossen, en ik kan weer verder spelen
    daReapervrijdag 30 juli 2004 @ 14:32
    quote:
    Op vrijdag 30 juli 2004 14:31 schreef TimberWolf het volgende:
    Helemaal duidelijk Oftewel: Vars die global moeten zijn, moet je buiten een blok definieren. Nu nog wat andere probleempjes oplossen, en ik kan weer verder spelen
    precies
    succes
    ChOasvrijdag 30 juli 2004 @ 14:34
    Je kan trouwens ook binnen een blok een global variabele locaal maken, waar dat nuttig voor is leg ik nog wel eens uit, maar zo werkt het:

    #!/usr/bin/perl -w

    use strict;

    my $a=5

    print "a: $a\n";
    {
    local $a=10;
    print "a: $a\n";
    };
    print "a: $a\n";
    Werewolfwoensdag 23 februari 2005 @ 15:44
    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?
    Hakkertwoensdag 23 februari 2005 @ 15:52
    quote:
    Op vrijdag 4 juni 2004 20:01 schreef ChOas het volgende:
    Nou... positieve reacties tot nu toe, en ik heb geen leven dus deel 2...
    Nou dat wist ik al Maarre leuk geschreven. Kheb er een bookmarkje van gemaakt dus zal hem thuis eens lezen
    keijzwoensdag 23 februari 2005 @ 16:01
    ik ga dit zeker een keer proberen

    tvpje dus
    Eghiewoensdag 23 februari 2005 @ 16:13
    Mooie zet. Ik ga binnenkort hier ook eens mee stoeien.
    daReaperwoensdag 23 februari 2005 @ 17:53
    quote:
    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?
    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
    ChOaswoensdag 23 februari 2005 @ 18:56
    quote:
    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
    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 ?
    TimberWolfwoensdag 23 februari 2005 @ 22:29
    quote:
    Op woensdag 23 februari 2005 18:56 schreef ChOas het volgende:
    Al verteld dat ik een vriendin heb ?
    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...)
    daReaperdonderdag 24 februari 2005 @ 00:42
    quote:
    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 ?
    Kan ze ook Perl?
    Of is ze een PHP 'er ?

    Proofkevrijdag 10 juni 2005 @ 19:40
    Heeft er iemand een werkend voorbeeld van een object orienteerd programma in perl???

    als het kan met database en zo

    thx
    skippy22donderdag 10 augustus 2006 @ 12:15
    <skippy> #!/usr/bin/perl
    <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> [email protected]:~/perl1$
    Wat doe ik fout ??
    ChOasdonderdag 10 augustus 2006 @ 12:44
    quote:
    Op donderdag 10 augustus 2006 12:15 schreef skippy22 het volgende:

    Wat doe ik fout ??
    Tot nu toe niets.. doe eens 'which perl' op je commandline ?
    skippy22donderdag 10 augustus 2006 @ 17:15
    Hij doet het al was een foutje van mij
    SpeedyRichdonderdag 10 augustus 2006 @ 17:17
    Lees post
    Bastardvrijdag 21 september 2007 @ 15:31
    quote:
    Op 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 ?
  • Tering
    Hakkertvrijdag 21 september 2007 @ 19:48
    quote:
    Op vrijdag 21 september 2007 15:31 schreef Bastard het volgende:

    [..]

    Tering
    Bastardvrijdag 21 september 2007 @ 20:25
    quote:
    Op vrijdag 21 september 2007 19:48 schreef Hakkert het volgende:

    [..]

    Whehehe
    ChOasvrijdag 21 september 2007 @ 20:49
    quote:
    Op vrijdag 21 september 2007 20:25 schreef Bastard het volgende:

    [..]

    Whehehe
    Maar heb je er nou wat van geleerd ?
    Bastardvrijdag 21 september 2007 @ 21:00
    quote:
    Op vrijdag 21 september 2007 20:49 schreef ChOas het volgende:

    [..]

    Maar heb je er nou wat van geleerd ?
    Nee Gijs.. na 3 zinnen viel ik in slaap
    Maar leuk initiatief
    Hakkertvrijdag 21 september 2007 @ 21:02
    quote:
    Op vrijdag 21 september 2007 21:00 schreef Bastard het volgende:

    [..]

    Nee Gijs.. na 3 zinnen viel ik in slaap
    Maar leuk initiatief
    Wou al zeggen... jij en programmeren.. nou is perl natuurlijk geen programmeren he... of wel scriptkiddie choas
    Farenjizondag 23 september 2007 @ 14:06
    Perl

    Er bestaat geen mooiere taal. Alle andere programmeertalen staan in de schaduw van Perl.
    Quarkszondag 23 september 2007 @ 15:15
    quote:
    Op zondag 23 september 2007 14:06 schreef Farenji het volgende:
    Perl

    Er bestaat geen mooiere taal. Alle andere programmeertalen staan in de schaduw van Perl.
    *Kuch* Lisp *Kuch*

    Niets ten nadele van Perl uiteraard.
    Farenjizondag 23 september 2007 @ 16:07
    Een taal waar je gedichten mee kan schrijven, die nog compileren ook, daar kan zelfs Lisp (Lost Inside Stupid Parentheses) niet aan tippen.

    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
        #!/usr/bin/perl

        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
    Quarkszondag 23 september 2007 @ 16:18
    quote:
    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 ]
    Dat kan ik ook.

    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
     (define (lost-in-stupid-parentheses again) 
         
           (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
    Posted to comp.lang.scheme on January 17, 1996, for Scheme's twentieth
    birthday:

                               ((I m a g i n e)
                             ([email protected])
                       (((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:
    dokazondag 23 september 2007 @ 16:33


    TVP dus
    R-Monzondag 23 september 2007 @ 16:39
    posten werkt niet helemaal goed maar: http://99-bottles-of-beer.net/language-perl-737.html
    jordeeehdinsdag 25 september 2007 @ 01:52
    Even een TVP'tje plaatsen hoor
    jordeeehdonderdag 27 september 2007 @ 05:11
    Hmm ik heb t nu geprobeert enzo, even die van jou gekopieert en opgeslagen als leeftijd.pl

    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.
    jordeeehdonderdag 27 september 2007 @ 12:05
    Iemand?
    Farenjidonderdag 27 september 2007 @ 12:11
    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.
    ChOasdonderdag 27 september 2007 @ 12:35
    quote:
    Op 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.
    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
    Scorpiedonderdag 27 september 2007 @ 12:37
    tvp.
    jordeeehdonderdag 27 september 2007 @ 12:50
    quote:
    Op 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
    K zal die wel gebruiken, werkt wat fijner/sneller

    Bedankt. Nu de rest doornemen
    SuperrrTuxxxdonderdag 27 september 2007 @ 13:05
    quote:
    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 ]
    Leuk