JavaScript@web.dok

Funktionen

Anweisungsblöcke
Funktionen
Parameter und Rückgabewerte
Aufrufe
globale und lokale Variable
Standardfunktionen

Anweisungsblöcke

Ein Anweisungsblock besteht aus zwei oder mehreren Anweisungen, die innerhalb einer übergeordneten Anweisung (z.B. bedingte Verzwigung oder Schleife) oder innerhalb einer Funktion stehen. Alle Anweisungen, die innerhalb einer selbst definierten Funktion stehen, bilden einen Anweisungsblock.

Ein Anweisungsblock wird durch eine öffnende geschweifte Klammer { begonnen und durch eine schließende geschweifte Klammer } beendet. Sie können die geschweiften Klammern jeweils in eine eigene Zeile schreiben, so wie in den Beispielen. Es ist aber auch erlaubt, die Klammern in der gleichen Zeile zu notieren wie die Anweisungen.

Bei bedingten Verzweigungen oder Schleifen müssen Sie solche Anweisungsblöcke notieren, sobald mehr als eine Anweisung von der Bedingung abhängig ausgeführt werden soll. Bei Funktionen müssen Sie immer Anfang und Ende der Funktion durch geschweifte Klammern markieren. Alles, was innerhalb der Funktion steht, ist daher ein Anweisungsblock.

function SageQuadrat(x) {
var Ergebnis = x * x;
alert(Ergebnis);
}

Anweisungsblöcke können natürlich auch verschachtelt sein, so wie in Beispiel 4 oben.

function SagEinmaleins(x) {

var Ergebnis = x * x;

   if(Ergebnis > 100) {
    Ergebnis = 0;
    Neustart();
    }

alert(Ergebnis);
}

Funktionen

Innerhalb des JavaScript-Bereichs, vozugsweise im Dateikopf, können selbst definierte Funktionen implementiert werden. Funktionen sind Anweisungsblöcke, die bei Bedarf aufgerufen werden. Der Vorteil von Funktionen ist, das sie immer wieder und von verschiedenen Stellen aufgerufen werden können. So müssen redundante Anweisungen nicht immer neu geschrieben werden, sondern können zu einer Funktion zusammengefasst werden. Eine Funktion beschreibt also eine Klasse von Problemen, nicht die bestimmte Ausprägung eines Problems.

Der Kopf von Funktionen beginnt immer mit dem Schlüsselwort "function", gefolgt von einem frei zu vergebenden Namen (mit den gleichen Einschränkungen wie bei den Variablennamen). Auf diesen folgen wiederum zwei runde Klammern () und dann die in geschweifte Klammern {...} gesetzten Anweisungen (Anweisungsblock).

function Funktionsname () {
    Anweisung 1
    ...
    Anweisung n
    }

Parameter und Rückgabewerte

Der Funktion können beim Aufruf auch Werte übergeben werden, mit denen die Funktion arbeiten soll. Diese Werte, auch Parameter genannt, stehen dann innerhalb der runden Klammern (). Die Parameter werden in der Regel beim Aufruf belegt. Dabei sind nicht die Namen der Parameter entscheidend, als vielmehr ihre Anzahl und Reihenfolge.

<html>
  <head>
    <title>JavaScript-Test</title>
    <script language="JavaScript">
      
    </script>
  </head>
  <body>
    <form>
      <input type=button value="Quadrat von 6 errechnen" onClick="Quadrat(6)">
      <input type=button value="Quadrat von 9 errechnen" onClick="Quadrat(9)">
    </form>
  </body>
</html>

Beispiel 6/a>

Es können auch mehrere Parameter übergeben werden, die dann mit Kommata getrennt werden.

Die Funktion Quadrat(x) errechnet im Beispiel oben das Quadrat von x und gibt das Ergebnis in einem alert-Fenster aus. Sie könnte von verschiedenen Stellen im HTML-Code aufgerufen werden. Damit ist sie für alle Quadratberechnungen zu gebrauchen. In diesem Fall bekommt die Funktion beim Aufruf eine Zahl als Parameter übergeben.

In JavaScript ist es möglich Funktionen mit einer variablen Anzahl von Parametern zu erzeugen, dabei werden die runden Klammern leer gelassen und die Parameter aus dem Array funktionsname.arguments.[i] ausgelesen. Soll zum Beispiel eine Funktion die Summme mehrere Werte ermitteln, könnte sie so aussehen:

function Summe() {
var Ergebnis=0;

    for (var i=0;i<summe.arguments.length;i++) {
      Ergebnis += summe.arguments.[i]*1;
    }

return Ergebnis;
}

Eine Schleife, hier mit dem Zähler i, liest das Array nacheinander aus und addiert die Werte auf. Die Aufrufe der Funktion könnten folgendermaßen aussehen:

x=summe(23,41,65);
y=summe(15,21,34,57,92,31,27);

Siehe hierzu auch Beispiel 12.

Im umgekehrten Fall, wenn weniger Parameter im Aufruf angegeben werden als in der Funktion vereinbart sind, bekommen die fehlenden Parameter automatisch den Wert null wie im folgenden Beispiel:

function test(s) {
   if ( s == null)
     return ""
   else
     return "irgendwas"
   }

Aufruf: test();

Die bislang gezeigten Funktionen wurden aufgerufen und liefen dann einfach ab ohne etwas der aufrufenden Instanz zurückzumelden. Soll die Funktion Quadrat(x) nun universell zu verwenden sein, empfielt es sich, die Ausgabe des Ergebnisses und die Berechnung zu trennen. Dafür muß die Funktion geringfügig modifiziert werden:

function Quadrat(Zahl) {
  var Ergebnis = Zahl * Zahl;
  return Ergebnis;
  }

Das Schlüsselwort return liefert jetzt die Variable Ergebnis an die aufrufende Instanz zurück. Der Aufruf müßte daher ebenfalls verändert werden:

onClick="x=Quadrat(6);alert(x);"

Die Funktion wird durch Quadrat(6) aufgerufen und ausgeführt. Das Ergebnis wird durch return zurückgeliefert und landet in der Variablen x. Daraufhin wird es durch eine alert-Box ausgegeben. Da der Interpreter die Funktion immer bei der return Anweisung verläßt und zurückspringt, steht diese Anweisung in der Regel am Ende.

Im Beispiel 7wird die Funktion Quadrat() mit dem Parameter zahlenfeld.value aufgerufen. zahlenfeld.value ist der Wert der im Feld zahlenfeld ducrh den Nutzer eingetragen wurde. Das Ergebnis wird dann in das selbe Feld wieder eingetragen.

Aufrufe

Der JavaScript-Code von Funktionen wird nur ausgeführt, wenn er explizit aufgerufen wird. Im obigen Beispiel erfolgt der Aufruf mit Hilfe eines buttons und der Anweisung onClick. Wenn der Anwender auf den button klickt, wird die Funktion mit dem entsprechenden Parameter ausgeführt.

Funktionen können sich auch gegenseitig aufrufen:

function FunktionsnameA () {
    Anweisung 1
    ...
    FunktionsnameB();
    Anweisung n
    }

Hier wird innerhalb der Funktion FunktionsnameA() die Funktion FunktionsnameB() aufgerufen.

globale und lokale Variable

Unbedingt zu beachten ist der Gültigkeitsbereich von Variablen.

globale Variable sind von überall her auszulesen und zu verändern. Sie werden ausserhalb von Funktionen deklariert.

      function Quadrat(Zahl) {
        Ergebnis = Zahl * Zahl;
        alert("Das Quadrat von " + Zahl + " = " + Ergebnis);
        }
      //-->
</script>

lokale Variable sind nur innerhalb einer Funktion gültig und werden auch innerhalb einer Funktion deklariert. Sie können auch nur dort ausgelesen oder belegt werden. Sie können lokale Variable mit dem selben Namen innerhalb verschiedener Funktionen verwenden (lokale Variable) und mit verschiedenen Werten belegen. Wegen der Übersichtlichkeit sollte man solche Fälle jedoch vermeiden.

Standardfunktionen

Es gibt eine Reihe Standardfunktionen in JavaScript, die Sie verwenden können:

(NaN steht für Not a Number und signalisiert das es sich nicht um eine Zahl handelt)

Funktion	Parameter	Beschreibung	Rückgabe	Beispiel
eval(z)	z = Zeichenkette	versucht die Zeichenkette als JavaScript auszuwerten	Ergebnis der Auswertung	X = eval("3*4+5"); x ist dann 17
escape(z)	z = Zeichenkette	Konvertiert ggf. die Sonderzeichen in einer Zeichenkette URL-konform	korrekte URL	escape("eigene Dateien") => "eigene%20Dateien"
unescape(z)	z = Zeichenkette	Umkehrfunktion von escape()	plain Text	escape("eigene%20Dateien") => "eigene Dateien"
IsNaN(w)	w=Wert	testet ob w eine Zeichenkette oder eine Zahl ist	false bei einer Zahl true bei einer Zeichenkette	erg=IsNaN("1980"); erg ist dann false
parseFloat(z)	z = Zeichenkette	Wandelt eine Zeichenkette in eine Zahl um bis zum ersten nicht numerischen Wert. Beginnt die Zeichenkette nicht mit einer Zahl, dann wird NaN zurückgegeben.	Zahl bzw. NaN	x=parseFloat("12.34DM"); x ist dann 12.34
parseInt(z)	z = Zeichenkette	Wandelt eine Zeichenkette in eine ganze Zahl um bis zum ersten nicht numerischen Wert. Beginnt die Zeichenkette nicht mit einer Zahl, dann wird NaN zurückgegeben.	Zahl bzw. NaN	x=parseInt("12.34DM"); x ist dann 12
IsFinite(w)	w=Wert	testet ob es sich um eine Zahl handelt, die JavaScript verarbeiten kann.	true wenn w nicht zu verarbeiten ist