Funktionen

Funktionen sind Codeblöcke, die mit einem Namen verbunden sind und bestimmte Aufgaben übernehmen. Funktionen helfen bei der Organisation von Code, da sie wiederverwertbare Code-Teile darstellen. Eine Funktion kann erst **aufgerufen** (= benutzt) werden, wenn sie **definiert** wurde. Zur Definition einer Funktion braucht es einen **Funktionskopf** mit dem Schlüsselwort //function//, einem frei wählbaren Namen, und (optional) der Angabe von n Parametern. Falls nötig schreibt man dahinter (nach Doppelpunkt) noch den **Typ des Rückgabewerts** ("void" steht für "nichts"). Danach kommt der **Funktionskörper**, ein Codeblock (in geschweiften Klammern), der bestimmt, was die Funktion tut. Damit der entsprechende Code-Block ausgeführt wird, muss man die Funktion über ihren Namen aufrufen. Ein **Funktionsaufruf** besteht aus dem Funktionsnamen gefolgt von Klammern. Innerhalb der Klammern werden die Übergabewerte (Parameter) angegeben, sofern die Funktion welche definiert. Innerhalb eines Objekts definierte Funktionen heissen Methoden. Da sich ActionScript-Code immer in einem Objekt befindet, ist eigentlich jede Funktion auch eine Methode. Eine Funktion kann erst aufgerufen werden, wenn sie definiert ist. Daher ist es ratsam, alle Funktionen im ersten Schlüsselbild der Hauptzeitleiste zu definieren. Siehe auch ////

Syntax
code format="actionscript" function funktionsName(Parameter:Typ):Rückgabetyp //Funktionskopf mit Schlüsselwort, Name und 0 - n Parametern //Alternative Formulierung: funktionsName = function(Parameter:Typ) {  Anweisungen;               //Funktionskörper, hier steht der Code den die Funktion ausführt }

//Aufgerufen wird eine Funktion so: funktionsName(Parameter); //einen Funktionsaufruf erkennt man an den Klammern nach dem Namen meinClip.funktionsName(Parameter); /*jede Funktion ist eine Methode eines Objekts, will man sie von ausserhalb des Objekts aufrufen braucht man einen Pfad*/ code

Parameter
Um Funktionen flexibel zu gestalten, kann man einer Funktion 0 bis n Werte übergeben - diese Übergabewerte werden auch Parameter oder Argumente genannt. Ob und wie viele Parameter eine Funktion hat, wird im Kopf der Funktion definiert, der korrekte Aufruf der Funktion richtet sich nach dieser Definition. Als Beispiel nehmen wir eine Funktion, die wie ein Knopf auf der Fernbedienung wirkt: drückt man die ‚lauter‘-Taste, so setzt der Fernseher die Lautstärke (hier: die bereits initialisierte Variable lautstaerke) herauf. In ActionScript könnte das so aussehen: code format="actionscript" var lautstaerke:Number = 0; //die Variable lautstärke muss ausserhalb der Funktion initialisiert werden function lauter:void { lautstaerke = lautstaerke + 3; //Kurzform: lautstaerke += 3; } lauter; //Funktionsaufruf; erhöht die lautstaerke um eine Stufe code Mit dieser Funktion „lauter“ würden wir also die Variable lautstaerke des Fernsehers um 3 höher setzen. Aufgerufen wird diese Funktion, indem man einfach lauter; schreibt - falls der Code sich innerhalb des Fernsehers befindet. Von ausserhalb braucht es noch dazu den Pfad zum Fernseher, z.B. fernseher.lauter; Will man ermöglichen, dass lautstaerke um einen beliebigen Wert erhöht werden kann, braucht man einen Parameter für diesen Wert: code format="actionscript" function lauter(staerke:Number):void{ lautstaerke = lautstaerke + staerke; } lauter(5); //stellt den Fernseher um 5 Stufen lauter lauter(-1); //stellt eine Stufen leiser code Wie man sieht, wird der Wert aus dem Funktionsaufruf an die Funktion übergeben und steht dann innerhalb der Funktion unter dem Namen //staerke// zur Verfügung. In diesem Beispiel wird der Parameter staerke benutzt, um zu bestimmen, wie viel lauter der Fernseher gemacht werden soll. In **AS3** kann man auch einen Standartwert (default value) für einen Parameter definieren. Dieser wird verwendet, wenn beim Aufruf der Funktion kein Parameter übergeben wird, obwohl eigentlich einer benötigt wird: code format="actionscript" function lauter(staerke:Number = 3):void{ lautstaerke += staerke; } lauter; //nutzt den Standartwert, stellt also um 3 Stufen lauter lauter(10); //nutzt den übergebenen Wert, stellt also 10 Stufen lauter code Funktionen können noch eine weitere wichtige Sache: einen Wert "zurückgeben". Angenommen, wir haben eine Funktion, die das Quadrat von einer Zahl berechnet: code format="actionscript" function quadratFlaeche(seitenLaenge:Number) { var meinQuadrat:Number = seitenLaenge * seitenLaenge; } code In diesem Beispiel speichert die Funktion das Quadrat der Seitenlänge in der Variable //meinQuadrat// - diese wird allerdings innerhalb der Funktion deklariert und ist daher ausserhalb nicht zugänglich (s. Geltungsbereich). Eine Lösung wäre, //meinQuadrat// ausserhalb der Funktion zu initialisieren und dann innerhalb der Funktion nur noch zu schreiben: code format="actionscript" meinQuadrat = seitenLaenge * seitenLaenge; code Auf diese Weise wird der Instanzvariablen //meinQuadrat// ein neuer Wert zugewiesen, der auch ausserhalb der Funktion gültig ist. Es gibt aber auch eine Lösung, bei der man nicht den Umweg über eine Instanzvariable gehen muss. Stattdessen kann man die Funktion mit dem Schlüsselwort **return** dazu bringen, den Wert //meinQuadrat// einfach zurück zu geben: code format="actionscript" function quadratFlaeche(seitenLaenge:Number):Number { //wenn man sauber programmiert, sollte nach den Klammern der Typ des Rückgabewerts angeben angegeben werden var meinQuadrat:Number = seitenLaenge * seitenLaenge; return meinQuadrat; // noch knapper: return seitenLaenge * seitenLaenge; } trace("Fläche: "+quadratFlaeche(2)); //die Funktion gibt jetzt einen Wert zurück, der hier gleich für einen Ausdruck benutzt wird// code Eine Funktion (in AS) kann höchstens einen Rückgabewert haben. Übergeben kann man allerdings beliebig viele Werte/Parameter, wozu das nötig sein kann, sieht man bei der Flächenberechnung eins Rechtecks: code format="actionscript" function rechteckFlaeche(hoehe:Number, breite:Number):Number { return hoehe * breite; } var flaeche:Number = rechteckFlaeche(5, 3); //hier müssen 2 Werte übergeben werden, s. Kopf. Das zurückgegebene Ergebnis wird in der Variablen flaeche gespeichert code //Wie schon erwähnt sind Funktionen praktisch, wenn man Code wiederverwendbar gestalten will. Wenn wir z.B. die beiden obigen Funktionen zur Flächenberechnung zur Verfügung haben, dann ist es sehr einfach, eine Gesamtfläche für mehrere Formen zu bekommen:// code format="actionscript" //setzt die Funktionen quadratFlaeche(seitenLaenge) und rechteckFlaeche(hoehe, breite) voraus var gesamtFlaeche:Number = quadratFlaeche(2) + rechteckFlaeche(5, 3) + quadratFlaeche(3.4); code //Wenn mit return ein Rückgabewert spezifiziert wurde, kann man also die Funktion einfach in Zuweisungen (rechte Seite) oder auch innerhalb von Berechnungen aufrufen, da sie bei der Ausführung des Codes ausgerechnet und dann durch den zurückgegebenen Wert ersetzt wird - z.B. wird// quadratFlaeche(2) //durch den Wert// 4 //ersetzt//.

Platzierung von Funktionen
In AS2 können benutzerdefinierten Funktionen an unterschiedlichen Stellen platziert werden, zum Beispiel auf einer Schaltfläche oder Filmsequenz, was den Funktionsaufruf (Pfade) je nach Situation erleichtern oder erschwerden kann. In AS3 sind die Möglichkeiten zur variablen Platzierung von AS-Code eingeschränkt. Zu empfehlen ist daher - in beiden Versionen - Code ausschliesslich in der Hauptzeitleiste zu platzieren, möglichst in einer eigenen gesperrten Ebene ohne sonstige Inhalte.

Alternative Einführung in Funktionen (AS2, deutsch)

 * http://www.learning-how.to/actionscript/Funktionen/content-docs/01-funktionen.php