Leer hier Perl

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

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 @Arr1=@{$Ref1};
my @Arr2=@{$Ref2};

# Heeft het gewerkt ? :

print "Array 1: @Arr1\n";
print "Array 2: @Arr2\n";
};

my @Array1=(1..4);
my @Array2=(5..10);

PrintArray \@Array1, \@Array2;

---

Output:

choas:~ choas$ ./les10
AtUnderscore: ARRAY(0x80a324) ARRAY(0x80cbb0)
Array 1: 1 2 3 4
Array 2: 5 6 7 8 9 10
choas:~ choas$

En DAT is dus een van de voordelen van references... Hopelijk is dit duidelijk, we gaan dit veel gebruiken.

Bij vragen: Laat het me alsjeblieft weten.

Straks denk ik deel 2 van references: complexe data structuren... wanneer er daarna nog geen vragen zijn is er een van de volgende dingen aan de hand:

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 ?}

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','xchoasx@wanadoo.nl','leeftijd',27);
my %P2=('naam','testpersoon','email','test@inter.net','leeftijd',66);
my %P3=('naam','testpersoon2','email','test2@inter.net','leeftijd',13);

# Maak de references:

my $RefP1=\%P1;
my $RefP2=\%P2;
my $RefP3=\%P3;

# Vul de lijst met de references:

push @Persoon,$RefP1;
push @Persoon,$RefP2;
push @Persoon,$RefP3;

# Kijken wat we in de lijst vinden.

foreach my $Identiteit (@Persoon)
{
# de-refereer de persoon weer naar een hash:

my %PData=%{$Identiteit};

# print informatie over de persoon:

print "Ik ben $PData{'naam'}, ik ben $PData{'leeftijd'} jaar oud, en mijn email adres is: $PData{'email'}\n";
};

---

Nou, dat is hopelijk nog wel te volgen, toch ? ... zo niet, laat het me weten...

De output:

choas:~ choas$ [b ]./les11[/b]
Ik ben ChOas, ik ben 27 jaar oud, en mijn email adres is: xchoasx@wanadoo.nl
Ik ben testpersoon, ik ben 66 jaar oud, en mijn email adres is: test@inter.net
Ik ben testpersoon2, ik ben 13 jaar oud, en mijn email adres is: test2@inter.net
choas:~ choas$


En dan nu hoe je het in de praktijk zal doen (later zal je nog veel ingewikkeldere voorbeelden tegenkomen, maar dit is alvast een begin (we gaan hier hele gave dingen meer doen):

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

use strict;

# Een lijst om de personen te bewaren:

my @Persoon;

# Hashes voor de personen:

my %P1=('naam','ChOas','email','xchoasx@wanadoo.nl','leeftijd',27);
my %P2=('naam','testpersoon','email','test@inter.net','leeftijd',66);
my %P3=('naam','testpersoon2','email','test2@inter.net','leeftijd',13);

# Vul de lijst met de references:

push @Persoon,\%P1,\%P2,\%P3;

# Kijken wat we in de lijst vinden.

foreach (@Persoon)
{
# print informatie over de persoon:

print "Ik ben $_->{'naam'}, ik ben $_->{'leeftijd'} jaar oud, en mijn email adres is: $_->{'email'}\n";
};

---

En nakijken:

choas:~ choas$ ./les11
Ik ben ChOas, ik ben 27 jaar oud, en mijn email adres is: xchoasx@wanadoo.nl
Ik ben testpersoon, ik ben 66 jaar oud, en mijn email adres is: test@inter.net
Ik ben testpersoon2, ik ben 13 jaar oud, en mijn email adres is: test2@inter.net
choas:~ choas$

Kijk... dat ziet er al een stuk makkelijker uit (tenminste, wanneer je er aan gewend bent )

Je ziet dus dat je oook doormiddel van '->' een element de-refereren zonder de gehele stuctuur te hoeven aanraken...

Stel nou dat jullie weer zo fantastisch reageren ga ik vanavond een begin maken aan reguliere expressies... prepare to be brainfucked

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

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'

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

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 ]

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

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

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

Heeft iemand misschien een paar regels Apache logging ?