Funktionen und Gültigkeitsbereiche

Mit Hilfe von Bedingunen, Schleifen und Kommentare können wir nun schon allerhand Dinge anstellen. Doch nach einer gewissen Zeit wird einem auffallen, dass so ein Code ziemlich schnell lang und unübersichtlich wird und dass man gewissen Code auch doppelt schreiben muss. Gerade Letzteres sollte man tunlichst vermeiden, da doppelter Code auch doppelte Arbeit bedeutet, sobald man einen Fehler finden und ausmerzen muss. Aber keine Sorge, dafür sind Funktionen da.

Funktionen sind eine sehr nützliche Sache. Mit Funktionen können wir einen bestimmten, Code an beliebiger Stelle einsetzen ohne ihn jedes Mal neu schreiben zu müssen. Man kann sich das so vorstellen, als würde man einen bestimmten Code in ein Päckchen packen und mit einen Namen versehen. Dieses Code-Päckchen kann man nun jederzeit, überall und beliebig oft anhand seines Namens aufrufen.

function erzeugeGegner()
{
      print(" Gegner wurde erzeugt!");  
}

Um eine eigene Funktion zu erzeugen, muss man als erstes das Schlüsselwort function angeben, gefolgt von dem Funktionsnamen. Der Funktionsname muss immer mit einer runden Klammer enden. Im nächsten Abschnitt werden wir die Klammer noch etwas genauer kennenlernen.

Um diese Funktion aufzurufen, brauchen wir dann einfach nur noch den Funktionsnamen in den Code schreiben und der Code wird an dieser Stelle ausgeführt.

var Gegner = 1;    
 
while (Gegner != 11)  
{
     erzeugeGegner();  
}   
 
function erzeugeGegner()  
{
      print(Gegner + " Gegner wurden erzeugt");
      Gegner++;	   
}

Wie wir sehen können, wird in der while-Schleife lediglich der Funktionsname verwendet und dennoch werden fleißig unsere Gegner erzeugt. Die Funktion selbst wird erst dann ausgeführt, wenn die Funktion aufgerufen wird, nicht aber wenn sie erzeugt wird. Deshalb wird die Funktion unten nicht ausgeführt.

Wie versprochen gehen wir nun auf die Klammer am Ende des Funktionsnamens ein. An sich ist eine solche Funktion wirklich sehr hilfreich doch sie ist noch viel komfortabler als wir bisher wissen. Angenommen, wir möchten nicht immer 10 Gegner erzeugen, sondern an der einen oder anderen Stelle auch mal nur 5 oder 2 Gegner erzeugen. Damit wir nicht für jede erdenkliche Anzahl von Gegnern eine neue Funktion schreiben müssen, können wir der Funktion auch Werte übergeben. Dies geschieht über die Parameterliste in der Klammer der Funktion. Hier ein kleines Beispiel:

erzeugeGegner(5);  
 
function erzeugeGegner(anzahl)  
{
    for (var i=0; i<anzahl; i++)
    {
	print(i + " Gegner wurden erzeugt");
    }
}

Als erstes erstellen wir uns wieder die Funktion erzeugeGegner(anzahl), doch diesmal geben wir der Funktion die Möglichkeit, Werte zu empfangen. Im Codeblock verwenden wir eine for-Schleife, die den übergebenen Wert als Bedingung erhält. Dann rufen wir die Funktion auf und übergeben ihr eine 5. Da wir nun eine for-Schleife in der Funktion haben, musste die while-Schleife weichen.

Wenn wir bei dem Funktionsaufruf keinen Wert übergeben, dann wird uns die Konsole auch nichts ausgeben. Für diesen Fall können wir unserer Funktion noch eine if-Bedingung hinzufügen, die anzahl einen Wert gibt, falls der Funktion kein Wert übergeben wurde.

function erzeugeGegner(anzahl)  
{
     if(!anzahl)
     {
         anzahl = 10;
     }
 
     for (var i=0; i<anzahl; i++)
     {
          print(i + " Gegner wurden erzeugt");
     }
}

Sollte anzahl nun nicht existieren, weil man beim Funktionsaufruf auf die Übergabe eines Wertes verzichtet, so wird anzahl mit 10 definiert.

Wenn wir mit Funktionen arbeiten (was bei DX Studio unabdingbar ist, siehe Eventhandler) sollten wir uns die Begriffe global und lokal näher anschauen.

In den vorherigen Kapiteln haben wir –ohne es zu wissen- immer globale Variablen erzeugt. Globale Variablen sind im gesamten Code verfügbar.

• Sobald eine Variable außerhalb einer Funktion deklariert und definiert wird, ist sie überall im Code und in jeder Funktion verfügbar.
• Sobald wir aber eine Variable innerhalb einer Funktion erzeugen, spricht man von einer lokalen Variable. Eine lokale Variable ist nur innerhalb der Funktion verfügbar und existiert nicht außerhalb dieser Funktion.

Wahrscheinlich kann man sich jetzt fragen, warum man überhaupt Variablen lokal erzeugen sollte wenn es doch viel einfacher ist, wenn man alle Variablen global erzeugt. Im Prinzip spricht nichts dagegen, sämtliche Variablen global zu halten. Aber stellen wir uns doch einfach mal vor, dass wir mittlerweile einen sehr umfangreichen Code haben und überall im Code können die globalen Variablen manipuliert werden. Jetzt taucht aber plötzlich ein Fehler auf, der mit einer der globalen Variablen zu tun hat. Hier wird schnell klar, dass die Fehlersuche hier eine Menge Arbeit bedeutet, da jede Funktion dafür verantwortlich sein könnte.

Soweit so gut. Um die ganze Angelegenheit etwas zu verdeutlichen ist ein neues Beispiel notwendig. Für dieses Beispiel ist diesmal ein Event-Handler nötig. Im Prinzip ist ein Event-Handler ja auch eine Funktion, aber dazu mehr im Event-Handler Tutorial.

function onInit()  
{ 
    var punkte = 12345; 
    punktestand();  
}   
 
function punktestand()  
{ 
    punkte = punkte * 10; 
    print(punkte);  
}

Hier rufen wir die Funktion punktestand() bei der Initialisierung des Programms auf. Man könnte annehmen, dass nun die Variable punkte manipuliert wird und anschließend ausgegeben wird. Wenn wir das Beispiel ausführen, wird uns aber eine Fehlermeldung ausgegeben. Das liegt daran, dass die Variable in der Funktion onInit() definiert und deklariert wurde, demzufolge ist sie also lokal. Würde man nun die Punkte global erzeugen, so würde das Beispiel einwandfrei funktionieren.

Das wollen wir aber an dieser Stelle einfach mal vermeiden, also muss eine andere Lösung her. Wir können der Funktion einfach die Variable übergeben. Dafür nehmen wir uns wieder die Parameterliste zur Hilfe.

function onInit()  
{ 
     var punkte = 12345; 
     punktestand(punkte); 
     print(punkte);  
}
 
function punktestand(punkte)  
{ 
     punkte = punkte * 10; 
     print(punkte);  
}

Wir übergeben der Funktion die Variable und lassen uns daraufhin noch einmal die Variable punkte ausgeben. Nun wirst Du feststellen, dass sich die eigentliche Variable gar nicht verändert. Und hier kommt nun der Vorteil von lokalen Variablen zum Vorschein. Es wird lediglich der Wert der Variable übergeben. Die Funktion erstellt sich dann eine eigene Kopie dieser Variable(die nach außen hin nicht existiert) , manipuliert diese Kopie und gibt sie aus. Das Original bleibt unangetastet.