Kontakt aufnehmen
Wir stellen ein: PHP-Entwickler (m/w/d) Key Account Manager (m/w/d)

CGI: Subroutinen

Eine Subroutine in Perl ist ein Unterprogramm, welches selbst Scriptteile enthält und von einer beliebigen Stelle im Script aufgerufen werden kann. Dadurch kann eine mehrfache Notation derselben oder im Wesentlichen identischen Scriptpassage vermieden werden, was das Script um ein Vielfaches übersichtlicher erscheinen lässt.

Subroutinen definieren

Eine Subroutine wird in Perl stets mit dem Schlüsselwort sub eingeleitet. Dem folgt ein im Prinzip frei wählbarer Name für die Subroutine, welcher allerdings die Regeln für Namensvergaben in Perl (siehe Besondere Hinweise zur Syntax) einhalten muss. Der Anweisungsblock innerhalb einer Subroutine, dessen Anweisungen nur nach Aufruf der entsprechenden Subroutine ausgeführt werden, wird durch geschweifte Klammern eingegrenzt:

sub Subroutine1
{
 print "Hier meldet sich die Subroutine Subroutine1";
 #weitere Anweisungen...
}

Subroutinen können in Perl an einer beliebigen Stelle des Codes (außerhalb von anderen Subroutinen) definiert werden. So kann der Aufruf einer Subroutine auch erfolgen, wenn sie im Scriptverlauf bis zur Aufrufanweisung noch nicht definiert wurde.

Subroutinen aufrufen

Der Aufruf einer Subroutine kann im Prinzip an jeder beliebigen Stelle im Script erfolgen. Der Subroutine können dabei wahlweise Daten (Parameter) übergeben werden, welche die Subroutine dann auf eine bestimmte Art und Weise auslesen kann.

Ohne Parameter

Der parameterlose Aufruf einer Subroutine kann im Wesentlichen in drei Varianten erfolgen, wobei die erste die unproblematischste ist und zugleich auch am ehesten an die Syntax anderer Programmiersprachen erinnert:

print "Hier erfolgt gleich der Aufruf von Subroutine1!<br>n";

my $i = 1;

Subroutine1(); #beste Variante
$i++;                
&Subroutine1();
$i++;
&Subroutine1;


sub Subroutine1
{
 print "Hier meldet sich Subroutine1 zum $i. Mal!<br>n";
 #weitere Anweisungen...
}

Mit Parameter

Der Aufruf einer Subroutine mit Übergabe von Parametern kann auf zwei unterschiedliche Art und Weisen realisiert werden. Innerhalb der runden Klammern wird dabei die Parameterliste notiert. Die Anzahl der zu übergebenden Parameter ist seitens der Programmiersprache unbegrenzt:

my $Parameter = "Parameter2";

Subroutine1("Parameter1",$Parameter,"Parameter3");                        
#oder:                
&Subroutine1("Parameter1",$Parameter);

sub Subroutine1
{
 my $Parameter1 = $_[0];
 #1. Parameter in Skalar $Parameter1 schreiben

 my $Parameter2 = $_[1];
 #2. Parameter in Skalar $Parameter2 schreiben

 my $i = 1;

 print "Die ersten beiden Parameter lauten: ";
 print "$Parameter1 und $Parameter2!";

 foreach (@_)
 {
  print "$i. Parameter: $_ <br>n";
  #Gibt akt. Element der Parameterliste @_ aus
  $i++;
 }
}

Das Beispiel zeigt zunächst, dass es keine Rolle spielt, wie viele Parameter an dieselbe Subroutine übergeben werden, da diese nicht vorschreibt, wie viele sie erwartet.
Die Parameter, welche an die Subroutine übergeben werden, sind nach Aufruf in dem vordefinierten Array @_ gespeichert. Über die array-typische Syntax (allg. $_[index]) kann der Wert der einzelnen Parameter, d.h. Arrayelemente, gelesen und ggf. in andere Skalare geschrieben werden. In diesem Beispiel wird zusätzlich der Gültigkeitsbereich der Parameter $Parameter1 und $Parameter2 durch die Funktion my lokal (innerhalb der Prozedur) begrenzt.
Alternativ kann das Ermitteln der übergebenen Parameter auch mittels der vordefinierten shift erfolgen, welche selbstständig das erste Element des Array @_ abschneidet und zurückgibt. Die entsprechende Subroutine könnte dann so aussehen:

sub Subroutine1
{
 my $Parameter1 = shift;
 #1. Parameter in Skalar $Parameter1 schreiben

 my $Parameter2 = shift;
 #2. Parameter in Skalar $Parameter2 schreiben

 my $i = 1;

 print "Die ersten beiden Parameter lauten: ";
 print "$Parameter1 und $Parameter2!";
}

Rückgabewerte von Subroutinen

Die oberen Beispiele zeigen eine Subroutine eher als eine Art Prozedur, da diese augenscheinlich keine Werte zurückgeben, was eine Funktion auszeichnet. In der Realität liefern aber auch diese einen Rückgabewert, nämlich das Ergebnis der zuletzt in der Subroutine ausgeführte Operation.
Perl Subroutinen können aber auch mithilfe der Funktion return() beliebige Werte an das aufrufende "Hauptprogramm" zurückliefern:

my $Parameter = "Parameter2";

$ParamLength = Subroutine2("Parameter1",$Parameter,"Parameter3");
print $ParamLength," Parameter wurden der Subroutine übergeben!";


sub Subroutine2 {
 my $ParamLength = @_;
 return ($ParamLength);
}

Subroutine2 gibt mittels der Funktion return() die Anzahl der übergebenen Parameter zurück, welche sie ermittelt, indem sie das Array @_ im skalaren Kontext auswertet. Dieser Wert wird in der ersten Zeile des Scripts im Skalar $ParamLength gespeichert und anschließend ausgegeben. Der Aufruf der Subroutine Subroutine2 erfolgt dabei bereits während der Wertzuweisung für $ParamLength. Die Klammern bei der Anweisung return(Argument); sind optional.
Der Rückgabewert einer Subroutine muss jedoch nicht der eines Skalars sein. Alle Variablentypen und sogar Referenzen auf diese sind möglich. Der Typ der Variable, welche den Rückgabewert erhalten soll, bestimmt beim Aufruf der Funktion seinen Typ. Das Ganze sei im folgenden Beispiel einmal für ein Hash demonstriert:

my $Parameter = "Parameter2";

%Params = Subroutine3(Param1 => "Parameter1", 
                      Param2 => $Parameter);

print "Die Parameter: <br>n";

while (($ParamName, $ParamValue) = each(%Params))
{ print "<b>$ParamName:</b> $ParamValue<br>n"; }

sub Subroutine3 { return (@_); }

In diesem Beispiel wird Subroutine3 ein Hash mit den Parameternamen und -werten übergeben, welche sie wiederum zurückgibt. Der Rückgabewert ist zwar vom Typ Array, aber bei der Wertzuweisung von %Params zeigt sich die bereits erläuterte Stärke von Perl. Das Array wird automatisch in das Hash %Params überführt, d.h. im Hash-Kontext bewertet. In einer Schleife typisch für Hashes werden schließlich seine Wertpaare formatiert ausgegeben.

Referenzen auf Subroutinen erzeugen

Eine Referenz auf eine Subroutine erzeugt man unter Verwendung der allgemeinen Form: $Referenz = &Subroutine. Den Zugriff auf den Rückgabewert der Subroutine erhält man am übersichtlichsten über folgende allgemeine Anweisung: $RueckgabeWert = $Referenz ->(). Ein Beispiel:

$ref_subroutine = &subroutine;
#Erzeugt Referenz auf Subroutine subroutine

print $ref_subroutine;
#Gibt Speicherort von subroutine (z.B. CODE(0x1682794)) aus


#Zugriff auf Rückgabewert von subroutine

$ref_rueckgabe = $ref_subroutine->(); #übersichtlichste Variante
#oder:
$ref_rueckgabe = &{$ref_subroutine}();
#oder:
$ref_rueckgabe = &$ref_subroutine();

print $ref_rueckgabe; #Gibt Rückgabewert von subroutine aus


sub subroutine
{
 my $string = "Rueckgabe der Subroutine";
 return $string;
}

Weiterlesen: ⯈ Wichtige Funktionen für Variablentypen

Über uns

Stefan Wienströer

Wir entwickeln Webanwendungen mit viel Leidenschaft. Unser Wissen geben wir dabei gerne weiter. Mehr über a coding project

Karriere bei a coding project - Wir freuen uns auf dich!

Alle unsere Stellen sind Remote oder an unseren Standorten in Münster und Wuppertal verfügbar:

// Warum Du Dich für uns entscheiden solltest

  • Regelmäßig neue Projekte, die Du von Grund an mit planen und aufbauen kannst
  • Arbeit in einem wachsenden IT-Unternehmen
  • So viel Home-Office wie Du möchtest - Und einen Arbeitsplatz in unserem Büro in Münster
  • Wöchentliche Vorträge: Jeden Freitag hält ein Mitarbeiter einen Vortrag über ein Fachthema seiner Wahl
Karriere

Cookie-Einstellungen

Helfen Sie dabei, uns noch besser zu machen. Wir nutzen Cookies und ähnliche Technologien, um die Website auf Ihre Bedürfnisse anzupassen. Zur Datenschutzerklärung

Auswahl speichern