Recover from microbel

README.md

@@ -0,0 +1,16 @@
+# Nybegynnerkurs i Perl
+
+- **Dato:** Torsdag 28. oktober 2004
+- **Tid:** 18 til 20
+- **Sted:** Auditorium R8, Gløshaugen
+- **Pris:** 50,- / 0,- (ikke-medlem / medlem)
+- **Påmelding:** [kurs@pvv.org](mailto://kurs@pvv.org)
+
+PVV arrangerer et nybegynnerkurs i programmeringsspråket Perl. Kurset gjør
+et forsøk på å lære deltakerene hvordan de kan lage enkle script, og gi et
+grunnlag for å lære seg mer selv. Forutsetter litt programmeringserfaring.
+Kurset er beregnet på folk som har litt erfaring med programmering fra før (å
+kunne Java fra programmeringsfag burde være nok).
+
+Det er ikke nødvendig å sende påmelding, men det hadde vært fint slik at
+vi fikk en viss oversikt over hvor mange som kommer.

foiler/01_velkommen.pl

@@ -0,0 +1,26 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+my $msg = <<'EOF';
+
+
+
+	__     __   _ _                                        
+	\ \   / /__| | | _____  _ __ ___  _ __ ___   ___ _ __  
+	 \ \ / / _ \ | |/ / _ \| '_ ` _ \| '_ ` _ \ / _ \ '_ \ 
+	  \ V /  __/ |   < (_) | | | | | | | | | | |  __/ | | |
+	   \_/ \___|_|_|\_\___/|_| |_| |_|_| |_| |_|\___|_| |_|
+														   
+			 _   _ _   ____           _       _                   _ 
+			| |_(_) | |  _ \ ___ _ __| |     | | ___   _ _ __ ___| |
+			| __| | | | |_) / _ \ '__| |_____| |/ / | | | '__/ __| |
+			| |_| | | |  __/  __/ |  | |_____|   <| |_| | |  \__ \_|
+			 \__|_|_| |_|   \___|_|  |_|     |_|\_\\__,_|_|  |___(_)
+																	
+
+
+
+EOF
+
+print $msg; 

foiler/02_whatis.pl

@@ -0,0 +1,27 @@
+#!/usr/bin/perl
+use strict; use warnings;
+print <<'EOF';
+                              HVA ER PERL?
+    
+  * Betyr: Practical Extraction and Reporting Language
+  * Alternativt: Pathologically Eclectic Rubbish Lister
+  * Et cross-platform scriptingspråk skrevet av Larry Wall (han er kul)
+  * Virker i UNIX, Windows, på Mac, i VMS, etc etc
+  * Kildekoden til perl er åpen (GPL)
+  * Et tolket språk (kompileres ikke, "kompileres" hver gang det kjøres).
+
+                              HVORFOR PERL?
+
+  * Veldig kraftig, du kan gjøre mye med lite kode
+  * Kjapt å skrive
+  * Svært mange ferdige biblioteker ( http://search.cpan.org )
+  * Det er kult
+
+                            HVORFOR IKKE PERL?
+  
+  * Ting kan fort bli litt grisete om man er syk i hodet eller ikke tenker
+  * Veldig mye ulik syntaks (flere måter å gjøre det samme på)
+  * Det blir en del krangling med Python-folk
+  * Python-folkene kommer sikkert på mer...
+
+EOF

foiler/03_what.pl

@@ -0,0 +1,24 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+print <<'EOF'
+
+                        HVA VI SKAL HA I DETTE KURSET
+
+   Det finnes to typer perl:
+   * Oneliner-perl (kjappe triks man bare skal bruke en gang (eller ha på
+     t-skjorta))
+   * Produksjonskode-perl (relativt pen, leselig kode)
+
+   Ikke alle ser denne forskjellen. De som ikke ser denne forskjellen er
+   grunnen til at perl har rykte på seg for å være uleselig og grisete,
+   såkalt "write once".
+
+   Jeg er ikke så glad i dem som ikke ser forskjellen. Spesielt ikke når jeg
+   må fikse på koden deres.
+
+   I dette kurset skal vi lære om produksjonskode-perl. Oneliner-perl lærer
+   dere tidsnok selv ;-)
+
+EOF

foiler/04_syntaks.pl

@@ -0,0 +1,22 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+print <<"EOF"
+# Enkel syntaks:
+
+ * Minner veldig om C, PHP og Java. 
+ * { og } deler inn blokker, 
+ * ( og ) rundt argumenter, etc (MEN: valgfrie). 
+ * Alle statements avsluttes med semikolon
+ 
+EOF
+
+# Parenteser rundt er valgfrie. Begge disse virker:
+
+print "hei\n";
+print("hei\n");
+
+# Parenteser brukes for å angi skop. Dette er spesielt nyttig når man har 
+# flere kommandoer nøstet inni hverandre. Lurer du på om det funker uten 
+# parentes? Da beholder du parentesene. Lesbar kode er viktig.

foiler/05_vars.pl

@@ -0,0 +1,23 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Variabler og slikt
+# Variabler, arrays og hasher deklareres med ordet "my". Det holder med ett 
+# ord for å deklarere, siden Perl ikke bryr seg så mye om innholdet i 
+# variabler. Om det er et heltall, et desimaltall eller tekst tas litt på
+# gefühlen.
+
+# En vanlig variabel (såkalt "skalar):
+my $tall = 15;
+my $tekst = 'hei';
+
+# En array:
+my @array;
+@array = (15, 'hei');    # Definer alle verdier
+$array[2] = 'gunnar';    # Sett tredje element
+
+# En hash:
+my %hash = ('ottar' => 15, 'pelle' => 17);  # Definer alle verdier
+$hash{'bjarne'} = 13;                       # Sett verdi for bjarne
+

foiler/06_quoting.pl

@@ -0,0 +1,13 @@
+#!/usr/bin/perl
+use strict; use warnings;
+
+## Quoting
+# Ulike hermetegn oppfører seg forskjellig, på samme måte som i PHP 
+# (PHP rappet det av Perl). 
+
+my $test = 'ottar';
+
+print "hei $test\n";   # printer dette: hei ottar
+print 'hei $test\n';   # printer dette: hei $test\n
+
+

foiler/07_joining.pl

@@ -0,0 +1,25 @@
+#!/usr/bin/perl
+use strict; use warnings;
+
+## Hvordan slå sammen tekst (også likt som i PHP, av samme grunn)
+
+# Flere tekststrenger slås sammen med punktum (Java bruker pluss).
+my $fornavn = "Kjell Magne";
+my $etternavn = "Bondevik";
+my $fulltnavn = $fornavn . ' ' . $etternavn;
+
+# Vi kunne selvsagt også brukt dette, som også er mye vanligere å bruke:
+$fulltnavn = "$fornavn $etternavn";
+
+# Men av og til er "" upraktisk, som f.eks. om du skal printe ut HTML, 
+# eller har verdiene i noe annet enn variabler.
+my %verdier = ('uid' => 1015, 'bnavn' => 'kjellmangle');
+
+# Dette:
+print '<a href="' . $verdier{'uid'} . '">' . $verdier{'bnavn'} . "</a>\n";
+
+# Er penere enn dette:
+print "<a href=\"$verdier{'uid'}\">$verdier{'bnavn'}</a>\n";
+
+# Men begge virker, selv om highlightingen min ikke tror det.
+# At noe virker men blir highlightet feil er ofte et hint. Ta hintet.

foiler/08_multiline.pl

@@ -0,0 +1,26 @@
+#!/usr/bin/perl
+use strict; use warnings;
+
+## Ting på flere linjer: bruk enten punktum eller <<"EOF";.
+
+# Punktum (Som regel best):
+my $test = "ottar";
+my $langvariabel = "Denne teksten på flere linjer er dedikert til\n"
+                 . "min gode venn og følgesvenn $test\n";
+
+# <<"EOF"; (Bruk bare når det er _store_ greier, og punktum blir veldig
+# tungvint. Ikke spesielt viktig å kunne, men greit å vite om):
+
+$langvariabel = <<"EOF";
+Denne teksten på flere linjer er dedikert til
+min gode venn og følgesvenn $test
+EOF
+
+$langvariabel = <<'EOG';
+Denne teksten på flere linjer er dedikert til
+min gode venn og følgesvenn $test
+EOG
+
+# Det inni hermetegnene er et merke. Alt helt ned til merket blir med i 
+# variabelen. Hva som skjer med teksten inni avhenger av hermetegnene rundt 
+# merket. Husk å bruke samme merke bare en gang! Pass på semikolonet!

foiler/09_logikk.pl

@@ -0,0 +1,25 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Logikk med tallverdier
+# Logikk i perl ligner veldig på andre språk som C, PHP og Java.
+# 0, tom streng og udefinert er false, det meste annet er true (som i PHP).
+# IKKE utnytt dette for mye. Det blir vanskelig å lese. Test bare rett på 
+# variabelen om du bruker variabelen som en boolean.
+
+# Booleans (1 = sant, 0 = usant):
+my $boolean = 1;
+if ($boolean) {
+	print "\$boolean er sann!\n";  # Dette skjer.
+} else {
+	print "\$boolean er usann!\n"; # Dette skjer ikke.
+}
+
+my $tall = 15;
+if ($tall > 10) {
+	print "\$tall er over 10!\n";
+} 
+elsif ($tall < 5) {                # elsif står for "else if"
+	print "\$tall under over 5!\n";
+}

foiler/10_tekstlogikk.pl

@@ -0,0 +1,25 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Logikk med tekstverdier
+
+# Dere som kan PHP er vant til å bruke "==" på tekststrenger. Det virker 
+# IKKE i Perl! I Perl er det egne greier for å sammenligne ord.
+
+# De viktigste:
+#  eq: er lik
+#  ne: er ikke lik
+
+my $tekst = "banan";
+if ($tekst eq "banan") {
+	print "\$tekst er lik banan\n";
+}
+
+if ($tekst ne "eple") {
+	print "\$tekst er ikke lik eple\n";
+}
+
+if (length($tekst) > 3) {
+	print "\$tekst er mer enn tre tegn lang\n";
+}

foiler/11_while.pl

@@ -0,0 +1,19 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## While-loop
+# En while-loop i perl virker akkurat som i andre språk. Yay!
+
+my $counter = 0;
+while ($counter < 10) {
+	print "tallet er $counter\n";
+	$counter++;                       # Øker $counter med 1
+}
+
+## For-loop
+# Virker også som i andre språk! Hurra!
+
+for (my $tall = 0; $tall < 10; $tall++) {
+	print "tallet er $tall\n";
+}

foiler/12_foreach.pl

@@ -0,0 +1,25 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Foreach-loopen
+# Denne er litt spesiell. Man har noe lignende i PHP, men syntaksen er ulik.
+# Foreach går gjennom hvert element i en liste.
+
+my @array = ('gunnar', 'ottar', 'per ulf');
+
+# Legg merke til at løpevariabelen $verdi angis utenfor parentesen!
+foreach my $verdi (@array) {
+	print "$verdi\n";
+}
+
+# Man kan også bruke foreach til å løpe over alle nøklene i en hash:
+my %hash = ( 'uid' => 3425, 'bnavn' => 'ottar', 'rnavn' => 'Ottar Evje' );
+
+# Kommandoen "keys" gir ut en array med alle nøklene i hashen, så dette er 
+# egentlig akkurat det samme.
+foreach my $key (keys %hash) {
+	print $key . " = " . $hash{$key} . "\n";
+}
+
+# Foreach er dritnyttig!

foiler/13_break.pl

@@ -0,0 +1,26 @@
+#!/usr/bin/perl
+use strict; use warnings;
+
+## Å bryte ut av looper i Perl
+# Når man skal bryte ut av looper er Perl litt rart. Alt heter noe annet enn
+# det gjør i andre språk! Dette er jo skikkelig teit, men man venner seg
+# til det ganske fort. Jeg tipper grunnen er at perl ble laget for å parse
+# tekst, og da virket disse navnene mer logiske.
+#
+# En liten tabell: 
+#     +------+-------------+---------------------------------------------+
+#     | Perl | Andre språk | Betydning                                   |
+#     +------+-------------+---------------------------------------------+
+#     | next | continue    | Hopp over det som er nedenfor og kjør neste |
+#     |      |             | runde i loopen                              |
+#     +------+-------------+---------------------------------------------+
+#     | last | break       | Avbryt kjøringen av hele loopen             |
+#     +------+-------------+---------------------------------------------+
+
+# Eksempel på next:
+foreach my $tall (1, 2, 3) {
+	if ($tall == 2) {
+		next;
+	}
+	print "tallet er $tall!\n";
+}

foiler/14_break2.pl

@@ -0,0 +1,15 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+# Eksempel på "last": Rakettutskyting med forviklinger
+
+for (my $tall = 10; $tall > 0; $tall--) {
+	print "$tall...\n";
+	
+	# Oh no! Når vi kommer til 5 eksploderer raketten!
+	if ($tall == 5) {
+		print "Boom!\n";
+		last; # Her avbryter loopen
+	}
+}

foiler/15_shebang.pl

@@ -0,0 +1,23 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+### Hva er egentlig det greiene på toppen av alle foilene?
+
+## Shebangen
+#
+# #!/usr/bin/perl er en såkalt shebang. Den forteller hva slags språk
+# scriptet er skrevet i, og hva slags program som skal brukes til å tolke 
+# det.
+#
+# Om ikke shebangen var det ville vi måttet vite hva scriptet var skrevet i,
+# og selv kjørt programmet med filen som argument.
+#
+# Uten shebang:
+# 	perl program.pl
+#
+# Med shebang:
+#   ./program.pl
+#
+# For at programmet skal kunne kjøres direkte må det også være kjørbart.
+# "chmod +x program.pl" fikser den biffen.

foiler/16_strict.pl

@@ -0,0 +1,15 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## use strict:
+#
+# Uten use strict trenger man ikke å deklarere variabler. Variabler blir 
+# bare opprettet når de trengs av seg selv. Kjekt? Nei.
+#
+# Alle variabler som er implisitt deklarert blir nemlig globale. 
+# Globale variabler er ikke bra.
+#
+# Dessuten blir det plutselig mulig å bruke samme variabel til flere ting 
+# uten å merke det. Det er heller ikke bra.
+

foiler/17_nonstrict_eks.pl

@@ -0,0 +1,27 @@
+#!/usr/bin/perl
+use warnings;
+
+# Eksempel uten strict. Merk at det ikke er noen "use strict" øverst.
+# Vi tenker oss en webtjeneste der brukeren kan logge inn. Brukeren er 
+# innlogget som "rob-geir".
+$user = "rob-geir";
+print "Du er logget inn som: $user\n";
+
+# maaaange linjer kode med magi og ting. Vi har helt glemt $user.
+
+# Hoi, systemet har en funksjon som lister opp alle som er innlogget.
+# Akkurat nå er det disse tre:
+@users = ('ottar', 'rob-geir', 'dan-børge' );
+
+# Vi lister opp alle brukerene. Men hold an! Her brukte vi jo $user på nytt!
+print "Brukere innlogget: ";
+for ($i = 0; $i < scalar @users; $i++){
+	$user = $users[$i];
+	print "$user ";
+}
+print "\n";
+
+# Maaange linjer med kode. Nå har vi glemt brukerlisten.
+
+# Nederst på siden vil vi vise hvem som er logget inn en gang til.
+print "Du er logget inn som: $user\n";

foiler/18_warnings.pl

@@ -0,0 +1,15 @@
+#!/usr/bin/perl
+use warnings;
+
+# Warnings betyr akkurat det som står: Advarsler. Det gjør at perl advarer 
+# når noe ser rart ut. Du vil ha det. Om koden din gir advarsler er det fordi
+# du har gjort noe du ikke burde gjøre.
+#
+# Jeg fjernet use strict denne gangen, så det skulle bli lettere å gjøre
+# noe dumt warnings kunne oppdage.
+
+# Eksempel på hvorfor warnings er bra:
+
+my $foo = "bar";
+
+print "hei, jeg er $bar\n"; # Å nei! Feil variabelnavn!

foiler/19_pekere.pl

@@ -0,0 +1,25 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Kompliserte datastrukturer i Perl
+# Perl versjon 4 (som ingen bruker lenger) hadde ingen støtte for å nøste
+# arrays og lignende. Todimensjonale arrays var ikke mulig. Folk brukte all
+# verdens grisete triks for å få til noe tilsvarende. Æsj!
+#
+# Perl versjon 5 har egentlig heller ikke støtte for flerdimensjonale arrays
+# eller sånne ting, men det merker vi ikke stort til. Nå har vi nemlig pekere!
+#
+# Pekere i perl kan minne om pointere i C eller objektreferanser i Java.
+
+# Vi har arrayen @array
+my @array = ('ottar', 'spiser', 'fisk');
+
+# Vi lager en referanse
+my $ref = [ @array ]; # Firkantparenteser til array, akkurat som ved henting
+                      # av verdier
+
+# Vi får tilbake arrayen med @{}:
+my @sammearray = @{$ref};  # denne sier: $ref er egentlig en array, altså!
+
+# Det samme gjelder for hasher, men med { %hash } og %{$ref}

foiler/20_pekere2.pl

@@ -0,0 +1,25 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+# Vi kan også gjøre ting litt mer direkte, uten å lage @array først:
+my $arrayref = [ 'geir', 'liker', 'sko' ];
+
+# Og så kan vi hente ut verdier direkte på to måter. De er omtrent like bra,
+# så det er bare å velge den du liker best. Personlig derefererer jeg gjerne 
+# referansen og bruker arrayen/hashen direkte etterpå, som på forrige foil.
+print @{$arrayref}[0] . "\n"; # Bruker @{} som før
+print $arrayref->[0] . "\n";  # Derefererer peker med ->, som i C.
+
+# Det samme virker for hasher:
+my $hashref = { 'name' => 'ottar', 'liker' => 'sko' };
+my %hash = %{$hashref};
+
+print %{$hashref}->{'name'} . "\n"; # Perl liker ikke }{, så vi må ha pil.
+print $hashref->{'name'} . "\n";
+print $hash{'name'} . "\n";
+
+# Legg merke til at den første bare er stygg, og de to siste ligner ganske
+# mye på hverandre. Ukritisk bruk av referanser kan være en potensiell
+# feilkilde, siden det er lett å blingse. Bare lag en vanlig hash eller
+# array, så unngår du problemet.

foiler/21_todimensjonalt.pl

@@ -0,0 +1,26 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Så, til poenget: Hvordan lage todimensjonale ting?
+# Todimensjonale arrays i Perl 5 er en array med arrayreferanser i.
+# Hva merker vi til dette? Ingen ting. Perl fikser det for oss automatisk.
+
+my @array;
+$array[0] = [ 'rob-geir' ]; # Vi legger en array-referanse fremst i arrayen.
+
+# Om vi printer ut $array[0] nå, får vi bare en referanse, omtrent som når vi
+# printer et rart objekt i Java. Den ser slik ut: "ARRAY(0x814cd28)"
+print $array[0] . "\n";
+
+# Dette er altså egentlig en referanse. Men vent nå litt, da kan vi jo bruke
+# pil-notasjonen fra forrige foil!
+print $array[0]->[0] . "\n"; 
+
+# Men denne pilen er jo kjedelig å skrive. Det fikser Perl! Det virker nemlig
+# uten også!
+print $array[0][0] . "\n";
+
+# Og vips, vi merker ingen ting til dette rare referanse-greiene!
+# Men, det er jo kjekt å vite om dem. Vi kan nemlig bruke dem andre steder
+# også.

foiler/22_todimensjonalt2.pl

@@ -0,0 +1,20 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+# Men av og til må vi likevel vite om dette rare med pekerene. Si vi lager en
+# todimensjonal array med navn i:
+my @array = (
+		[ 'gunnar', 'ottar', 'bengt-åke' ],
+		[ 'kåre', 'ole-rånni', 'per' ],
+		[ 'kåbbai-laila', 'per-kristian foss' ]
+	);
+
+# Og så vil vi gå gjennom alle verdiene:
+foreach my $ref (@array) {
+	my @navn = @{$ref};   # Foreach gir oss referansen, så vi lager en array
+	foreach my $navn (@navn) {
+		print "$navn\n";
+	}
+	print "\n";           # Printer et linjeskift etter hver gruppe
+}

foiler/23_lesing.pl

@@ -0,0 +1,21 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Å lese inn ting med perl
+# Noe av det man gjør oftest i perl er å lese inn data. Dette gjør man med 
+# "<>". Omtrent sånn:
+
+## Lese fra standard in
+# En og en linje:
+while (my $linje = <STDIN>) {
+	print $linje;
+}
+
+# Alt inn i en stor array (krever mer minne, unngå om du kan):
+my @array = <STDIN>;
+foreach my $linje (@array) {
+	print $linje;
+}
+
+

foiler/24_lesing2.pl

@@ -0,0 +1,19 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Å lese fra en fil:
+# Åpne filen, eller dø om det ikke virket.
+open(my $FILDESKRIPTOR, "test.txt") or die("Kunne ikke åpne test.txt: $!"); 
+
+# Les, og print ut med "> " foran:
+while(my $linje = <$FILDESKRIPTOR>) {
+	print "> $linje";
+}
+
+# Lukk.
+close($FILDESKRIPTOR);
+
+# Hett tips: open kan også brukes for å åpne ting for skriving.
+# Kjør kommandoen "perldoc -f open" for å få masse info om alt du
+# kan gjøre med open.

foiler/25_chomp.pl

@@ -0,0 +1,22 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Fjerne linjeskift fra det du leser
+# Til forskjell fra f.eks. sed og grep, fjerner ikke perl linjeskift av seg
+# selv. Om du ikke vil ha dem, må du fjerne dem.
+# Til dette har vi kommandoen chomp.
+
+while (my $linje = <STDIN>) {
+	chomp($linje);
+	print "$linje\n"; # ok, litt unyttig å bare sette på igjen linjeskiftet.
+}
+
+# chomp kan også kjøres rett på en hel array. Da fikser den alle verdiene.
+
+my @array = <STDIN>;
+chomp(@array);
+
+# NB! Det er veldig vanlig å glemme chomp, og så fortsette i god tro.
+# Det kan føre til ekle bugs der linjeskift dukker opp på rare steder.
+# Jeg vet dette fordi jeg gjør det hele tiden selv ;-)

foiler/26_print.pl

@@ -0,0 +1,25 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Printing i Perl
+# Hittil har vi bare sett på basic bruk av print. Men print kan brukes til 
+# mer. For eksempel en fildeskriptor:
+
+# Dette burde gi morosakene ut på standard error.
+# PS: Det er IKKE komma etter fildeskriptoren når du printer!
+print STDERR "Aaaah! Venstre motor brenner!\n";
+
+
+# Om du åpner noe med skrivetilgang med open kan og også bruke print der.
+# Dette overskriver test.txt:
+open(my $DESKR, ">test.txt") or die ("feil ved åpning av test.txt: $!");
+
+print $DESKR "Hei, har du det bra?\n";
+
+close($DESKR);
+
+
+# Print på en array printer alle verdiene:
+my @linjer = ("hei\n", "ost\n", "banan\n");
+print @linjer;

foiler/27_printf.pl

@@ -0,0 +1,27 @@
+#!/usr/bin/perl
+use strict; use warnings;
+
+## Printf: Fancy-schmancy printing
+# Der sitter du med et digert desimaltall, og vil printe det ut med to
+# desimaler. Printf to the rescue!
+my $tall = 3.1415;
+printf("pi: %.2f\n", $tall);
+
+# Eller du har en masse tallverdier med ulik lengde, og vil høyurejustere:
+my @tall = (3, 1337, 25, 254);
+foreach my $tall (@tall) {
+	printf("tall: %4d\n", $tall);  # juksa litt: hardkodet inn maksbredde fire
+}
+
+# Eller du vil printe ut et tall i hex, oktal og desimal, null-paddet til 
+# åtte sifre:
+printf("hex: %08x %08o %08d\n", 255, 255, 255);
+
+# Du kan også lagre resultatet i en annen variabel med sprintf:
+my $leet = sprintf("%03.2f", 13.37890);
+print $leet, "\n";
+# Dette er litt for omfattende til at vi kan herje veldig mye med det.
+# "perldoc -f sprintf" har mer info.
+#
+# Pass på! Det er lurere å bruke print om du ikke trenger ekstra formatering!
+# Printf er tregere, og det er lettere å gjøre feil.

foiler/28_split.pl

@@ -0,0 +1,26 @@
+#!/usr/bin/perl
+use strict; use warnings;
+
+## Splitting av tekststrenger
+# Ofte har man en lang greie man vil splitte inn i en array. No problem!
+
+my $string = "www.pvv.ntnu.no";
+my @deler = split(".", $string);
+# nå inneholder @deler dette: ('www', 'pvv', 'ntnu', 'no');
+
+# Man kan også splitte på flere tegn:
+my $verdier = "en, to, tre, fire, fem";
+my @verdier = split(", ", $verdier);
+
+# I stedet for å skrive en string som tegnet man kan splitte på, kan man også
+# skrive et regulært uttrykk. Vi tar kanskje noe om regulære uttrykk senere,
+# hvis vi rekker det.
+
+# Å splitte på " " (mellomrom) er litt spesielt. Da oppfører perl seg som awk,
+# og gir deg alle ordene, uansett hvor mye whitespace det er mellom. 
+my $setn = "hei, jeg  er    ikke så   flink    med      mellomrom";
+my @setn = split(" ", $setn);
+
+# Om du vil at det skal bli som i cut, med blanke felter mellom spaces som er 
+# inntil hverandre, bruk regulæruttrykket / /:
+@setn = split(/ /, $setn);

foiler/29_join.pl

@@ -0,0 +1,18 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Join, det motsatte av split
+# Hvis du har en array, og skal lage en tekststreng av verdiene, er join
+# tingen for deg. Den setter sammen alle feltene, med en tekststreng mellom.
+
+my @koner = ("magda", "gunhild", "gunda");
+my $penliste = join(", ", @koner);
+print "Koner: $penliste\n";
+
+# Ut kommer dette: "Koner: magda, gunhild, gunda"
+
+
+# Gammelt jegertriks for å lage en diger variabel av en array du har lest inn:
+my @linjer = <STDIN>;
+my $digervariabel = join("", @linjer); # Vi joiner på tom streng

foiler/30_magiske_variable.pl

@@ -0,0 +1,24 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Magiske variabler i Perl
+# De magiske variablene i Perl er beryktet, og flittig kritisert av 
+# Python-brukere. Og ja, de er litt ekle. Ikke bruk dem mer enn du må,
+# og husk å kommentere kode der du eventuelt bruker dem.
+
+# Disse tre dukker opp relativt ofte, og man forventes vel egentlig å kunne
+# dem, så de trenger man ikke forklare i koden. Men husk å forklare eventuelle
+# andre utskeielser!
+
+    $_ # Default-variabelen. Om ikke noe er angitt, brukes som regel
+	   # denne. Kan stort sett unngås, men av og til lurer den seg inn.
+	
+	@_ # Default-arrayen. Dukker stort sett bare opp som argumentene til
+	   # subrutiner (mer om dem senere, om vi rekker det)
+	
+	$! # Feilmelding. Denne variabelen inneholder siste feilmelding.
+	   # Den ble brukt etter open for et par foiler siden.
+
+# Det er hauger av andre magiske variabler også, men disse tre får holde 
+# inntil videre. Er du nysgjerrig på mer, kjør kommandoen "perldoc perlvar".

foiler/31_subrutiner.pl

@@ -0,0 +1,18 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Subrutiner (også kjent som funksjoner eller metoder)
+# Subrutiner er veldig kjekke for å strukturere scripts. De har litt
+# annerledes syntaks enn det vi er vant til, men ikke så veldig.
+
+# Vi lager en subrutine
+sub hei () {
+	print "hei!\n";
+}
+
+# ...og vi kjører den.
+hei();
+
+# ...og en gang til:
+hei();

foiler/32_subrutiner2.pl

@@ -0,0 +1,26 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+# Men vi vil kanskje gjerne gi subrutinen noen argumenter. For å fortelle 
+# subrutinen at den skal ta inn to variabler, gir vi den to $-tegn i 
+# parentesen:
+
+sub hei($$) {
+	my ($navn, $adjektiv) = @_;            # Oi, hva er dette?
+
+	print "Hei $navn, du er $adjektiv!\n";
+}
+
+# Og så hilser vi på noen
+hei("ottar", "kul");
+hei("pål", "illeluktende");
+
+# Nå dukket det opp litt nytt, spesielt den rare greia som heter @_. 
+# @_ er en magisk array der alle argumentene ligger. Jeg vet at det er to 
+# argumenter (det står jo "$$" i parentesen), så jeg kan bare hente dem ut 
+# direkte med to variabler inni en parentes.
+#
+# Denne parentesen er kanskje litt rar, men det er egentlig bare 
+# array-snarveien baklengs. Husk at vi kan si 
+my @array = ('per', 'pål');

foiler/33_subrutiner_return.pl

@@ -0,0 +1,22 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+# Vi vil jo ofte returnere noe fra subrutinene våre. Det er lett. Bare bruk 
+# return $variabel:
+
+# Vi lager subrutinen fjortis, som setter masse utropstegn bakerst på
+# tekst:
+sub fjortis ($) {
+	my ( $tekst ) = @_;
+	return "$tekst!!!11";
+}
+
+# Hent ut fjortis-tegnsatt variabel
+my $fjortis = fjortis("hei");
+
+# Print den.
+print "$fjortis\n";
+
+# Print en dobbeltfjortis variabel
+print fjortis(fjortis("hallo")) . "\n";

foiler/34_subrutiner_array.pl

@@ -0,0 +1,18 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+# Å sende inn og ut arrays fra subrutiner er lett:
+
+# En skikkelig unødvendig og teit subrutine som sorterer mot alfabetet:
+sub descsort (@) {
+	my @array = @_;
+	my @output = reverse sort @array;
+	return @output;
+}
+
+my @array = ('hei', 'hå', 'aha');
+foreach my $ord (descsort(@array)) {
+	print "$ord\n";
+}
+

foiler/35_subrutiner_hash.pl

@@ -0,0 +1,25 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+# Å leke med en hash er også temmelig likt:
+
+sub print_hash (%) {
+	my %hash = @_;                 # Hold an! Hva er dette? Hash = Array? Hæ?
+	
+	foreach my $key (keys %hash) {
+		print "$key = " . $hash{$key} . "\n";
+	}
+}
+
+my %hash = ( 'fnavn' => 'herodes', 'enavn' => 'falsk' );
+print_hash(%hash);
+
+# Dette med "%hash = @_" virker jo litt sært. Men legg merke til at vi bruker
+# de samme parentesene for å lage arrays og hasher. Faktisk er det bare piler
+# stedet for kommaer på annenhver for at det skal bli lettere å se hva som er
+# hva.
+#
+# Når du legger masse verdier inn i en hash gir du den altså bare en array
+# med verdier, og så blir annenhver verdi nøkkel og innhold.
+# (dette virker på samme måten i PHP).

foiler/36_subrutiner_multivar.pl

@@ -0,0 +1,26 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+# Men hva om vi for eksempel vil gi inn to variabler og en array?
+
+sub felleseie ($$@) {
+	my $han = shift;              # Hva er denne shift?
+	my $hun = shift;
+	my @eiendeler = @_;
+	print "$han og $hun eier sammen dette:\n";
+	foreach my $ting (@eiendeler) {
+		print "\t$ting\n";
+	}
+}
+
+my @eiendeler = ('sofa', 'tv', 'stereo');
+felleseie("per", "kari", @eiendeler);
+
+# shift(@array) tar første verdi i @array, fjerner den fra arrayen og
+# returnerer den. ('en', 'to', 'tre') blir altså ('to', 'tre') etter shift.
+# Slik kan vi fjerne de to første variablene, og sitte igjen med resten, som
+# er til arrayen.
+# 
+# Grunnen til at det må gjøres slik er at @_ bare inneholder alle verdiene, 
+# den har ikke system på hva som er hva.

foiler/37_subrutiner_dual_arrays.pl

@@ -0,0 +1,25 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+# Men hva med to arrays? @_ vet jo ikke når den ene slutter og den andre 
+# begynner! Da må vi til med referanser igjen!
+
+sub tell_penisforlengere (\@\@) {
+	my @biler = @{ $_[0] };
+	my @baater = @{ $_[1] };
+	
+	print "Det er ".scalar @biler." bilær og ".scalar @baater."båtær\n";
+}
+
+my @biler = ('mercedes', 'porsche', 'austin martin');
+my @baater = ('sjekte', 'campingcruiser', 'yacht', 'pråm');
+
+tell_penisforlengere(\@biler, \@baater);
+
+# Hva er disse backslashene? Bare en annen måte å lage referanser på.
+# I C ville de tilsvart '&var'. Hvilken du bruker er hipp som happ. 
+# Disse gjør det samme:
+my $biler;
+$biler = [ @biler ];
+$biler = \@biler;

foiler/38_prototyping.pl

@@ -0,0 +1,20 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+# Hittil har vi hatt funksjonen øverst i scriptet. Men da må vi jo scrolle
+# forbi masse drit for å se hva selve programmet gjør (man *skal* gi 
+# subrutinene så logiske navn at man skjønner hva de gjør ut fra navnet.
+
+# Dette fikser vi med en prototype. De er omtrent som i C:
+sub hei ($$);
+
+# Og så bruker vi den
+hei('rob-geir', 'tøff');
+hei('gunnar', 'sexy');
+
+# Og her kommer den.
+sub hei ($$) {
+	my ($navn, $adjektiv) = @_;
+	print "Hei $navn, du er $adjektiv!\n";
+}

foiler/39_prototyping2.pl

@@ -0,0 +1,20 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+# Om du skriver rekursive funksjoner må du uansett prototype. 
+# La oss se på denne greia som teller nedover (på en skikkelig teit måte):
+
+sub tellned ($);
+
+sub tellned ($) {
+	my $tall = shift;
+	
+	print "$tall...\n";
+
+	if ($tall > 0) {
+		tellned($tall-1);
+	}
+}
+
+tellned(10);

foiler/40_subrutiner_epilog.pl

@@ -0,0 +1,17 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Noen siste ord om subrutiner
+# 
+# I en del gammel eller dårlig kode vil du kanskje oppdage at alle 
+# subrutinekall er med '&' foran, og at ingenting er prototypet.
+#
+# Dette var slik subrutiner virket før. De sjekket ikke antall argumenter 
+# eller noe som helst, og man sa fra om at de var subrutiner med &.
+# Det er fremdeles mulig å gjøre det slik av hensyn til bakoverkompatibilitet,
+# men IKKE GJØR DET!
+#
+# Om man gjør dette forsvinner nemlig alle former for feilsjekking rett i
+# rett i dass, siden &subrutine() slår av sjekking av antall argumenter og
+# slikt. Dette er et kjempetriks for å skjule bugs. Just don't do it, okay?

plakat.html

@@ -0,0 +1,88 @@
+<html>
+<head>
+<style type="text/css">
+body {font-family: arial, helvetica, sans-serif;}
+td {vertical-align: top;}
+pre {float: right;}
+.h1 {font-size: 110pt; text-align: center;}
+.h2 {font-size: 40pt;}
+p,td.top {font-size: 16pt; line-height: 20pt;}
+pre {font-size: 6pt;}
+</style>
+</head>
+<body>
+<center>
+<table width="5"><tr><td colspan="3">
+<span class="h1">#!&nbsp;/usr/bin/perl</span><br />
+&nbsp;<br />
+<span class="h2">PVV arrangerer nybegynnerkurs i Perl</span><br />
+&nbsp;<br />
+&nbsp;<br />
+&nbsp;<br />
+</td></tr><tr><td class="top">
+<p>
+<table>
+<tr><td class="top">Tid: </td><td class="top">Torsdag 28. oktober, fra 18:00 til 20:00</td></tr>
+<tr><td class="top">Sted:&nbsp;</td><td class="top">Auditorium R8, Realfagsbygget</td></tr>
+<tr><td class="top">Pris: </td><td class="top">Kr 50 for ikke-medlemmer, gratis for medlemmer (medlemsskap koster kr 42)</td></tr>
+</table>
+</p>
+<p>
+PVV arrangerer kurs for nybegynnere i programmerings- språket Perl. Vi fokuserer på hvordan man kan lage enkle script, og på å gi et grunnlag for å lære seg mer selv.</p>
+<p>Kurset forutsetter litt programmeringserfaring, men halve IT-intro burde holde.</p>
+<p>Kursholder: Knut Auvor Grythe</p>
+</td><td width="20"></td><td>
+<pre>
+#!/usr/bin/perl -w                                    
+use strict;
+                                           $_='ev
+                                       al(&quot;seek\040D
+           ATA,0,                  0;&quot;);foreach(1..2)
+       {&lt;DATA&gt;;}my               @camel1hump;my$camel;
+  my$Camel  ;while(             &lt;DATA&gt;){$_=sprintf(&quot;%-6
+9s&quot;,$_);my@dromedary           1=split(//);if(defined($
+_=&lt;DATA&gt;)){@camel1hum        p=split(//);}while(@dromeda
+ ry1){my$camel1hump=0      ;my$CAMEL=3;if(defined($_=shif
+        t(@dromedary1    ))&amp;&amp;/\S/){$camel1hump+=1&lt;&lt;$CAMEL;}
+       $CAMEL--;if(d   efined($_=shift(@dromedary1))&amp;&amp;/\S/){
+      $camel1hump+=1  &lt;&lt;$CAMEL;}$CAMEL--;if(defined($_=shift(
+     @camel1hump))&amp;&amp;/\S/){$camel1hump+=1&lt;&lt;$CAMEL;}$CAMEL--;if(
+     defined($_=shift(@camel1hump))&amp;&amp;/\S/){$camel1hump+=1&lt;&lt;$CAME
+     L;;}$camel.=(split(//,&quot;\040..m`{/J\047\134}L^7FX&quot;))[$camel1h
+      ump];}$camel.=&quot;\n&quot;;}@camel1hump=split(/\n/,$camel);foreach(@
+      camel1hump){chomp;$Camel=$_;tr/LJF7\173\175`\047/\061\062\063
+      45678/;tr/12345678/JL7F\175\173\047`/;$_=reverse;print&quot;$_\040
+       $Camel\n&quot;;}foreach(@camel1hump){chomp;$Camel=$_;y/LJF7\173\17
+        5`\047/12345678/;tr/12345678/JL7F\175\173\047`/;$_=reverse;p
+         rint&quot;\040$_$Camel\n&quot;;}#japh-Erudil';;s;\s*;;g;;eval;   eval
+           (&quot;seek\040DATA,0,0;&quot;);undef$/;$_=&lt;DATA&gt;;s$\s*$$g;(   );;s
+             ;^.*_;;;map{eval&quot;print\&quot;$_\&quot;&quot;;}/.{4}/g; __DATA__   \124
+               \1   50\145\040\165\163\145\040\157\1 46\040\1  41\0
+                    40\143\141  \155\145\1 54\040\1   51\155\  141
+                    \147\145\0  40\151\156 \040\141    \163\16 3\
+                     157\143\   151\141\16  4\151\1     57\156
+                     \040\167  \151\164\1   50\040\      120\1
+                     45\162\   154\040\15    1\163\      040\14
+                     1\040\1   64\162\1      41\144       \145\
+                     155\14    1\162\       153\04        0\157
+                      \146\     040\11     7\047\         122\1
+                      45\15      1\154\1  54\171          \040
+                      \046\         012\101\16            3\16
+                      3\15           7\143\15             1\14
+                      1\16            4\145\163           \054
+                     \040            \111\156\14         3\056
+                    \040\         125\163\145\14         4\040\
+                    167\1        51\164\1  50\0         40\160\
+                  145\162                              \155\151
+                \163\163                                \151\1
+              57\156\056
+
+# camel code, copyright 2000 by Stephen B. Jenkins
+# The use of a camel image with the topic of Perl 
+# is a trademark of O'Reilly &amp; Associates, Inc. 
+# Used with permission.
+</td></tr></table>
+</pre>
+</center>
+</body>
+</html>