**Perl**, uoffisielt også kalt *Practical Extraction and Report Language*, er et programmeringsspråk som ble utgitt av Larry Wall 18. desember 1987. Språket «låner» mye av sin funksjonalitet fra for eksempel C, Unix-skripting (sh), awk, sed, Lisp og (i mindre grad) mange andre programmeringsspråk.

Filosofi
--------

Perl ble laget for å være et praktisk språk for å prosessere filer og hente ut og generere tekstlig informasjon. Et av mottoene er «There's more than one way to do it» (TMTOWTDI – uttales «Tim Toady»), som direkte oversatt til norsk betyr «det er mer enn én måte å gjøre det på». Et motto for språket var å gjøre «enkle oppgaver enkle å løse, og vanskelige oppgaver mulige å løse».

Perl har direkte støtte for regulære uttrykk i sin syntaks for enkel og kraftig tekstprosessering, og språket er ofte betegnet som det typiske skriptspråket og har blitt kalt «limet som holder webben sammen» på grunn av språkets popularitet som «CGI-språk».

Historie
--------

Larry Wall, utdannet lingvist, skapte versjon 1.0 mens han jobbet som systemadministrator hos NASA i 1987. Hans formål var å lage et generelt scriptspråk for Unix for å forenkle rapportprosessering. Bruken av Perl nådde nye høyder i den første tiden da World Wide Web tok av rundt 1994, og ble de neste 3-4 årene av mange ansett som en de-facto standard for å lage dynamiske nettsider (webapplikasjoner) med CGI og databasekobling. Med mod\_perl for Apache og rammeverk som Catalyst, Mason m.fl. brukes Perl fortsatt til web-programmering selv om andre språk har blitt mer populære.

Perl 6 og Raku
--------------

Utviklingen av Perl 6, senere kallt Raku, har foregått samtidig med at Perl 5 også utvikles med årlige oppgraderinger. Perl 6 var rundt år 2000 tenkt som neste utgave av Perl 5, men endte opp som et nytt språk og er ikke bakover-kompatibelt. Perl 6 tok opprinnelig i bruk Parrot, en virtuell maskin som ble utviklet parallelt med tanke på å støtte flere programmeringsspråk. I 2014.08-utgaven så byttet Perl 6 sin virtuelle maskin til MoarVM. Med 2019.11 utgaven byttet språket navn til Raku for å gjøre språkets betydelige forskjeller fra Perl tydeligere. 

Raku styrker bl.a. støtten for grammatikker, funksjonell programmering med blant annet "lazy evaluation" og objekt-orientert programmering. Raku finnes i flere implementasjoner der Rakudo av mange anses som den offisielle.

Perl 6 ble utgitt 24. desember 2015.

Innebygde datatyper
-------------------

Perl har en rekke innebygde datatyper, hvorav de vanligste:

* *Skalarer* (en. *scalars*) kan holde en enkelt verdi, f.eks. en tekststreng, et nummer eller en referanse.
* *Tabeller* (en. *arrays*) kan holde flere skalarer basert på en indeks (som starter ved posisjon 0).
* *Assosiative tabeller* (en. *hashes*) er uordnede samlinger bestående av skalarer som er indeksert på basis av den assosierte nøkkelen.
* *Filpekere* (en. *file handles*) kan holde styr på posisjon, lesing, skriving o.s.v. for filer, *pipes*, *sockets* og lignende.
* *Katalogpekere* (en. *directory handles*) kan tilsvarende holde styr på kataloger.
* *Subrutiner* (en. *subroutines*) kan holde brukerdefinerte funksjoner, metoder og closures.

Verdier av disse typene (og flere) kan tilordnes navngitte variabler. Et tegn, «sigil», foran variabelnavnet angir vanligvis hvilken datatype vi får fra en variabel, uavhengig av hva slag datatype(r) som er tilordnet variablen.

«$» foran variabelnavnet gir en skalar, om variabelen holder en skalar, en tabell (med indeks) eller en hash (med indeks):

```
$foo                  # en enkel skalar $foo
$maaneder[11]         # det 12. elementet i tabellen @maaneder
$adresse{'Per'}       # elementet med nøkkelen 'Per' i hashen %adresse
```

«@» foran variabelnavnet gir en liste, om variabelen holder en tabell (med eller uten indeks) eller en hash (med indeks):

```
@maaneder             # ( $maaneder[0], $maaneder[1], ... $maaneder[n] )
@maaneder[2,3,4]      # samme som ( $maaneder[2], $maaneder[3], $maaneder[4] )
@adresse{'Per','Ola'} # samme som ( $adresse{'Per'}, $adresse{'Ola'} )
```

«%» foran variabelnavnet gir en liste bestående av nøkler og verdier i parvis vilkårlig rekkefølge, om variabelen holder en hash:

```
%adresse              # samme som ( 'Per', $adresse{'Per'}, 'Ola', $adresse{'Ola'} ),
                      # gitt nøklene 'Per' og 'Ola', i den rekkefølgen
```

«&» foran variabelnavnet gir en subrutine. Dette brukes vanligvis ikke ved kall til subrutinen, men noe oftere for å ta en referanse til den:

```
$ref = \&bar;
```

Variabelnavnet uten noe tegn foran kaller en subrutine hvis det følger parenteser eller hvis subrutinen er deklarert; ellers gir det vanligvis en fil- eller katalogpeker, avhengig av bruk:

```
foo(1,2,3);           # kaller subrutinen &foo
close bar;            # (lukker) filpekeren bar
closedir baz;         # (lukker) katalogpekeren baz
```

Eksempler på syntaks
--------------------

### Hello, world!

```
#!/usr/bin/perl -w
print "Hello, world!\n";
```

### Løkker

```
while ( *uttrykk* ) {
    ...
}
```

```
do {
    ...
} while ( *uttrykk* );
```

```
do {
    ...
} until ( *uttrykk* );
```

```
for ( *liste* ) {
    ...
}
```

```
foreach ( *liste* ) {
    ...
}
```

```
for ( *initialisering ; termineringsbetingelse ; økningsgrad* ) {
    ...
}
```

### If-then

```
if ( *uttrykk* ) {
    ...
}
```

```
unless ( *uttrykk* ) {
    ...
}
```

```
if ( *uttrykk* ) {
    ...
}
else {
    ...
}
```

```
if ( *uttrykk* ) {
    ...
}
elsif ( *uttrykk* ) {
    ...
}
else {
    ...
}
```

### Særtrekk ved Perl sammenlignet med mange andre språk

* Konstruksjonene `for`, `while`, `if` m.fl. kan valgfritt legges bak det som utføres hvis det kun består av ett uttrykk;

```
 say "$_ er primtall" for 2, 3, 5, 7, 11, 13;
 funksjon( pop @oppgaver ) while @oppgaver;
 say "$n er oddetall" if $n % 2 == 1;
```

* Perl har støtte for regulære uttrykk i språket.

### Subrutiner

Subrutiner spesifiseres med nøkkelordet `sub`. Argumenter til subrutinen er tilgjengelige som elementer i den lokale (for subrutinen) tabellen `@_`. Kaller man en subrutine med tre argumenter, blir disse representert som `@_[0]`, `@_[1]` og `@_[2]` i subrutinen. Merk at disse elementene blir referert til som skalarene `$_[0]`, `$_[1]` og `$_[2]`. Funksjonen `shift` kan også benyttes for å få tak i hver av verdiene.

Endres noen av elementene i `@_` i subrutinene, reflekteres også denne endringen i programmet som kalte subrutinen.

Subrutiner returner vanligvis resultatet av det siste uttrykket, men en eksplisitt `return`-verdi kan angis og anbefales for å gjøre det helt klart hva programmereren faktisk ønsker å returnere.

Eksempel:

```
sub kube {
 my $x = shift;
 return $x \*\* 3;
}

$z = -4;
$y = kube($z);
print "$y\n";

```

Navngitte argumenter kan simuleres ved å gi subrutinen en hash som inn-argument:

```
sub hallo {
 my %person = @\_;
 return "Hallo, $person{fornavn} $person{etternavn}!\n";
}

print hallo (
 fornavn => 'Ola',
 etternavn => 'Nordmann',
);

```

Perl har i nyere versjoner fått støtte for parameternavngivning som ligner mer på andre språk:

```
sub pytagoras ($x, $y) {
 sqrt( $x \*\* 2 + $y \*\* 2 );
}

```

### Moduler

Man kan samle funksjoner i en biblioteksfil. I sin enkleste form kan dette gjøres slik i filen modtest.pm:

```
 # definer navn på pakke
 package modtest;
 
 # strict og warnings hjelper deg i debugging, og hindrer deg
 # å skrive slurvete kode.
 use strict;
 use warnings;
 
 # trengs for å kunne eksportere funksjoner
 use Exporter ();
 
 our @ISA = qw( Exporter );
 
 # her eksporterer vi funksjonene
 our @EXPORT = qw( hello helloname );

 sub hello {
 print "hello world\n";
 }

 sub helloname {
 my $name = shift; # henter første innverdi

 print "hello $name\n";
 }

 ## returner 1 etter initiering av modul
 1;

```

Modulen brukes så på følgende måte:

```
 #!/usr/bin/perl

 use strict;
 use warnings;
 use modtest;

 hello();
 helloname( "you" );
 #end..

```

Merk at modulen ( modtest.pm ) må ligge i en av perls systemmapper ( se hva som ligger i `@INC` ).

CPAN
----

CPAN, Comprehensive Perl Archive Network, ble opprettet på slutten av nittitallet og er der man finner utvidelser til Perl (moduler), og er ansett for å være en av Perls største styrker. Over 7 000 programmerere fra hele verden har bidratt med over 15 000 moduler.

Perl og databaser
-----------------

DBI-grensesnittet er den CPAN-modulen som oftest blir brukt for å kommunisere med de fleste ANSI SQL-databasene, som f.eks. MySQL, PostgreSQL, Oracle og SQLite.

Andre språk
-----------

Perl har inspirert flere andre språk, blant annet PHP og Ruby. Vanlige alternativer til Perl er Python, Ruby og tildels Grails. Perl er laget i C og en del av de vanligste utvidelsene (modulene) på CPAN er helt eller delvis skrevet i C. Ved hjelp av modulen Inline::C, XS eller SWIG kan C-biblioteker (objekt-filer) bli tilgjengelige som moduler og subrutiner i Perl.

Referanser
----------

1. ↑   metacpan.org, besøkt 2. september 2016[Hentet fra Wikidata]
2. ↑  «Release Release #79 ("Minsk") · rakudo/rakudo». *GitHub* **(engelsk)**. Besøkt 2. oktober 2021.
3. ↑  «Release Release #132 (2019.11) · rakudo/rakudo». *GitHub* **(engelsk)**. Besøkt 2. oktober 2021.
4. ↑  «An Unexpectedly Long-expected Party». *Perl 6 Advent Calendar*. 24. desember 2015. Besøkt 28. desember 2015.

Eksterne lenker
---------------

* (en) Offisielt nettsted Rediger på Wikidata

* (en) Perl (programming language) – kategori av bilder, video eller lyd på Commons Rediger på Wikidata
* (en) CPAN
* (en) En Windows-utgave av Perl, inkludert Komodo utviklingsmiljø, GUI-debugger og Perl-til-exe-«kompilator»
* (en) Perl's dokumentasjon

| * v
* d
* r
Programmeringsspråk |
| --- |
| Tidslinje |
| A# **·** ActionScript **·** Ada **·** Alef **·** ALGOL **·** ALGOL 58 **·** ALGOL 60 **·** ALGOL 68 **·** ALTRAN **·** APL **·** AppleScript **·** Argus **·** Assembler **·** Autokode **·** awk **·** B **·** BASIC **·** BCPL **·** BETA **·** BitC **·** BLISS **·** Bourne Shell **·** C **·** C++ **·** C-- **·** CHILL **·** C# **·** C shell **·** Caml **·** Ch **·** Cilk **·** Cilk++ **·** Cilk Plus **·** Clarion **·** Clipper **·** CLISP **·** Clojure **·** CLU **·** COBOL **·** COMAL **·** Common Lisp **·** Concurrent C **·** Concurrent Euclid **·** Concurrent Pascal **·** C shell **·** D **·** Delphi **·** Dylan **·** ECMAScript **·** Eiffel **·** Emacs Lisp **·** Erlang **·** Euclid **·** F\* **·** F# **·** Forth **·** Fortran **·** GNU Common Lisp **·** GNU Pascal **·** Go **·** Haskell **·** HyperTalk **·** Incr Tcl **·** INTERCAL **·** Interlisp **·** Java **·** JavaScript **·** JRuby **·** LaTeX **·** Legoscript **·** LilyPond **·** Limbo **·** Lisp **·** LPC **·** Lua **·** Lynx **·** Mary **·** MATLAB **·** Mesa **·** ML **·** MML **·** Modula **·** Modula-2 **·** MUMPS **·** Objective-C **·** Objective-C++ **·** OCaml **·** OpenVera **·** O'Haskell **·** Pascal **·** Perl **·** PHP **·** Pike **·** PL/I **·** Plankalkül **·** PLEX **·** Prolog **·** Protel **·** Pure Data **·** Python **·** R **·** Ratfor **·** REXX **·** RTL/2 **·** Ruby **·** Rust **·** SAS **·** Scala **·** Scheme **·** Scratch **·** Simula **·** SML **·** Smalltalk **·** SNOBOL **·** Tcsh **·** Tcl **·** TECO **·** TOM **·** Turbo Basic **·** Turbo Pascal **·** Verilog **·** Visual Prolog **·** Turing **·** TypeScript **·** Vala **·** VHDL **·** Visual Basic **·** Flere.. |
| 
* Kategori **Kategori**

 |

|  |  |
| --- | --- |
| Oppslagsverk/autoritetsdata | Store norske leksikon **·** Encyclopædia Britannica **·** Nationalencyklopedin **·** GND **·** LCCN **·** BNF **·** BNF (data) **·** NKC **·** BNE
 |