cgicorner.ch

Informationen rund um Perl/CGI

Sie sind hier: Home > CGI Hilfe > Tutorial > Kapitel 7 - Subroutinen

Tutorial - Kapitel 7: Subroutinen

Voraussetzungen für dieses Kapitel

  • Webserver mit Perl/CGI-Unterstützung

Einleitung

Bis jetzt haben wir Programme einfach in "einem Rutsch" programmiert. Das Programm wird von der ersten bis zur letzten Zeilen durchlaufen. Dies ist keine realitätsnahe Programmierung. Für Programmschritte, welche immer wieder benutzt werden, empfiehlt es sich, Subroutinen, auch Funktionen genannt, zu schreiben, welche dann in einem Programm mehrmals verwendet werden

Bis jetzt haben wir Programme einfach in "einem Rutsch" programmiert. Das Programm wird von der ersten bis zur letzten Zeilen durchlaufen. Dies ist keine realitätsnahe Programmierung. Für Programmschritte, welche immer wieder benutzt werden, empfiehlt es sich, Subroutinen, auch Funktionen genannt, zu schreiben, welche dann in einem Programm mehrmals verwendet werden können, oder auch anderen Programmen zur Verfügung gestellt werden können.

Argumente und Rückgabewerte

Im Zusammenhang mit Subroutinen spricht man immer wieder von zwei Begriffen: Argumente und Rückgabewerte. Eine Subroutine muss man sich als Black-Box vorstellen: man füttert die Funktion mit irgendwelchen Werten (Argumente). Die Funktion führt dann im Hintergrund irgendwelche Berechnungen aus und gibt dann wieder beliebige Werte (Rückgabewerte) zurück. Weder Argumente als auch Rückgabewerte sind aber zwingend erforderlich.

Beispiel 1: Hello World

Als erstes einmal eine ganz einfache Subroutine, um einmal den Syntax genauer anzusehen:

#!/usr/bin/perl
print "Content-type: text/html\n\n";
print "<html><body>";
&test;
print "</body></html>";

sub test {
  print "Hello World!";
}

Dieses Beispiel macht natürlich noch nicht sonderlich viel Sinn, da die Funktion nur einmal benötigt ist. Der Syntax sollte aber aus diesem Beispiel hervorgehen: eine Subroutine wird durch den Text sub [Name] eingeleitet, wobei [Name] der Name der Funktion ist. Danach folgen, innerhalb geschweifter Klammern, die Anweisungen der Funktion.

Aufgerufen wird die Funktion dann mit &[Name];, wobei [Name] wiederum der Name der Funktion ist. Bei der Namensgebung von Funktionen gelten die gleichen Regeln wie bei Variablen.

Beispiel 2: Subroutine mit Argumente

#!/usr/bin/perl
print "Content-type: text/html\n\n";
print "<html><body><table border="0">";
&tableRow("Zeile 1","Kommentar zur Zeile 1");
&tableRow("Zeile 2","Kommentar zur Zeile 2");
&tableRow("Zeile 3","Kommentar zur Zeile 3");
&tableRow("Zeile 4","Kommentar zur Zeile 4");
&tableRow("Zeile 5","Kommentar zur Zeile 5");
print "</table></body></html>";

sub tableRow {
  print "<tr valign=\"top\"><td width=\"200\">$_[0]</td><td>$_[1]</td></tr>\n";
}

Hier macht sich der Vorteil von Funktionen schon bemerkbar. Eine Funktion tableRow erstellt eine komplette Tabellenzeile in HTML. Der Funktion werden zwei Argumente für die zwei Spalten pro Zeile übergeben. Dies erhöht einerseits die Übersichtlichkeit, andererseits müssen Änderungen an der Tabelle (z.B. andere Spaltenbreite, andere Zellen-Hintergrundfarbe etc.) auch nur noch an einer zentralen Stelle vorgenommen werden.

Zum Syntax noch folgendes: Argumente werden beim Aufruf der Funktion in Klammern übergeben

&[Name]("[Argument1]","[Argument2]","[Argument3]");

und sind dann innerhalb der Funktion im Array @_ abrufbar, also $_[0], $_[1], $_[2].

 

Beispiel 3: Subroutine mit Argumenten und Rückgabenwerte

#!/usr/bin/perl
print "Content-type: text/html\n\n";
print "<html><body>";
$a=10;
$b=15;
$c=&pythagoras($a,$b);
print "Nach Pythagoras ist c=$c, wenn a=$a und b=$b\n";
print "</body></html>";

sub pythagoras {
  return sqrt(($_[0]*$_[0])+($_[1]*$_[1]));
}

In diesem Beispiel wenden wir etwas Mathematik an und schreiben ein Programm, welches uns nach der Formal Pythagoras (c2 = a2 + b2) "c" aus den Werten "a" und "b" errechnet.

Den Aufruf der Funktion inkl. Argumente kennen wir ja bereits. Neu ist nur der Rückgabewert. Der Syntax ist einfach: vor dem Aufruf der Funktion wird der Name der Variable, gefolgt von einem Gleichheitszeichen geschrieben. Innerhalb der Funktion wird der Rückgabewert mittels return zurückgegeben (sqrt steht übrigens für Quadratwurzel und hat nichts mit dem Rückgabewert zu tun).

Weitere Informationen

Sowohl Argumente als auch Rückgabewerte können nebst Variablen auch noch Arrays sein. Ebenfalls sind mehrere Rückgabewerte möglich. Hier noch eine Auflistung einiger erlaubten Beispiele:

($a,$b)=&testA("1","2");
@myArray=&testA("1","2");

@myArray=&testB;
($a,$b,$c)=&testB;

@myArray2=("abc","def","ghi");
&testC(@myArray2);

sub testA {
  return $_[0], $_[1];
}

sub testB {
  @mySubArray=("abc","def","ghi");
  return @mySubArray;
}

sub testC {
  print "$_[0] / $_[1] / $_[2]";
}

Zusammenfassung

In diesem Kapitel haben wir Subroutinen, auch Funktionen genannt, kennen gelernt. Wir wissen ebenfalls, dass sich Subroutinen sehr gut dazu eignen, wiederkehrende Schritte auszuführen. Definiert werden Sie mit sub, aufgerufen mit einem führenden &. Im Zusammenhang mit Subroutinen haben wir Argumente und Rückgabewerte kennen gelernt. Argumente übergeben wir der Funktion in Klammern beim Aufruf und stehen dann innerhalb der Funktion im Array @_ zur Verfügung. Rückgabewerte werden innerhalb der Funktion mit return eingeleitet und stehen in der beim Aufruf vorangestellten Variable zur Verfügung.

Wie geht's weiter?

Im Kapitel 8 befassen wir uns mit HTML-Formularen, welche Daten an CGI-Scripts übermitteln.

Im vorherigen Kapitel (6) beschäftigten wir uns Schleifen.

Sie können aber auch zurück zum Inhaltsverzeichnis und dort ein beliebiges anderes Kapitel auswählen.