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<70>k skrevet av Larry Wall (han er kul)
+  * Virker i UNIX, Windows, p<> Mac, i VMS, etc etc
+  * Kildekoden til perl er <20>pen (GPL)
+  * Et tolket spr<70>k (kompileres ikke, "kompileres" hver gang det kj<6B>res).
+
+                              HVORFOR PERL?
+
+  * Veldig kraftig, du kan gj<67>re mye med lite kode
+  * Kjapt <20> skrive
+  * Sv<53>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 <20> gj<67>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 <20> 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 <20> 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 <20> 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<65>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<70>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<73> sammen tekst (ogs<67> likt som i PHP, av samme grunn)
+
+# Flere tekststrenger sl<73>s sammen med punktum (Java bruker pluss).
+my $fornavn = "Kjell Magne";
+my $etternavn = "Bondevik";
+my $fulltnavn = $fornavn . ' ' . $etternavn;
+
+# Vi kunne selvsagt ogs<67> brukt dette, som ogs<67> er mye vanligere <20> 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 <20> kunne, men greit <20> 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 <20> 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<70>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 <20> 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<73>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 <20> bruke "==" p<> tekststrenger. Det virker 
+# IKKE i Perl! I Perl er det egne greier for <20> 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<70>k. Yay!
+
+my $counter = 0;
+while ($counter < 10) {
+	print "tallet er $counter\n";
+	$counter++;                       # <20>ker $counter med 1
+}
+
+## For-loop
+# Virker ogs<67> som i andre spr<70>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<67> bruke foreach til <20> 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;
+
+## <20> 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<67>r i andre spr<70>k! Dette er jo skikkelig teit, men man venner seg
+# til det ganske fort. Jeg tipper grunnen er at perl ble laget for <20> parse
+# tekst, og da virket disse navnene mer logiske.
+#
+# En liten tabell: 
+#     +------+-------------+---------------------------------------------+
+#     | Perl | Andre spr<70>k | Betydning                                   |
+#     +------+-------------+---------------------------------------------+
+#     | next | continue    | Hopp over det som er nedenfor og kj<6B>r neste |
+#     |      |             | runde i loopen                              |
+#     +------+-------------+---------------------------------------------+
+#     | last | break       | Avbryt kj<6B>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<70>k
+# scriptet er skrevet i, og hva slags program som skal brukes til <20> tolke 
+# det.
+#
+# Om ikke shebangen var det ville vi m<>ttet vite hva scriptet var skrevet i,
+# og selv kj<6B>rt programmet med filen som argument.
+#
+# Uten shebang:
+# 	perl program.pl
+#
+# Med shebang:
+#   ./program.pl
+#
+# For at programmet skal kunne kj<6B>res direkte m<> det ogs<67> v<>re kj<6B>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 <20> 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 <20> bruke samme variabel til flere ting 
+# uten <20> 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" <20>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<73>r: Advarsler. Det gj<67>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<67>re.
+#
+# Jeg fjernet use strict denne gangen, s<> det skulle bli lettere <20> gj<67>re
+# noe dumt warnings kunne oppdage.
+
+# Eksempel p<> hvorfor warnings er bra:
+
+my $foo = "bar";
+
+print "hei, jeg er $bar\n"; # <20> 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<73>tte for <20> n<>ste
+# arrays og lignende. Todimensjonale arrays var ikke mulig. Folk brukte all
+# verdens grisete triks for <20> f<> til noe tilsvarende. <20>sj!
+#
+# Perl versjon 5 har egentlig heller ikke st<73>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<74>!
+
+# 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<67> gj<67>re ting litt mer direkte, uten <20> 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 <20> velge den du liker best. Personlig derefererer jeg gjerne 
+# referansen og bruker arrayen/hashen direkte etterp<72>, 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 <20> blingse. Bare lag en vanlig hash eller
+# array, s<> unng<6E>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<74> 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 <20> skrive. Det fikser Perl! Det virker nemlig
+# uten ogs<67>!
+print $array[0][0] . "\n";
+
+# Og vips, vi merker ingen ting til dette rare referanse-greiene!
+# Men, det er jo kjekt <20> vite om dem. Vi kan nemlig bruke dem andre steder
+# ogs<67>.

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-<2D>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;
+
+## <20> lese inn ting med perl
+# Noe av det man gj<67>r oftest i perl er <20> lese inn data. Dette gj<67>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<6E> 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;
+
+## <20> lese fra en fil:
+# <20>pne filen, eller d<> om det ikke virket.
+open(my $FILDESKRIPTOR, "test.txt") or die("Kunne ikke <20>pne test.txt: $!"); 
+
+# Les, og print ut med "> " foran:
+while(my $linje = <$FILDESKRIPTOR>) {
+	print "> $linje";
+}
+
+# Lukk.
+close($FILDESKRIPTOR);
+
+# Hett tips: open kan ogs<67> brukes for <20> <20>pne ting for skriving.
+# Kj<4B>r kommandoen "perldoc -f open" for <20> f<> masse info om alt du
+# kan gj<67>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 <20> bare sette p<> igjen linjeskiftet.
+}
+
+# chomp kan ogs<67> kj<6B>res rett p<> en hel array. Da fikser den alle verdiene.
+
+my @array = <STDIN>;
+chomp(@array);
+
+# NB! Det er veldig vanlig <20> 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<67>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 <20>pner noe med skrivetilgang med open kan og ogs<67> bruke print der.
+# Dette overskriver test.txt:
+open(my $DESKR, ">test.txt") or die ("feil ved <20>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 
+# <20>tte sifre:
+printf("hex: %08x %08o %08d\n", 255, 255, 255);
+
+# Du kan ogs<67> 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 <20> bruke print om du ikke trenger ekstra formatering!
+# Printf er tregere, og det er lettere <20> gj<67>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<67> splitte p<> flere tegn:
+my $verdier = "en, to, tre, fire, fem";
+my @verdier = split(", ", $verdier);
+
+# I stedet for <20> skrive en string som tegnet man kan splitte p<>, kan man ogs<67>
+# skrive et regul<75>rt uttrykk. Vi tar kanskje noe om regul<75>re uttrykk senere,
+# hvis vi rekker det.
+
+# <20> splitte p<> " " (mellomrom) er litt spesielt. Da oppf<70>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<75>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 <20> 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 <20> kommentere kode der du eventuelt bruker dem.
+
+# Disse tre dukker opp relativt ofte, og man forventes vel egentlig <20> kunne
+# dem, s<> de trenger man ikke forklare i koden. Men husk <20> forklare eventuelle
+# andre utskeielser!
+
+    $_ # Default-variabelen. Om ikke noe er angitt, brukes som regel
+	   # denne. Kan stort sett unng<6E>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<67>, men disse tre f<>r holde 
+# inntil videre. Er du nysgjerrig p<> mer, kj<6B>r kommandoen "perldoc perlvar".

foiler/31_subrutiner.pl

@@ -0,0 +1,18 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+## Subrutiner (ogs<67> kjent som funksjoner eller metoder)
+# Subrutiner er veldig kjekke for <20> 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<6B>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 <20> 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<73>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;
+
+# <20> sende inn og ut arrays fra subrutiner er lett:
+
+# En skikkelig un<75>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;
+
+# <20> leke med en hash er ogs<67> 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 <20> lage arrays og hasher. Faktisk er det bare piler
+# stedet for kommaer p<> annenhver for at det skal bli lettere <20> se hva som er
+# hva.
+#
+# N<>r du legger masse verdier inn i en hash gir du den alts<74> 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<74> ('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<67>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<69>r og ".scalar @baater."b<>t<EFBFBD>r\n";
+}
+
+my @biler = ('mercedes', 'porsche', 'austin martin');
+my @baater = ('sjekte', 'campingcruiser', 'yacht', 'pr<70>m');
+
+tell_penisforlengere(\@biler, \@baater);
+
+# Hva er disse backslashene? Bare en annen m<>te <20> lage referanser p<>.
+# I C ville de tilsvart '&var'. Hvilken du bruker er hipp som happ. 
+# Disse gj<67>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 <20>verst i scriptet. Men da m<> vi jo scrolle
+# forbi masse drit for <20> se hva selve programmet gj<67>r (man *skal* gi 
+# subrutinene s<> logiske navn at man skj<6B>nner hva de gj<67>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 <20> gj<67>re det slik av hensyn til bakoverkompatibilitet,
+# men IKKE GJ<47>R DET!
+#
+# Om man gj<67>r dette forsvinner nemlig alle former for feilsjekking rett i
+# rett i dass, siden &subrutine() sl<73>r av sjekking av antall argumenter og
+# slikt. Dette er et kjempetriks for <20> 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<70>ket Perl. Vi fokuserer p<> hvordan man kan lage enkle script, og p<> <20> gi et grunnlag for <20> 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>