Subroutinen

(bearbeitete Darstellung aus Perl-Tutorial - Die Verweise funktionieren deshalb nicht, können aber im "Original" abgerufen werden.)

Wie jede gute Programmiersprache können in Perl eigene Funktionen programmiert werden. Man nennt sie in Perl Subroutinen (wie in Fortran!?). 

Sie können irgendwo im Programm platziert werden. Normalerweise wird man sie an den Anfang oder ans Ende des Programmes stellen. Wie in C kann eine Subroutine deklariert und später definiert werden unter Verwendung der Compilerdirektive use subs. 

sub NAME;               # Deklaration

sub NAME BLOCK          # Definition
Beispiel:  
sub mysubroutine
{
        print "Dies ist eine langweilige Subroutine.\n";
        print "Sie macht immer das gleiche!\n";
}
Alle folgenden Anweisungen rufen diese Subroutine auf. Beachte, dass der Buchstabe & am Anfang des Namens stehen muss. (V5: nicht mehr nötig, aber empfohlen.)  
&mysubroutine;          # Aufruf ohne Parameter
&mysubroutine($_);      # Aufruf mit einem Parameter
&mysubroutine(1+2, $_); # Aufruf mit zwei Parametern
Im Allgemeinen gelten folgende Regeln für den Unterprogrammaufruf:  
NAME(LIST);      # & ist fakultativ mit Klammern
NAME LIST;       # Klammern sind fakultativ falls vordefiniert oder importiert
&NAME;           # übergibt der Subroutine aktuellen @_ 

Parameter

Im obigen Fall wurden die Parameter akzeptiert aber nicht verwendet. Mit dem Aufruf einer Subroutine werden alle übergebenen Parameter im Spezialarray @_ gespeichert. Diese Variable hat nichts zu tun mit der Spezialvariablen $_.
@_ ist ein Array, $_ ist eine skalare Variable. Die folgende Subroutine gibt die Liste der Parameter aus, mit welcher sie aufgerufen wurde:  
sub printargs
{
        print "@_\n";
}

&printargs("perly", "king");    # Example prints "perly king"
&printargs("frog", "and", "toad"); # Prints "frog and toad"
Wie bei jedem anderen Array, können die einzelnen Elemente von @_ mit eckigen Klammern zugegriffen werden:  
sub printfirsttwo
{
        print "Der erste Parameter war $_[0]\n";
        print "und $_[1] war der zweite\n";
}
Wir betonen noch einmal das $_[0] und $_[1] nichts zu tun haben mit der Spezialvariablen $_ und das beides gleichzeitig benützt werden darf, ohne Namenskollisionen befürchten zu müssen. 

Rückgabewerte

Das Resultat einer Subroutine ist immer das Resultat des letzten evaluierten Ausdruckes. Diese Subroutine berechnet das Maximum von zwei gegebenen Eingabeparameter:  
sub maximum
{
        if ($_[0] > $_[1]) {
           $_[0];
        } else {
           $_[1];
        }
}
Der Aufruf sieht so aus:  
$biggest = &maximum(37, 24);    # $biggest ist 37
Die Subroutine printfirsttwo gibt ebenfalls einen Wert zurück, und zwar ist es 1. Die letzte Evaluation dieser Subroutine war die print-Anweisung. Das Resultat einer erfolgreichen print-Anweisung ist immer 1. 

Mit der Funktion 

                           return  ausdruck         oder         return

kann man eine Subroutine - auch "vorzeitig" - verlassen und gleichzeitig den Wert von ausdruck als Rückgabewert festlegen (ist ja dann auch der zuletzt ausgewertete Ausdruck). Ist ausdruck nicht angegeben, ist der Rückgabewert in skalarem Kontext (im aufrufenden Programm) ein undefinierter Wert, im Listen-Kontext eine leere Liste.

Lokale Variablen mit my

Die Variable @_ ist lokal zur aktuellen Subroutine. Um Namenskollisionen zu vermeiden, können auch andere Variablen lokal gemacht werden. Dazu verwenden wir die Funktionen my oder local.

Häufig möchte man die Elemente von @_ einer eigenen lokalen Variablen zuordnen, etwa um die Lesbarkeit zu verbessern. Die folgende Subroutine testet, ob ein String Substring eines anderen ist, ohne die Leerzeichen zu berücksichtigen:  

sub inside
{
        my ($a, $b);                    # Erzeuge lokale Var.
        ($a, $b) = ($_[0], $_[1]);      # Param. zuordnen
        $a =~ s/ //g;                   # Leerzeichen aus lok.
        $b =~ s/ //g;                   #   Var. löschen
        ($a =~ /$b/ || $b =~ /$a/);     # Ist $b in $a
                                        #   oder $a in $b?
}

&inside("lemon", "dole money");         # true
Falls mehr als eine Variable mit my deklariert werden soll, müssen sie in Klammern angegeben werden (my ist eine Funktion!). Wir können das Ganze auch noch ein wenig eleganter schreiben, indem wir die ersten beiden Zeilen zusammenfassen:  
my ($a, $b) = @_;

Lokale Variablen mit local

local war in Perl 4 die einzige Möglichkeit lokale Variabeln zu deklarieren. Aus Kompatibilitätsgründen und für Spezialfälle ist es noch verfügbar. 

my ist die neuere (abPerl 5) und effizientere Art lokale Variablen zu deklarieren. Der Unterschied zu local liegt in wichtigen Feinheiten. local erzeugt einen temporären Wert für eine globale Variable (dynamic scoping), wohingegen my eine echte lokale Variable deklariert (lexical scoping), welche nur im umgebenden Block, Subroutine (oder eval) bekannt ist. Die Syntax ist bei beiden gleich. 
Eine Einschränkung gibt es bei den Variablennamen: Mit my sind nur alphanumerische Zeichen erlaubt! Um Spezialvariablen, wie zB. $\ zu lokalisieren, muss local verwendet werden.