Funktionsparameter -- Flash CS3

ActionScript 3.0 umfasst einige Funktionsmerkmale für Funktionsparameter, die weniger erfahrenen ActionScript-Programmierern wahrscheinlich unbekannt sind. Die Idee der Übergabe von Parametern über Wert oder als Verweis dürfte den meisten Programmierern vertraut sein, während das arguments-Objekt und der ...-Parameter (Rest) wohl vielen unbekannt sein dürfte.

Unterthemen

Übergabe von Argumenten über Wert oder als Verweis

Bei vielen Programmiersprachen ist es wichtig, den Unterschied zwischen der Übergabe von Argumenten über Wert (Englisch „pass by value") oder als Verweis (Englisch „pass by reference") zu verstehen. Der Unterschied kann sich auf das Codedesign auswirken.

Eine Übergabe über Wert bedeutet, dass der Wert des Arguments in ein lokale Variable kopiert wird, damit er innerhalb der Funktion verwendet werden kann. Eine Übergabe als Verweis bedeutet, dass nur ein Verweis auf das Argument anstelle des tatsächlichen Wertes übergeben wird. Es wird keine Kopie des tatsächlichen Arguments erstellt. Stattdessen wird ein Verweis auf die als Argument übergebene Variable erstellt und einer lokalen Variablen für die Verwendung innerhalb der Funktion zugewiesen. Als Verweis auf eine Variable außerhalb der Funktion ermöglicht die lokale Variable das Ändern des Wertes der Ursprungsvariablen.

In ActionScript 3.0 werden alle Argumente als Verweis übergeben, da alle Werte als Objekte gespeichert sind. Objekte, die zu den Grunddatentypen gehören („Boolean", „Number", „int", „uint" und „String"), haben besondere Operatoren, durch die sich Objekte so verhalten können, als würden sie über Wert übergeben. Im folgenden Beispielcode wird eine Funktion namens passPrimitives() erstellt, die zwei Parameter namens xParam und yParam definiert; beides Parameter des Datentyps „int". Diese Parameter ähneln lokalen Variablen, die innerhalb des Rumpfs der passPrimitives()-Funktion deklariert wurden. Wenn die Funktion mit den Argumenten xValue und yValue aufgerufen wird, werden die Parameter xParam und yParam mit Verweisen auf die int-Objekte initiiert, die von xValue und yValue dargestellt werden. Da diese Argumente Grundtypen sind, verhalten sie sich so, als wenn sie über Wert übergeben worden wären. Obwohl xParam und yParam zunächst nur Verweise auf die Objekte xValue und yValue enthalten, erzeugen alle Änderungen an den Variablen innerhalb des Funktionsrumpfs neue Kopien der Werte im Arbeitsspeicher.

function passPrimitives(xParam:int, yParam:int):void
{
    xParam++;
    yParam++;
    trace(xParam, yParam);
}

var xValue:int = 10;
var yValue:int = 15;
trace(xValue, yValue);          // 10 15
passPrimitives(xValue, yValue); // 11 16
trace(xValue, yValue);          // 10 15

In der passPrimitives()-Funktion werden die Werte von xParam und yParam erhöht. Dies wirkt sich jedoch nicht auf die Werte von xValue und yValue aus, wie aus der letzten trace-Anweisung ersichtlich ist. Dies würde eintreten, wenn die Parameter mit den gleichen Namen wie die Variablen xValue und yValue benannt wären, da xValue und yValue innerhalb der Funktion auf neue Speicherstellen im Arbeitsspeicher verweisen würden, die separat von den Variablen mit dem gleichen Namen außerhalb der Funktion existieren würden.

Alle anderen Objekte - also Objekte, die nicht zu den Grundtypen gehören - werden immer als Verweis übergeben, sodass Sie die Werte der Ursprungsvariablen ändern können. Im folgenden Beispielcode wird ein Objekt namens objVar mit zwei Eigenschaften erstellt, x und y. Das Objekt wird als Argument an die Funktion passByRef() übergeben. Da das Objekt nicht zu den Grundtypen gehört, wird es nicht nur als Verweis übergeben, sondern bleibt auch ein Verweis. Dies bedeutet, dass sich Änderungen an den Parametern innerhalb der Funktion auf die Objekteigenschaften außerhalb der Funktion auswirken.

function passByRef(objParam:Object):void
{
    objParam.x++;
    objParam.y++;
    trace(objParam.x, objParam.y);
}
var objVar:Object = {x:10, y:15};
trace(objVar.x, objVar.y); // 10 15
passByRef(objVar);         // 11 16
trace(objVar.x, objVar.y); // 11 16

Der objParam-Parameter verweist auf das gleiche Objekt wie die globale Variable objVar. Wie Sie anhand der trace-Anweisungen im Codebeispiel sehen können, werden Änderungen an den Eigenschaften x und y des objParam-Objekts im objVar-Objekt widergespiegelt.

Standard-Parameterwerte

Neu in ActionScript 3.0 ist die Möglichkeit zum Deklarieren von Standard-Parameterwerten für eine Funktion. Wenn ein Aufruf einer Funktion mit Standard-Parameterwerten einen Parameter mit Standardwerten weglässt, wird der in der Funktionsdefinition angegebene Wert für diesen Parameter verwendet. Alle Parameter mit Standardwerten müssen am Ende der Parameterliste platziert werden. Bei den als Standardwerte zugewiesenen Werten muss es sich um Konstanten zur Kompilierzeit handeln. Das Vorhandensein eines Standardwerts für einen Parameter macht diesen Parameter zu einem optionalen Parameter. Ein Parameter ohne Standardwert wird als erforderlicher Parameter betrachtet.

Im folgenden Beispielcode wird eine Funktion mit drei Parametern erstellt, zwei dieser Parameter weisen Standardwerte auf. Wenn die Funktion mit nur einem Parameter aufgerufen wird, werden die Standardwerte für die Parameter verwendet.

function defaultValues(x:int, y:int = 3, z:int = 5):void
{
    trace(x, y, z);
}
defaultValues(1); // 1 3 5

arguments-Objekt

Wenn Parameter an eine Funktion übergeben werden, können Sie mit dem arguments-Objekt auf Informationen über die an Ihre Funktion übergebenen Parameter zugreifen. Einige wichtige Aspekte des arguments-Objekts sind:

In ActionScript 3.0 können Funktionsaufrufe mehr Parameter enthalten als in der Funktionsdefinition definiert wurden. Dies führt jedoch im strikten Modus zu einem Compiler-Fehler, wenn die Anzahl der Parameter kleiner ist als die Anzahl der erforderlichen Parameter. Sie können den Array-Aspekt des arguments-Objekts verwenden, um auf Parameter zuzugreifen, die an die Funktion übergeben wurden. Dabei spielt es keine Rolle, ob dieser Parameter in der Funktionsdefinition definiert wurde. Im folgenden Beispielcode wird das Array arguments zusammen mit der Eigenschaft arguments.length verwendet, um alle Parameter zu verfolgen, die an die traceArgArray()-Funktion übergeben wurden:

function traceArgArray(x:int):void
{
    for (var i:uint = 0; i < arguments.length; i++)
    {
        trace(arguments[i]);
    }
}

traceArgArray(1, 2, 3);

// Ausgabe:
// 1
// 2
// 3

Die arguments.callee-Eigenschaft wird häufig in anonymen Funktionen zum Erstellen einer Rekursion verwendet. Außerdem können Sie mit dieser Eigenschaft die Flexibilität Ihres Codes erweitern. Wenn sich der Name einer rekursiven Funktion im Verlauf Ihres Entwicklungszyklus ändert, müssen Sie sich nicht um die Änderung des rekursiven Aufrufs in Ihrem Funktionsrumpf kümmern, wenn Sie arguments.callee anstelle des Funktionsnamens verwenden. Die arguments.callee-Eigenschaft wird im folgenden Funktionsausdruck verwendet, um eine Rekursion zu ermöglichen:

var factorial:Function = function (x:uint)
{
    if(x == 0)
    {
        return 1;
    }
    else
    {
        return (x * arguments.callee(x - 1));
    }
}

trace(factorial(5)); // 120

Wenn Sie den ... -Parameter (Rest) in der Funktionsdeklaration verwenden, steht das arguments-Objekt nicht zur Verfügung. Stattdessen greifen Sie mit den Parameternamen, die Sie für die Parameter deklariert haben, auf die Parameter zu.

Verwenden Sie den String „arguments" nicht als Parameternamen, da dadurch das arguments-Objekt verborgen wird. Angenommen, die Funktion traceArgArray() wird umgeschrieben, um einen arguments-Parameter hinzuzufügen, so zeigen die Verweise auf arguments im Funktionsrumpf auf den Parameter anstatt auf das arguments-Objekt. Der folgende Code erzeugt keine Ausgabe:

function traceArgArray(x:int, arguments:int):void
{
    for (var i:uint = 0; i < arguments.length; i++)
    {
        trace(arguments[i]);
    }
}

traceArgArray(1, 2, 3);

// keine Ausgabe

In früheren Versionen von ActionScript enthielt das arguments-Objekt noch eine Eigenschaft namens caller, die einen Verweis auf die Funktion darstellt, welche die aktuelle Funktion aufruft. Die caller-Eigenschaft ist in ActionScript 3.0 nicht mehr vorhanden. Wenn Sie einen Verweis auf die aufrufende Funktion benötigen, können Sie die aufrufende Funktion so ändern, dass sie einen weiteren Parameter übergibt, der einen Verweis auf sich selbst darstellt.

...-Parameter (Rest)

Mit ActionScript 3.0 wurde eine neue Parameterdeklaration mit der Bezeichnung ... -Parameter (Rest) eingeführt. Mit diesem Parameter können Sie einen Array-Parameter angeben, der mit einer beliebigen Anzahl von kommagetrennten Argumenten arbeitet. Der Parameter kann jeden Namen annehmen, der kein reserviertes Wort ist. Diese Parameterdeklaration muss der letzte angegebene Parameter sein. Wenn Sie diesen Parameter verwenden, steht das Objekt arguments nicht mehr zur Verfügung. Obwohl der ... -Parameter (Rest) die gleichen Funktionsmerkmale wie das arguments-Array und die arguments.length-Eigenschaft zur Verfügung stellt, verfügt er nicht über die Funktionsmerkmale, die mit arguments.callee bereitgestellt werden. Bevor Sie den ... -Parameter (Rest) einsetzen, sollten Sie sicherstellen, dass Sie arguments.callee nicht benötigen.

Im folgenden Beispielcode wird die traceArgArray()-Funktion mit dem ... -Parameter (Rest) anstelle des arguments-Objekts neu programmiert:

function traceArgArray(... args):void
{
    for (var i:uint = 0; i < args.length; i++)
    {
        trace(args[i]);
    }
}

traceArgArray(1, 2, 3);

// Ausgabe:
// 1
// 2
// 3

Der ... -Parameter (Rest) kann zusammen mit anderen Parametern verwendet werden, muss jedoch der letzte angegebene Parameter sein. Im folgenden Codebeispiel wird die traceArgArray()-Funktion so geändert, dass der erste Parameter x den Datentyp „int" aufweist und der zweite Parameter den ... -Parameter (Rest) verwendet. Die Ausgabe überspringt den ersten Wert, da der Parameter jetzt kein Teil des Arrays mehr ist, das vom ... -Parameter (Rest) erstellt wurde.

function traceArgArray(x: int, ... args)
{
    for (var i:uint = 0; i < args.length; i++)
    {
        trace(args[i]);
    }
}

traceArgArray(1, 2, 3);

// Ausgabe:
// 2
// 3