Grundfunktionen -- Flash CS3

In diesem Abschnitt werden die Definitionen der Grundfunktionen und die Techniken zum Aufrufen dieser Funktionen beschrieben.

Unterthemen

Aufrufen von Funktionen

Eine Funktion wird mit ihrem Bezeichner und anschließender Eingabe des Klammernoperators (()) aufgerufen. Der Klammernoperator nimmt alle Funktionsparameter auf, die Sie an die Funktion übergeben möchten. Beispielsweise wird die trace()-Funktion, eine der Funktionen auf der obersten Ebene in der Flash Player-API, wiederholt in diesem Handbuch verwendet:

trace("Use trace to help debug your script");

Wenn Sie eine Funktion ohne Parameter aufrufen, müssen Sie ein leeres Paar runder Klammern angeben. Zum Erzeugen einer Zufallszahl können Sie beispielsweise die Math.random()-Methode verwenden, die ohne Parameter arbeitet:

var randomNum:Number = Math.random();

Definieren eigener Funktionen

Eine Funktion in ActionScript 3.0 kann auf zwei Arten erstellt werden: Sie können eine Funktionsanweisung oder einen Funktionsausdruck verwenden. Die von Ihnen gewählte Technik hängt davon ab, ob Sie einen statischen oder dynamischen Programmierstil bevorzugen. Wenn Sie das statische Programmieren bzw. den strikten Modus bevorzugen, definieren Sie Ihre Funktionen mit Funktionsanweisungen. Definieren Sie Ihre Funktionen mit Funktionsausdrücken, wenn dies aus bestimmten Gründen erforderlich ist. Funktionsausdrücke werden häufiger bei der dynamischen Programmierung bzw. im Standardmodus eingesetzt.

Funktionsanweisungen

Funktionsanweisungen stellen die bevorzugte Technik bei der Definition von Funktionen im strikten Modus dar. Eine Funktionsanweisung beginnt mit dem Schlüsselwort function, gefolgt von:

Im folgenden Beispielcode wird eine Funktion erstellt, die einen Parameter definiert und dann die Funktion mit dem String „hello" als Parameterwert aufruft:

function traceParameter(aParam:String)
{
    trace(aParam);
}

traceParameter("hello"); // hello

Funktionsausdrücke

Das zweite Verfahren zum Deklarieren einer Funktion verwendet eine Funktionsanweisung mit einem Funktionsausdruck, der manchmal auch als ein Funktionsliteral oder als eine anonyme Funktion bezeichnet wird. Dies ist eine wesentlich ausführlichere Methode, die häufig in früheren Versionen von ActionScript verwendet wurde.

Eine Funktionsanweisung mit einem Funktionsausdruck beginnt mit dem Schlüsselwort var, gefolgt von:

Im folgenden Beispielcode wird die traceParameter-Funktion mit einem Funktionsausdruck deklariert:

var traceParameter:Function = function (aParam:String)
{
    trace(aParam);
};
traceParameter("hello"); // hello

Im Gegensatz zu einer Funktionsanweisung geben Sie keinen Funktionsnamen an. Ein anderer wichtiger Unterschied zwischen Funktionsausdrücken und Funktionsanweisungen besteht darin, dass ein Funktionsausdruck eher einen Ausdruck als eine Anweisung darstellt. Dies bedeutet, dass ein Funktionsausdruck im Gegensatz zu einer Funktionsanweisung nicht allein stehen kann. Ein Funktionsausdruck kann nur als Teil einer Anweisung verwendet werden, in der Regel wird hier eine Zuweisungsanweisung verwendet. Das folgende Beispiel zeigt einen Funktionsausdruck, der einem Array-Element zugewiesen ist:

var traceArray:Array = new Array();
traceArray[0] = function (aParam:String)
{
    trace(aParam);
};
traceArray[0]("hello");

Auswählen zwischen Anweisungen und Ausdrücken

Im Allgemeinen verwenden Sie eine Funktionsanweisung, es sei denn, besondere Umstände verlangen nach einem Ausdruck. Funktionsanweisungen sind weniger ausführlich und bieten eine einheitlichere Führung zwischen dem strikten Modus und dem Standardmodus als Funktionsausdrücke.

Funktionsanweisungen sind einfacher zu lesen als Anweisungszuweisungen, die Funktionsausdrücke enthalten. Funktionsanweisungen halten den Code kurz und sind einfacher zu verstehen als Funktionsausdrücke, für die Sie die beiden Schlüsselwörter var und function verwenden müssen.

Funktionsanweisungen sorgen für eine einheitlichere Führung zwischen den beiden Compiler-Modi, da Sie die Punktsyntax sowohl im strikten als auch im Standardmodus verwenden können, um eine Methode aufzurufen, die mit einer Funktionsanweisung deklariert wurde. Dies gilt nicht unbedingt für Methoden, die mit einem Funktionsausdruck deklariert wurden. Im folgenden Beispielcode wird eine Klasse namens „Example" mit zwei Methoden definiert: methodExpression(), die mit einem Funktionsausdruck deklariert wurde, und methodStatement(), die mit einer Funktionsanweisung deklariert wurde. Im strikten Modus können Sie die Punktsyntax nicht verwenden, um die Methode methodExpression() aufzurufen.

class Example
{
  var methodExpression = function() {}
  function methodStatement() {}
}

var myEx:Example = new Example();
myEx.methodExpression(); // Fehler im strikten Modus; OK im Standardmodus
myEx.methodStatement(); // OK im strikten Modus und im Standardmodus

Funktionsausdrücke sind wesentlich besser zum Programmieren geeignet, wenn das Hauptaugenmerk auf dem Echtzeit- bzw. dynamischen Verhalten liegt. Wenn Sie den strikten Modus bevorzugen, aber ebenfalls eine Methode aufrufen müssen, die mit einem Funktionsausdruck deklariert wurde, können Sie eines der beiden Verfahren verwenden. Zunächst können Sie die Methode mit eckigen Klammern ([]) anstelle des Punktoperators (.) aufrufen. Der folgende Methodenaufruf wird sowohl im strikten als auch im Standardmodus erfolgreich ausgeführt:

myExample["methodLiteral"]();

Alternativ können Sie die gesamte Klasse als dynamische Klasse deklarieren. Obwohl Ihnen dieses Verfahren ermöglicht, die Methode mit dem Punktoperator aufzurufen, gibt es einen Nachteil: Sie opfern einen Teil der Funktionsmerkmale im strikten Modus für alle Instanzen dieser Klasse. Beispielsweise erzeugt der Compiler keinen Fehler, wenn Sie versuchen, bei einer Instanz einer dynamischen Klasse auf eine undefinierte Eigenschaft zuzugreifen.

Es gibt ein paar Situationen, in denen Funktionsausdrücke sinnvoll sind. Häufig werden Funktionsausdrücke für Funktionen genutzt, die nur einmal verwendet und dann verworfen werden. Eine weitere weniger übliche Anwendungsmöglichkeit ist das Anfügen einer Funktion an eine Prototypeigenschaft. Weitere Informationen finden Sie unter Prototypobjekt.

Es gibt zwei feine Unterschiede zwischen Funktionsanweisungen und Funktionsausdrücken, die Sie unbedingt bei der Auswahl der zu verwendenden Technik berücksichtigen sollten. Der erste Unterschied ist, dass Funktionsausdrücke hinsichtlich der Speicherverwaltung und -bereinigung (Garbage Collection) nicht unabhängig als Objekte existieren. Anders ausgedrückt, wenn Sie einen Funktionsausdruck einem anderen Objekt zuweisen (beispielsweise einem Array-Element oder einer Objekteigenschaft), erstellen Sie in Ihrem Code lediglich einen Verweis auf diesen Funktionsausdruck. Wenn das Array oder Objekt, an das Ihr Funktionsausdruck angehängt ist, außerhalb des Gültigkeitsbereichs gerät oder aus anderen Gründen nicht mehr zur Verfügung steht, ist kein Zugriff auf den Funktionsausdruck mehr möglich. Wenn das Array oder Objekt gelöscht wurde, wird der vom Funktionsausdruck belegte Speicher für die Garbage Collection verfügbar. Dies bedeutet, dass der Speicherbereich für andere Zwecke neu vergeben werden kann.

Das folgende Beispiel zeigt einen Funktionsausdruck, in dem die Funktion nicht mehr zur Verfügung steht, nachdem die Eigenschaft, welcher der Ausdruck zugewiesen war, gelöscht wurde. Die Test-Klasse ist dynamisch; dies bedeutet, Sie können eine Eigenschaft namens functionExp hinzufügen, die einen Funktionsausdruck aufnimmt. Die functionExp()-Funktion kann mit dem Punktoperator aufgerufen werden, aber nachdem die Eigenschaft functionExp gelöscht wurde, kann nicht mehr auf die Funktion zugegriffen werden.

dynamic class Test {}
var myTest:Test = new Test();

// Funktionsausdruck 
myTest.functionExp = function () { trace("Function expression") };
myTest.functionExp();   // Funktionsausdruck
delete myTest.functionExp;
myTest.functionExp();   // Fehler

Wenn die Funktion andererseits zuerst mit einer Funktionsanweisung definiert wird, existiert sie als eigenständiges Objekt und kann auch weiterhin verwendet werden, nachdem die Eigenschaft gelöscht wurde, an die sie angefügt wurde. Der Operator delete kann nur mit Eigenschaften von Objekten verwendet werden. Daher hat auch ein Aufruf zum Löschen der Funktion stateFunc() keine Auswirkungen.

dynamic class Test {}
var myTest:Test = new Test();

// Funktionsanweisung
function stateFunc() { trace("Function statement") }
myTest.statement = stateFunc;
myTest.statement(); // Funktionsanweisung
delete myTest.statement;
delete stateFunc;   // keine Auswirkung
stateFunc();        // Funktionsanweisung
myTest.statement(); // Fehler

Der zweite Unterschied zwischen Funktionsanweisungen und Funktionsausdrücken besteht darin, dass Funktionsanweisungen im gesamten Gültigkeitsbereich existieren, in dem sie definiert wurden. Hierzu zählen auch die Anweisungen, die vor der Funktionsanweisung stehen. Im Gegensatz dazu sind Funktionsausdrücke nur für nachfolgende Anweisungen definiert. Im folgenden Codebeispiel wird die scopeTest()-Funktion erfolgreich aufgerufen, bevor sie definiert wird:

statementTest(); // statementTest

function statementTest():void
{
    trace("statementTest");
}

Funktionsausdrücke sind erst verfügbar, nachdem sie definiert wurden. Aus diesem Grund führt der folgende Code zu einem Laufzeitfehler:

expressionTest(); // Laufzeitfehler

var expressionTest:Function = function ()
{
    trace("expressionTest");
}

Zurückgeben von Werten aus Funktionen

Wenn Ihre Funktion einen Wert zurückgeben soll, verwenden Sie die return-Anweisung gefolgt von dem Ausdruck oder Literalwert, der zurückgegeben werden soll. Der folgende Code gibt beispielsweise einen Ausdruck zurück, der einen Parameter darstellt:

function doubleNum(baseNum:int):int
{
    return (baseNum * 2);
}

Beachten Sie, dass die return-Anweisung die Funktion beendet. Das heißt, alle Anweisungen nach einer return-Anweisung werden nicht ausgeführt, wie im folgenden Code dargestellt:

function doubleNum(baseNum:int):int {
    return (baseNum * 2);
    trace("after return"); // Diese trace-Anweisung wird nicht ausgeführt.
}

Im strikten Modus müssen Sie einen Wert des entsprechenden Typs zurückgeben, wenn Sie einen Rückgabetyp festgelegt haben. Mit dem folgenden Code wird im strikten Modus eine Fehlermeldung erzeugt, da er keinen gültigen Wert zurückgibt:

function doubleNum(baseNum:int):int
{
    trace("after return");
}

Verschachtelte Funktionen

Sie können Funktionen verschachteln; anders ausgedrückt, Sie können Funktionen innerhalb von anderen Funktionen deklarieren. Eine verschachtelte Funktion steht nur innerhalb ihrer übergeordneten Funktion zur Verfügung, es sei denn, dem externen Code wurde ein Verweis auf die Funktion übergeben. Im folgenden Codebeispiel werden zwei verschachtelte Funktionen in der Funktion getNameAndVersion() deklariert:

function getNameAndVersion():String
{
    function getVersion():String
    {
        return "9";
    }
    function getProductName():String
    {
        return "Flash Player";
    }
    return (getProductName() + " " + getVersion());
}
trace(getNameAndVersion()); // Flash Player 9

Verschachtelte Funktionen werden als Funktionshüllen an einen externen Code übergeben. Dies bedeutet, dass die Funktion alle Definitionen beibehält, die sich beim Definieren der Funktion in ihrem Gültigkeitsbereich befanden. Weitere Informationen finden Sie unter Funktionshüllen.