Marke Eigenbau

Gerade in grösseren Programmen kommt es häufig vor, daß Ihr denselben Codeschnippsel mehrfach braucht. Als Beispiel nehmen wir einen Code, der ab einer bestimmten Bildnummer die nächsten fünf Bilder als Thumbnails zeigt

// Die Start-Bildnummer sei in der Variablen 'start'
var thumbs = new Array[5]; // Array zum Speichern der Thumbnails
var zaehler = 0; // Initialisierung
while (zahler < 5)
  {
  // erzeugt Thumbnail zu Bildnummer
  thumbs[zaehler] = createThumbnail(start+zaehler);
  // zeige Thumbnail an Position Nr. 'zaehler'
  showAt(thumbs[zaehler], zaehler);
  }

Diesen Code könnt Ihr mehrfach in Eurer Webseite benutzen, z. B. um die fünf neuesten Fanarts, die Cover der fünf zuletzt erschienen Comics und so weiter anzuzeigen. Dazu muß der Code entsprechend oft in Eurer Webseite stehen - oder Ihr schreibt ihn als eigene Funktion. Diese eigene Funktion könnt Ihr genauso wie die Funktionen, die die Programmiersprache bereits mitbringt, an beliebiger Stelle aufrufen.

Funktionen werden als eigenständiger Block definiert. Zunächst, als einfacheres Beispiel, eine Funktion, die zwei Zahlen addiert

function int add(int x, int y)
  {
  var ergebnis = x + y; // addiere die beiden Parameter
  return ergebnis; // und liefere das Ergebnis zurück
  }

Diese Funktion könnt Ihr dann wie gewohnt verwenden

var number = add(3, 5); // 'number' enthält jetzt den Wert 8

An diesem Beispiel könnt Ihr die Prinzipien einer Funktion gut sehen: Der Funktionskopf ist die Signatur, in unserem Fall 'int add(int x, int y)'. Die Funktion nimmt also zwei Parameter vom Typ int und liefert ein int zurück. Der Funktionsrumpf ist ein Block, der den Code der Funktion enthält. Dort ist der Befehl 'return' für die Rückgabe des Rückgabewertes zuständig. 'return' beendet die Ausführung des Funktionscodes; sein Parameter wird der Rückgabewert der Funktion. In unserem Fall ist das der Wert der Variablen 'ergebnis'. Das 'return' muß nicht immer am Schluß des Funktionscodes stehen. Das könnt Ihr dazu benutzen, um die Ausführung einer Funktion vorzeitig abzubrechen

function boolean showPic(int number)
  {
  // konstruiere den Dateinamen
  var filename = "bild"+number;

  // wenn keine Datei mit diesem Namen existiert
  if (!exists(filename))
    // beende Funktion mit Rückgabewert 'false' als Fehlermeldung
    return false;

  ... // ab hier wird jetzt das Bild geladen und angezeigt

  return true; // beende Funktion mit Rückgabewert 'true'
  }

Ein boolean als Rückgabewert wird wie in diesem Beispiel oft benutzt, um durch die Rückgabe von 'false' einen Fehler zu signalisieren.

Im Zusammenhang mit Funktionen stoßen wir zum ersten Mal auf eine bisher noch unbekannte Eigenschaften von Variablen: Den Gültigkeitsbereich. Wenn Ihr wie gewohnt in Eurem Programm eine Variable deklariert, könnt Ihr sie auch (ab der Deklaration) überall in Eurem Programm benutzen. Solche Variablen nennt man auch global. Eine Variable, die Ihr innerhalb einer Funktion definiert, existiert auch nur dort und nicht im restlichen Programm. Es ist also eine lokale Variable. Generell kann man sagen: Eine Variable existiert nur innerhalb des nächsten umschließenden Containers. Oberhalb einer globalen Variablen ist direkt das Programm, also ist sie auch im gesamten Programm bekannt. Oberhalb einer Variablen in einer Funktion ist zunächst mal die Funktion, also ist sie auch nur dort bekannt. In einigen Sprachen könnt Ihr auch lokale Variablen in einem Block, der zu einem if oder einer Schleife gehört, definieren. Auch die sind dann nur jeweils dort bekannt.

Wie Ihr gesehen habt, könnt Ihr die übergebenen Parameter in Eurer Funktion weiterverarbeiten. Jetzt stellt sich natürlich die Frage, sind die geänderten Werte nach dem Aufruf der Funktion auch im Programm bekannt? Nehmen wir ein einfaches Beispiel

function int testfunktion(int x)
  {
  x += 3; // erhöhe den Parameter um 3
  return x; // und liefere ihn zurück
  }
...
var zahl = 3;
print testfunktion(zahl); // gibt '6' aus
print zahl; // was wird hier ausgegeben?

Jetzt gibt es zwei Möglichkeiten: Die Variable 'zahl' hat nach der Funktion den Wert 6, weil sie ja in der Funktion um 3 erhöht wurde. Oder: Die Variable 'zahl' hat nach der Funktion noch immer den Wert 3, weil Änderungen in der Funktion ja immer lokal sind, also außerhalb nicht auftauchen.

Interessanterweise gibt es beides. Den ersten Ansatz nennt man call by reference. Das bedeutet, als Parameter werden die übergebenen Variablen selbst benutzt. Änderungen am Parameter sind Änderungen an der «richtigen» Variable. Die andere Variante ist call by value. Dabei wird eine Kopie der Variablen als Parameter benutzt. Diese Kopie kann jetzt beliebig geändert werden, das juckt die «richtige» Variable nicht weiter. In den meisten Programmiersprachen wird call by value verwendet. Um call by reference zu erreichen (was machmal die Arbeit sehr erleichtert), gibt es eine Reihe von «Tricks».

In vielen Sprachen könnt Ihr selbstgeschriebene Funktionen überladen. Das bedeutet, Ihr definiert mehrere Funktionen mit gleichem Funktionnamen, aber unterschiedlicher Signatur (z. B. unterschiedlichen Parametern). Damit könnt Ihr beispielsweise optionale Parameter realisieren

function int indexOf(String text, String such)
  {
  // Liefert die erste Position des Teilstrings
  // 'such' innerhalb von 'text'.
  // Wenn 'such' nicht gefunden wird,
  // wird -1 zurückgeliefert.
  ...
  }
function int indexOf(String text, String such, int start)
  {
  // tut dasselbe wie die obere Funktion,
  // beginnt mit der Suche aber erst
  // bei Zeichen Nr. 'start' in 'text'
  ...
  }

Die Funktion indexOf() existiert also in zwei Versionen, einmal mit und einmal ohne den dritten Parameter.