0251 / 590 644 - 0
info@a-coding-project.de

Funktionen in JavaScript

Funktionen sind bestimmte Abläufe. Sie haben mehrere Rollen, wie zum Beispiel das Reagieren auf Ereignisse oder das Prüfen und Errechnen eines oder mehrerer Werte. Sie dienen dazu, oft verwendete Abläufe dadurch zu vereinfachen, dass diese nur einmal aufgeschrieben werden müssen.

JavaScript 1.1 JScript 2.0 function - Funktionsdeklarartion

Eine Funktion besteht dabei immer aus einer Funktions-Deklaration (auch Funktions-Kopf oder Funktions-Ausschreibung genannt) und dem eigentlichen Hauptteil der Funktion, der Ablaufteil (auch Funktions-Körper genannt). Die Deklaration einer Funktion beginnt mit dem Wort function, dem folgt der Name der Funktion sowie unmittelbar dahinter eine öffnende und eine schließende runde Klammer (( und )).
In den Funktions-Körper werden dann sämtliche Anweisungen notiert, die erledigt werden sollen, wenn die Funktion ausgeführt wird. Diese Anweisungen müssen dazu innerhalb eines Anweisungsblockes stehen, d.h. sie müssen durch eine öffnende und eine schließende geschwungene Klammer begrenzt sein ({ und }). Beispiel:

function MeineFunktion()
{
 ... Anweisungen ...

Der Aufruf einer selbstdefinierten Funktion geschieht dann, indem der Name der Funktion sowie die Klammern (und eventuelle Parameter) notiert werden. Wird eine Funktion innerhalb einer Funktion aufgerufen, so wird erst der Inhalt der aufgerufenen (zweiten) Funktion ausgeführt und dann erst mit der ersten weiter verfahren. Beispiel:

a = 1;
function FunktionA()
{ a=a+1; }

function FunktionB()
{
 FunktionA();
 a=a+1;
 alert(a);

Erklärung: Es wird angenommen, dass die Funktion FunktionB() ausgeführt wird. Diese ruft nun die Funktion FunktionA() auf, welche die Variable a um 1 erhöht. Ist der Aufruf der Funktion FunktionA() beendet, wird wieder innerhalb von FunktionB() weiter gemacht und die Variable a nochmals erhöht und ausgegeben. Die Funktion ist erst dann beendet, wenn der letzte Aufruf vollständig ausgeführt wurde.

JavaScript 1.1 JScript 2.0 Parameter

Parameter sind bestimmte (Zusatz-)Informationen, die einer Funktion übergeben werde, damit sie mit diesen arbeiten kann. Soll eine Funktion Parameter übergeben bekommen, so muss dies in der Funktions-Deklaration mit vermerkt werden. Dazu wird innerhalb der Klammern nach dem Funktionsnamen eine, durch Kommas getrennte, Liste von Variablennamen notiert.
Die Übergabe von Werten an eine Funktion geschieht dann mit dem Aufruf der Funktion, wobei dann auch innerhalb der Klammern Werte oder Variablen notiert werden müssen, die der Funktion übergeben werden sollen. Wichtig dabei ist, dass immer die gleiche Anzahl an zu Übergebenden Werten existiert. Das heißt, wenn einer Funktion beispielsweise 3 Werte übergeben werden sollen, müssen auch 3 Werte/Variablen beim Funktionsaufruf notiert werden.
Innerhalb der Funktion kann dann mit den Deklarierten Variablen gearbeitet werden. Beispiel:

function BekommtWerte(a,b,c)
{
 x = a+b+c;
 alert(x);
}

function GibtWerte()
{
 m = 1;
 n = 1+1;
 BekommtWerte(m,n,3);

Erklärung: Es wird angenommen, dass die Funktion GibtWerte() ausgeführt wird. Sie definiert 2 Variablen (m und n) und ruft anschließend die Funktion BekommtWerte() auf. Dieser Funktion werden als Parameter der Wert von m als Variable a, der Wert von n als Variable b und der Wert 3 als Variable c übergeben. Innerhalb dieser Funktion kann nun mit den übergebenen Werten gearbeitet werden.

Wird eine Funktion mit einer Variablen als Übergabewert aufgerufen und dieser innerhalb der Funktion verändert, so bleibt die ursprüngliche Variable erhalten. Bei Variablen werden nur die Werte übergeben. Wird stattdessen einer Funktion ein Objekt übergeben, und eine Eigenschaft dieses Objekts innerhalb der Funktion verändert, so ist auch das ursprüngliche Objekt verändert. Beispiel:

function DoIt1(val)
{
 val = val + ' neuer Text ';
}
a = ' alter Text ';
DoIt1(a); // a == ' alter Text '

function DoIt2(val)
{
 val.color = ' neue Farbe ';
}
Auto = { mark:'BMW', color: ' alte Farbe '};
DoIt2(Auto); // Auto.color == ' neue Farbe '

Erklärung: Beim ersten Beispiel wird an die Funktion eine Variable übergeben. Innerhalb der Funktion wird dieser verändert, wobei die eigentliche Variable a nicht verändert wird.
Beim zweiten Beispiel wird der Funktion ein ganzes Objekt übergeben. Innerhalb der Funktion wird eine Eigenschaft des Objektes verändert. Danach hat auch das eigentliche Objekt einen anderen Wert dieser Eigenschaft.

Da Funktionen auch Objekte darstellen können, ist es auch möglich Funktionen einer Variablen zuzuweisen oder innerhalb von Arrays zu definieren. Das folgende Beispiel zeigt diese Verwendung:

var meinefunction = function(a,b){return(a+b);}
//der aufruf erfolgt dann mit:
meinefunction(1,2);

var meinArray = [
                 function(a,b){return(a+b);},
                 function(a,b){return(a-b);},
                 function(a,b){return(a*b);}
                ];
//der aufruf erfolgt dann mit:
meinArray[0](1,2); // = 3
meinArray[1](1,2); // = -1
meinArray[2](1,2); // = 2 

JavaScript 1.1 JScript 2.0 return - Rückgabe

Um eine Funktion frühzeitig zu beenden oder ein Resultat zurück zu geben wird der return-Aufruf verwendet. Taucht er auf, so wird die Funktion an dieser Stelle beendet. Zusätzlich kann ihm, in runden Klammern dahinter, gesagt werden, welchen Wert er an die Elternfunktion (also die Funktion die die Funktion aufgerufen hat) zurück geben soll. Dieser Wert kann eine Variable, eine Zahl oder ein beliebiges Objekt sein; wichtig dabei ist nur, dass es nicht mehrere sondern immer nur einer ist. Beispiel:

function Berechne(a,b)
{
 x = a+b*100;
 return(x);
}

function MachWas()
{
 m = 1;
 n = 2;
 o = Berechne(m,n);
 alert(o);

Erklärung: Es wird angenommen, die Funktion MachWas() wird ausgeführt. Sie erstellt zwei Variablen (m und n) und weißt einer dritten Variablen (o) die Funktion Berechne() zu. Dies würde bedeuten, dass an dieser Stelle die Funktion Berechne() ausgeführt wird und der Rückgabewert der Funktion (also die neu berechnete Variable x) der Variablen o zugewiesen wird.

JavaScript 1.3 JScript 3.0 Verschachtelung

Neben der normalen Notation von Funktionen können Funktionen auch verschachtelt werden. Das heißt, eine Funktion wird direkt in eine andere hinen notiert. Dies hat folgene Vor- bzw. Nachteile:

  • die innere (verschachtelte) Funktion kann nur über die äußere aufgerufen werden und ist für alle anderen Zugriffe unzugänglich
  • die innere Funktion kann die Variablen und Parameter der äußeren nutzen
  • die äußere Funktion kann die Variablen und Parameter der inneren Funktion nicht nutzen
  • die innere Funktion wird als (lokale) quasi-Variable angesehen
Beim Aufruf von verschachtelten Funktionen können die Parameter spezifisch zugeordent werden. Dazu wird die äußere Funktion normal aufgerufen. An dem Aufruf wird zusätzlich eine weitere, in Klammern stehende, Parameterliste notiert. Diese zweite Liste wird dann der inneren Funktion übergeben. Beispiel:

function außen(a)
{
 function innen(b,c)
 {
  x = a+b+c;
  return(x);
 }
 return(innen);
}
z = außen(1)(2,3) // = 6 

Ab JavaScript 1.5 ist es außerdem möglich die eingeschlossene Funktion gegen eine Bedingung zu stellen. Dazu wird diese z.B. innerhalb einer if-Abfrage definiert. Beispiel:

function außen(a)
//machwas
if(a == 1234)
 function innen()
 {
  //machwas
 }