SCALAR
Scalar benyttes til å lagre tall eller tekst-strenger. Tall lagres som flyttall. Det er automatisk konverting mellom tall og tekst, slik at
if ("1"<2)
er sant. Navnet tall- og tekst-variabler prefikses med dollartegn ved tillordning og bruk av variablen$. Tilordningsoperatoren er likhetstegn, eks $varNavn="verdi";.

ARRAY
Perl array tilsvarer vektorer i java. For å indikere at operatorer og funksjoner skal tolke variablen som en liste benyttes prefikset @. Eksempler på tilording av lister:

@arrayNavn1=("tekst 1","tekst 2", "tekst 3"); @listNavn2=("tekst 1",100,200,3.14 ); @arrayNavn3=("tekst 1", $arrayNavn[1], $arrayNavn[2]);    #arrayNavn3 vil ha samme innhold som arrayNavn1 @arrayNavn4=(@arrayNavn1,@arraynavn2);    #arrayNavn4 vil først innholde elementen i arrayNavn1 og deretter elementene arrayNavn2 @arrayNavn5=("navn1","verdi 1","navn2","verdi 2","navn3","verdi 3"); @arrayNavn6=@arrayNavn1;    #Setter arrayNavn6 lik en liste som er kopi av arrayNavn1

En kan direkte referere til enkelt elementer i arrayen ved bruk tall-indeker. Eksempel på referanse til første element i arrayen arrayNavn2: $arrayNavn2[0]. Negative indekser blir tolket som indeksering bakfra slik at $arrayNavn2[-1] returnerer siste elemententet i arrayen som er lik 3.14. . For forklaring på bruk av dollar-tegn i stedet alfakrøll, se omtale av kontekst. Perl har noen standard funksjoner som opererer på arrayer:

pop(@listNavn)	fjerne siste element i arrayn
shift(@listNavn)	Fjerner første element i arrayn
push(@listNavn,"element 4")	Legger nytt element inn bakerst i arrayn
sort(@listNavn)	Sortere arrayn alfabetisk

@ARG er en predefinert array som innholder alle environment variabler.

Arrayer av arrayer kan deklares på følgende måte:

HASH
Hash er tabeller der en benytter nøkkelord istedet for tall for søke fram verdier. For å indikere at operatorer og funksjoner skal tolke variablen som en hash benyttes prefikset %. Eksempeler på tilordnig av hash-tabeller som vil innholde samme elementer:

%hashNavn1=("navn1"=>"verdi 1","navn2"=>"verdi 2","navn3"=>"verdi 3"); %hashNavn2=("navn1","verdi 1","navn2","verdi 2","navn3","verdi 3"); %hashNavn3=@arrayNavn5;

En kan direkte referere til enkelt elementer ved bruk nøkkelordet, f.eks $arrayNavn1{"navn1"} er "verdi 1". For forklaring på bruk av dollar-tegn i stedet for prosent-tegnet se omtale av kontekst. Perl har noen standard funksjoner for hash-tabeller:

keys(%hashNavn)	returnerer en array med alle nøkler i hashen
values(%hashNavn)	returnerer en array med alle verdier i hashen

@ENV er en predefinert hash som innholder alle programmets parametre

Kontekst
Mange operatorerer og funksjoner i Perl kan operere på både scalare- og array/hash-variabler. Operatorene og funksjonene kan ha ulik betydning med hensyn til kontekst. Kontekst er et viktig begrep i Perl. Konteksten angir forventet type resultat eller retur verdi til operatorerer og funksjoner. Det er fire typer kontekster:

• Scalar-kontekst forventer et tall- eller en tekst-verdi. Eksempler:
  $x=("null","en");    #setter x lik "en", det siste elementet i listen.
  $x=@arrayNavn1;    #settes x lik 3, som er lik antall elementer i listen.
  I disse to tilordningene av x skiller Perl på lister og array. Alle elementer til listen vil plasseres i en midlertidig stakk. Siden dette er en scalar-konteks tilordnes kun siste elementet. Variablen arrayNavn1 vet at den er en array-variabel som befinner seg i scalar-kontekst og plassere derfor ingen elementer i den midlertidige stakken, men returner kun antall elementer i arrayen.
• Liste-kontekst forvententer en liste eller tabell. Eksempler:
  @y=("null","en");    #setter y lik listen slik at $y[0] er lik "null" og $y[1]="en".
• Boolean-kontekst forventer "true" eller "false". Perl tolker strengen "" og "0", tallet 0 samt variabler som ikke er tilordnet verdier som usann. Alle andre verdier er sanne. Operatratorer og funksjoner gir samme resultat som i scale-kontekst.
• Void-kontekst forventer ingen retur verdi.

Referanser og datastrukturer
Det er to typer referanser: "hard" og "symbolic". Hard- og symbolic-referanser er analogt til hard- og symbolics-links til filer i Linux. Hard-referanser innholder noe tilsvarende adressen til hvor selve verdien er lagret (dette er også analogt til pekere i c). Symbolic-referanser innholer navn (labelen) på en variabel. Hard-referanser betraktes som en egen datatype i Perl. Tilordning av denne variablene skjer på flere måter:

TILORDNING AV REFERANSER	BRUK AV REFERANSER
$hardRef1=\"tekst1";	$$hardRef1
$hardRef2=\$x;	$$hardRef2
$hardRef3=\@arrayNavn1;	$$hardRef3[1], $${hardRef3}[1], $hardRef3->[1]
$hardRef4=\%hashNavn1;	$$hardRef4{"navn1"}, $${hardRef4}{"navn1"}, $hardRef4->{"navn1"}
$hardRef5=\&subNavn1;	&$hardRef5(), &${hardRef5}(), $hardRef5->()
$hardRef5=\*globNavn1;
$hardRef6=["a1","b1",["tekst 1","tekst 2","tekst 3"]];	$hardRef->[2][0], $hardRef->[2]->[0]
$hardRef7=["a1","b1",[@arryNavn1]];	$hardRef->[2][0], $hardRef->[2]->[0]

hardRef6 og hardRef7 simulerer 2-dimensjonale arrayer. I dette eksemplet innholder hardRef6 og hardRef7 like elementer.

Symbolic-referanser en en tekst-variabel som innholde navnet på en variabel. F.eks $x="y"; der y er navnet på en scalar tekst eller tall-variabel. Her vil $$x=24; føre til at y blir lik verdien 24. Tilsvarende blir om y er en array da vil $x->[0]=24; sette første element i arrayen til 24. Om y er hash vil x->{"key"}=24; sette elementet med navn "key" til 24.

Vi har sett over at bruk av referanser kan simulere 2-dimensjonale arrayer. Alternativt kan de to-dimensjonale arrayene deklares ved:

ARRAY AV ARRAY	REFERERE TIL ELEMENTER
@array6=["a1","b1",["tekst 1","tekst 2","tekst 3"]];	$hardRef[2][0], $hardRef[2]->[0]
@array7=["a1","b1",[@arryNavn1]];	$hardRef[2][0], $hardRef[2]->[0]

Arrayer og hash-tabeller kan også kombineres.

Filehandle
Filhandler referer til filer og pipes. Filhandle tilordnes verdi ved hjelp av open-funksjonen. F.eks kan to filer åpnes for henhonholdvis lesing og skriving ved følgende programlinjer:

open ( InnH, "<innfil.txt"); open ( UtH, ">utfil.txt");

Filhandlerene InnH og utH og referer til hver sin fil. En kan nå lese og skrive til filene ved å benytte på filhandlerene:

$linje=<InnH>; print (UtH $linje);

Her leses neste linje fra filen som handleren InnH referer til. Linjeskilletegnet "\n" følger med på lasset og kan eventuelt fjernes med kallet: chomp($linje). Print skriver linjen til filen angitt av filhandleren. Legg merke til at det ikke er komma mellom filhandler og teksten som skrives ut

Det er predefinerte filhandlere for standard innput, output og error: STDIN, STDOUT og STDERR. I mang tilfeller vil dette være default handlere. F.eks vil <> lese fra STDIN og print-funskjonen skriver til STDOUT om ikke annet oppgis. Se omtale av open-funksjonen nedenfor for syntaks for å appende til filer og åpne piper.

Typeglob
Typeglob har har sammenheng med at det i perl kan deklares forskjellig typer variabler med samme navn. Den viktigse bruk av Typeglobal er ved eksport av variabler i moduler, se eget kapittel. I avsnitt over om referanser så vi hvordan en kan benytte typeglob til å lage alias for refanser til verdier i alle variabeltyper med samme variabelnavn. Her følger noe andre eksempler på bruk av typeGlob

• Lage alias
  *a=*b;
  Dette betyr at a er et alias for b. I alle sammehenger er bruk av a og b ekvivalent.
• TypeGlobale benyttes ved lagring av filhandlere:
  $MinHandle=*FilHandle;
• Definering av konstanter:
  *PI=\3.14;
  PI er nå deklarert som kun en lesbar scalar.

• Søking: $tekst=~m/bil/;
• Substituering: $tekst=~s/bil/bruktbil/g;

For dokumentasjon av regulære utrykk se beskrivelse av Javascript.

• unless er en if-test som utføres når betingelsen er falsk
• until er en while løkke som utføres så lenge betingelsen er falsk. unless
• foreach VAR LIST {- - - - } Løkkke som går igjennom elementer i LIST-arrayen. Nytte element plassers i VAR for hver gjennomløp.
• Hver program-linje kan tillegges en if- og unless-test som bestemmer om setningen skal utføres eller ikke. Eks:
  print "tekst" if ($x==1);

Funksjoner
Funksjoner i Perl kalles subrutiner. Her følger eksemple på vanlig syntaks til definisjon av en subrutine vi her har kalt "sum"

sub sum {    print (1+3); }

Denne rutinen kan kalles ved å bruke en av følgende ekvivalente programlinjer

sum(); ∑

Prefiksing med &-tegnet over gir interpreteren beskjed om tolke etterfølgende navn som en en subrutine. Rutinen kan alternativt defineres uten navn og sette en refaranse variabel til å peke på rutinen.

&sum=sub {    print (1+3); }

Rutinen over kan vi enkelt utvide til ta argumenter og returne verdier. Argumenter og returverdier overføres i arrayer. Argumenter overføres i arrayen med det spesielle variabelnavnet: $_. Arrayen $_ er definert lokalt til rutinenen. Aktuelle paremetere overføres "by name". Verdien i arrayen er alias for de aktuelle pararametrene slik at endring inne i rutinen på verdien til argumentene vil også endre den aktuelle parameteren på utsiden av rutinen. Definisjonen av rutinen sum kan nå bli som følger:

sub sum {    print ($_[0]+$_[1]); }

Rutinen kan kalles på følgende måte:

sum(1,2);

Retur verdi til rutiner er verdi generert av siste programlinje i rutinen eller verdi returnert av funkjonen return i rutinen. Rutiner kan returnere både scalar-, array- og hash-verdi, men avhengig av i hvilken kontekst funksjonen er kalt vil verdien eventuelt bli konvertert. Definisjon av rutinenen sum til å returne summen av argumentene blir som følger:

sub sum {    $_[0]+$_[1]; }

Eksempl på bruk av denne subrutinen. Begge kallene nedenfor er ekvivalente. Subrutiner trenger ikke å omslutte sine argumenter med parantes:

sum(1,3); sum 1,3;

For å bruke subrutiner før de er definert ( selve programkoden ) må de deklareres.

sub sum($$);     #deklarsjon av sum print sum(1,3); sub sum($$){     #definisjon av sum (PS definasjonen må nå inneholde argument-typer) $_[0];+$_[1]; }

En kan også merke seg at det er lovlig med rekursive kall på rutiner.

AUTOLOAD
Vanligvis kan en ikke kalle på en subrutine som ikke eksisterer, men i Perl er mulig å ha en default rutine som benyttes om ingen annen passer. Denne rutinen må navnet AUTOLOAD. Hvert navnerom (se forklarin i kapittelt "Package, symbol-tabell og scoped til variabler" ) kan ha sin AUTOLOAD rutine.

$a=1; package To; $a=2; print $a;     #skriver ut: 2 print $main::a;     #skriver ut: 1 package main print $a;     #skriver ut: 1 print $To::a;     #skriver ut: 2

Alle variabelnavn tilhørende et navnerom lagres i en symbol-tabell oppkalt etter navnerommet. Symbol-tabellen for navnerom "To" over er "%To::". Bare navn som begynner med bokstaver eller lav bindestrek kan lagres i symbol-tabellen. Alle variabler inkludert $! , $! og $_ har tvunget tilhørighet til main-rommet. Nøkkel i symbol-tabellen er navnet på variablene og verdien tilhørende typeglobe. For eksempel vil symbol-tabellen etter tilordning av $a i package To innholde følgende:

print $To::{"a"};     #skriver ut: *To::a

Ved å endre verdier i symbol-tabellen kan en lage alias.

$b="C"; @b=("D","E"); *a=*b; print $main::a;     #skriver ut: *main::b print "$a";     #skriver ut: C print "@a";     #skriver ut: DE

Alias kan benyttes til å aksesser variabler innenfor en annen pakke uten å prefikse variabelnavnet med pakkenavnet. Det er også mulig å gjøre variabler og rutiner tilgjengelige uten prefiks i alle andre pakker ved å bruk funksjonen our, f.eks:

$a=1; our $a; our $b=2; package to; print $a.$b;      #skriver ut 12

Our gjør variablen direkte aksesserbar innenfor filen eller blokken den deklarer variablen i, uavhengig av pakke-grenser.

Scope til variabler
Scope til variabler er globalt om ikke annet er oppgitt. Om en definere en variabel inne i en annen {}-blokk eller subrutine kan de likevel aksesseres på utsiden. Tilsvarende for subrutiner. Ved bruk av package så vi over hvordan vi kunne knytte variabelnavn til ulike navnrom, men alle variablene kan forsatt aksesseres i alle rom ved å prefikse variablenavn med navnet på rommet. For å deklare en variabel eller rutine "lexically", som betyr kun aksessesbar innenfor en {}-blokk, må deklarasjonen prefikses med my eller local. Variabler og subrutiner prefikset med my vil ikke bli lagret i symbol-tabellen og "eksisterer" kun innefor {}-blokken subrutinen de er definert. My-variabler er aksessbar innenfor blokken uavhengig av pakkegrenser. Local lager ikke noen lokal variabler, men legger eksisterende verdi til global-variabel med samme variabelnavn og type på en stakk. Når programmet forlater {}-blokken eller subrutinen inneholdene local deklarasjon vil opprinnelig verdi til variablen hentes tilbake fra stakken. Koden nedefor viser et eksempel hva forskjellen mellom my og local utgjør i praksis:

$a=1; { local $a=3; print inc();      #skriver ut 4 } sub inc{ ++$a}; }

Blir local her endret til my vil verdien 2 skrives ut.

Vi vil starte med et eksempel uten objekt-orientert programmering for å vise den lille endringen som gjøre for at det kalles objektorientert i Perl. Her vil vil lage en subrutine "skrivHash" i navnerommet "MinKlasse". Subrutinen tar som første parameter en referanse til hash. Den andre parameteren er et navn som benyttes som nøkkel i hashen til verdien som skal skrives ut:

package MinKlasse; sub skrivHash{ my $hashRef=shift; my $navn=$_[0]; print $hashRef->{$navn}; } package main; %i=("fornavn"=>"henrik"); $instans1=\%i; MinKlasse::skrivHash($instans1,"fornavn");       #skriver ut: henrik

Nå skal vi gjøre eksemplet over om til objektorientert programmering i Perl:

package MinKlasse; sub skrivHash{ my $hashRef=shift; my $navn=$_[0]; print $hashRef->{$navn}; } package main; %i=("fornavn"=>"henrik"); $instans1=\%i; bless($instans1,"MinKlasse"); $instans1->skrivHash("fornavn");       #skriver ut: henrik

Det er kun de to nederste programlinjene som er endret. Her benytter vi bless for knytte hash referansen "instans1" opp mot navnrommet "MinKlasse". I kallet på metoden "skrivHash" vil automatisk hashen, som "instanse1" refererer til, bli tillagt som første argument. Ved å definere er metode i klassen som kan benyttes som konstruktør blir syntaksen enda mer likt hva vi er vant til fra objektorientert programmering. Konstruktøren har vi naturlig nok kalt "new":

package MinKlasse; sub new { bless {}} sub skrivHash{ my $hashRef=shift; my $navn=$_[0]; print $hashRef->{$navn}; } package main; $instans1=MinKlasse::new(); $instans1->{fornavn}="henrik"); $instans1->skrivHash("fornavn");       #skriver ut: henrik

Subrutinen "new" returnerer en referanse til en ny hash som er bless-et til navnreommet MinKlasse. Variablen "instans1" settes lik denne referansen og blir dermed en instanse av klassen "MinKlasse". Videre legges elementet "fornavn=>henrik" inn som lokale variable til "instans1". I eksemplet over kalles "new" som en subrutine med såkalt kvalifisert-navn (navn på subrutine eller variabel prefikset med pakkenavn etterfult av doble kolon). I stedet subrutine-kall bør metode-kall benyttes for "new". I eksemplet over benytter vi metode-kall på "instans1->skrivHash". Her er metoden kalt som en instans-metode. Det er også mulig å kalle metoder som klasse-metode. Kallet på "new" i eksemplet over kan kalles som en klasse metode som følger:

$instans1=MinKlasse->new();

Her bør en merke seg at navnet på klassen, altså "MinKlasse", blir automatisk oppgitt som første argument i klasse-metode-kallet. Perl har også en alternativ akvivalent syntaks som kan benyttes for kall på metoder som både instans- og klasse-metoder, f.eks:

$instans1=new MinKlasse ();

Nå begynnner dette å ligne svært på vanlig objekt-orientert syntaks. Videre kan vi modifisere vårt eksempel slik at lokale variabler blir initsiert av konstruktøren.

package MinKlasse; sub new { my $klasseNavn=shift; my %hash=@_; return bless(\%hash, $klasseNavn); sub skrivHash{ my $hashRef=shift; my $navn=$_[0]; print $hashRef->{$navn}; } package main; $instans1=new MinKlasse ("fornavn"=>"henrik"); $instans1->skrivHash("fornavn");       #skriver ut: henrik

En klasse kan arve metoder fra en annen klasse ved hjelp av arrayen @ISA. Ønsker vi f.eks. "DinKlasse" skal arve alle metoder i "MinKlasse" gjøres det som følger:

package DinKlasse; our @ISA="MinKlasse";

package main; $dinInstans1=new DinKlasse ("dittnavn"=>"marie"); $dinInstans1->skrivHash("dittnavn");       #skriver ut: marie

For å finne korrekt methode i kall på "new" og "skrivHash" vil Perl sjekk i rekkefølge følgende seks muligheter:

1. Sjekker klassen har subrutine med navnet, d.v.s. en subrutine med dette navnet er definert innenfor navnerommet instansen tilhører
2. Sjekker om subrutinen er arvet fra fedre og stamfedre, d.v.s. en subrutine definert i en av klassene nevnt i @ISA-arrayen. Elementene i arrayen vil traverseres fra venster mot høyere og dybden før bredden.
3. Sjekker om subrutine med dette navn i pakken UNIVERSAL::
4. Perl gir å finner noe subrutine med dette navnet og sjekke om klassen har en AUTOLOAD subrutine.
5. Perl sjekker alle aller fedre og stamfedre for AUTOLOAD subrutine
6. Perl sjekker til slutt om de finnes en UNVIVERSAL::AUTOLOAD subrutine

• $instans1->isa("MinKlasse");
  Subrutinen "isa" returnerer sant om instansen som kaller på den er medlem av klassen MinKlasse.
• $instans1can("skriveHash");
  Subrutinen "can" returnerer sant om instansen har en subrutine med navn "skrivHash". Fedre vil også sjekkes.
• $instans1->VERSION();
  Returnerer versjonsnummeret til klassen instansen peker til. Versjonen til klassen er deklarert i $VERSION variablen.

SCALAR	ARRAY	HASH	FILEHANDLE
TIESCALAR class, list	TIEARRAY class, list	TIEHASH class, list	TIEHANDLE class, list
FETCH self	FETCH self, subscripT	FETCH self, key	READ self, scalar, length, offset
STORE self, value	STORE self, subscript, value	STORE self, key, value	READLINE self
DESTROY	FETCHSIZE	DELETE self, key	GETC self
	STORESIZE self, count	CLEAR self	WRITE self, scalar, length, offset
	CLEAR self	EXISTS self, key	PRINT self, list
	PUSH self, list	FIRSTKEY self	PRINTF self, format, list
	POP self	NEXTKEY self, key	CLOSE self
	SHIFT self	DESTROY self	DESTROY self
	UNSHIFT self, list
	SPLICE self, offset, length, list
	EXTEND self, count
	DISTROY self

Tie-funksjonen binder en variabel til en klasse som innholder methoder som overskriver standard event-methoden for variablen. Variablen er av type: scalar, array, hash eller typeglob. Typeglob representerer filhandler. Tie-funksjonen kaller respektiv konstruksjon-metode for hver av typene: TIESCALAR, TIEARRAY, TIEHASH eller TIEHANDLE. Her følger et eksempel på hvordan en kan oveskrive event-methodene til en scalar:

#! /usr/bin/perl package kr; sub TIESCALAR {bless \my $self, shift}; sub STORE {${$_[0]}=$_[1]};     #default tilordning sub FETCH {printf "%.02f", ${my $self=shift}};     #avrunder til 2 siffer bak komma package main; tie $sum, "kr"; $sum=5*6.5647; printf ("Total sum: $sum\n");     #skriver ut beløp med to siffer bak komma

Tie-funksjonen kaller på TIESCALAR i klassen "kr". Legg merke til at her benyttes "bless" på vanlig måte for å knytt en referanse til en scalar variabel til klassen "kr". Til forskjell fra vanlige klasse vil operatører på variablen "sum" kaller metoder i klassen "kr".

use modulnavn liste

"Modulnavnet" er her likt navnet på en standard modul eller en egendefinert modul. Alle standard moduler som er tilgjengelig i våre webhotel befinner seg i katalogen /usr/lib/perl5/5.6.0/ og /usr/lib/perl5/site_perl/ (opprett en ssh-forbindelse og bruk ls-kommandoen på katalogen). "Liste"-argumentet kan benyttes ved tradisjonelt interface og innholder navn på de variabler og subrutiner en ønsker å importere fra modulen.

Objekt-orientert interface
I objekt-orient interface oppretter man en eller flere instanser av modulen. Variabler og subrutiner i modulen er deretter tilgjengelig ved vanlig objektorienter syntaks, eks på opprettelse av en instans av CGI-modulen:

$q= new CGI;      #oppretter insans q av CGI $q->header(-type=>'text/html');      #skriver ut hode-felt

Tradisjonelt interface
I tradisjonelt interface eksporterer modulen navn på variabler og subrutiner inn i navnerommet til programmet der modulen benyttes. Her følger eksempel på en modul som eksporterer en rutine "fart" og variablen "merke" (koden må lagres i en fil kalt Bil.pm).

#! /usr/bin/perl package Bil; require Exporter; our @ISA=qw(Exporter); our @EXPORT=qw(&fart $merke); our @EXPORT_OK=qw($farge); our $VERSION=1.00; $merke="Ferrari"; $farge="rød"; sub fart { printf "Du kjøre en %s %s i %.02f km/t\n",$farge, $merke, rand $_[0];}

Her følger eksempel på et program som benytter modulen (programmet må lagres i samme katalog som Bil-modulen)

#! /usr/bin/perl use Bil; $fartsgrense=100; fart($fartsgrense);

Vi ser at Bil-modulen arver egenskaper til Exporter-modulen. I @EXPORT-arrayene angir en navn på variabler og rutiner som pr. default skal exporteres inn i navnerommet til programmet som benytter modulen. Modulen importeres i programmmet ved use-funksjonen. Use kan i tillegg til navn på modul ta en liste med navn på de variabler og rutiner en ønsker å importere. De oppgitte navn må også forekomme i @EXPORT, @EXPORT_OK eller @EXPORT_TAGS i modulen. Spesifiserer en ingen argument utenom modul-navnet use-funksjonen blir alle navn listet i @EXPORT importert.

Kompilatoren ser etter moduler i kataloger listet i @INC-arrayen. For legge til katalognavn kan følgende kode benyttes:

BEGIN{ push @INC, "/home/no/serlvets/perl/moduls/"; }

Begin-blokken utføres av kompilatoren før programmet starter. I eksemplet over vil nå kompilatoren i tillegg se etter moduler i katalogen "/home/no/servlets/perl/moduls/". Navn på egendefinerte moduler og variabler bør ikke innholde bare store eller små bokstaver da dette kan føre til sammenblanding med standard moduler.

Pragma-modulen
Pragma-modulen påvirker kompilatoren under utføring av ditt program.

CGI-modulen
Modulen innholder bl.a. subrutiner for å lese ut environment-variablen QUERY-STRING. Modulen har både tradisjonelt og objekt-orientert interface, her omtales kun det objekt-orientert. Oppgis ingen parametere ved instansiering av modulen vil QUERY-STRING leses inn, men det også mulig å direkte oppgi parameterverdier til instansen, her følger noen eksempler:

$s1=new CGI;	#Leser envirionment variablen QUERY-STRING
$s2=new CGI (filhandler);	#Leser parameterer på formen navn=verdi <linjeskift> fra filen.
$s3=new CGI (\*STDIN);	#Leser parametere fra stdin
$s4=new CGI (%hashnavn);	#Leser parametere fra hash
$s5=new CGI ($stringnavn);	#Leser en streng formater som URL-søkestreng
$s6=new CGI ("");	#Leser ingen parametere

Parameterverdien kan også leses ut igjen på flere ulike måter:

@navn=$s->param;	#Plassere alle navn på parametrene i en array
@verdier=$s->param(@navn);	#Plassere alle verdier til parametrene i en array
$s->import_names ("R");	#Lager en variable i navnerommet "R" for hvert "navn=verdi" par
$s->save (filhandle);	#Skrive "navn=verdi" par til fil. Hver par er avskilt med linjeskift
$verdi=$s->param("navn");	#Henter ut verdien til parameter med navn "navn"
$s->delete("navn");	#Sletter en parameter par
$s->delete_all();	#Sletter all parametre

For ytterlige informasjon om CGI-modulen og andre moduler anbefaler vi å opprette en ssh-forbindelse til våre webhotell og les manualen eller selve perl-koden i modulen, f.eks for CGI-modulen kan en gi følgende kommandoer

perldoc CGI
more /usr/lib/perl5/5.6.0/CGI.pm

Samme dokumentasjon, men med bedre layout: http://perldoc.com/perl5.8.0/lib/CGI.html

#! /usr/bin/perl use Net::SMTP; use CGI; $s=new CGI; $s->import_names("R"); print "Conent-type: text/plain\n\n"; print $R::navn; $smtp=Net::SMTP->new('localhost'); $smtp->mail('info@registrar.no'); $smtp->recipient($R::epost); $smtp->data(); $smtp->datasend("Subject: Demo av CSS og Perl\n"); $smtp->datasend("\n"); $smtp->datasend("Denne mail er usendt av et test eksempel vi har av CSS og Perl, der vi oppfordrer kunder til å skrive inn egen e-postadresse. Vi beklager om oppgitt e-postadresse ikke er korrekt. E-postadressen og eventuell annen oppgitt informasjon blir uansett ikke lagret hos oss.\n\nMed vennlig hilsen\nREGISTRAR.NO"); $smtp->dataend(); $smtp->quit;

1. Lokaliserere Perl interpeteren som skal benyttes.
3. Importere NET::SMTP-modulen.
4. Importeres CGI-modulen.
5. Lage en instans av CGI-modul. $s blir referanse til instansen. Instansen leser environment-variablen QUERY-STRING.
6. Her vil alle par på formen navn=verdi i QUERY-STRING genere en variabel med navnet "navn" og tilordnes verdien "verdi". De variablen blir deklarert i navnerommet "R".
8. Skriver ut hodefelt til stdout. Kun "Content-type" er plikt og legg merke til doble linjeskift mellom hodefelt og body.
9. Begynner utskrift av selve bodyen som her kun inneholder verdien til parameter "epost".
11. Lages en instans av Net::SMTP modulen som initsieres til å åpne en forbindelse til lokal smpt-server for utsendelse av e-post.
12. Oppgir avsender
13. Oppgir mottager
14. Starter på selve data-blokken i meldingen
15. Oppgir subject
16. Mimefelt skilles fra selve innholdet i meldingen med et ekstra linjeskift
17. Selve innholdet i meldingen
18. Avslutter meldingen
19. Avslutter forbindelsen til smtp-server.

    For mer informasjon om Net::SMTP modulen.

• Inkluder linjen

  use DBI(); 

  øverst i skriptet.
• Kall på funksjonen

  DBI->connect

  Som parametere oppgir du en URL på formen

  DBI:mysql:database=<din_database>;host=<hostnavn_eller_ipnr>

  samt brukernavn, passord og en hashtabell som brukes i forbindelse med feilhåndtering. I retur får du en database-handle.

  Eksempel:

     
     my $dbh = DBI->connect("DBI:mysql:database=testbase;host=db8.registrar.no",
  		       "testuser", "passord",
  		       {'RaiseError' => 1});
  

• For å gjøre oppdateringer på basen, kall på $dbh->do(<sql-kall>);

  Eksempel:

     $dbh->do("INSERT INTO Ordrer (Vare, Antall) VALUES (?, ?)", undef, $vare, $antall);
  

  $dbh->do tar to standard parametere. Den første er selve sql-setningen, den andre benyttes ikke av MySQL. Etterfølgende parametere blir substituert for ? i selve sql-setnignen.
• For å hente ut informasjon fra basen, kall først på

     dbh->prepare(<sql-kall>)
  

  som gir deg et statement-objekt. Kall på execute() på dette objektet, deretter kan du f.eks. kalle fetchrow_hashref() for å lese ut en og en linje.

  Eksempel:

     my $sth = $dbh->prepare("SELECT * FROM Ordrer");
     $sth->execute();
     while(my $ref = $sth->fetchrow_hashref()) {
         print "<tr><td> $ref->{'Vare'} </td><td> $ref->{Antall} </td>";
     }
     $sth->finish();
  

• Når du er ferdig med å bruke basen, lukk forbindelsen med

     $dbh->disconnect();
  

ADVARSEL: Koden innholder passord til database. For å beskytte dine programfiler for innsyn må korrekte fil-rettigheter settes, se SSH.

• Bøker: "Programming Perl" av Larry Wall, Tom Christiansen og Randal Schwartz. Dette er biblen for perl-programmerere og kalles også "kamelboken" p.g.a. av bildet av dyret på forsiden.
• Nyhetsgrupper: no.it.programmering.perl
• www.perl.org
• http://www.perldoc.com Dokumentasjon av Perl og moduler
• http://www.perldoc.com/perl5.8.0/pod/perlintro.html Intro til Perl
  
• www.cpan.org Comprehensive Perl Archive Network er det sentrale stedet for nedlasting av Perl intepreter, moduler og script.