Der
Gültigkeitsbereich
einer Variablen ist der Bereich Ihres Codes, in dem durch einen lexikalischen Verweis auf die Variable zugegriffen werden kann. Eine
globale
Variable ist in allen Bereichen Ihres Codes definiert, während eine
lokale
Variable nur in einem bestimmten Teil Ihres Codes definiert ist. In ActionScript 3.0 sind Variablen immer dem Gültigkeitsbereich der Funktion oder Klasse zugeordnet, in der sie deklariert wurden. Eine globale Variable ist eine Variable, die außerhalb einer Funktions- oder Klassendefinition definiert ist. Im folgenden Code wird beispielsweise eine globale Variable
strGlobal
erstellt, indem sie außerhalb einer Funktion deklariert wird. Das Beispiel zeigt, dass eine globale Variable sowohl innerhalb als auch außerhalb der Funktionsdefinition verfügbar ist.
var strGlobal:String = "Global";
function scopeTest()
{
trace(strGlobal); // Global
}
scopeTest();
trace(strGlobal); // Global
Sie deklarieren eine lokale Variable, indem Sie die Variable innerhalb einer Funktionsdefinition deklarieren. Der kleinste Codebereich, für den Sie eine lokale Variable definieren können, ist eine Funktionsdefinition. Eine lokale Variable, die in einer Funktion deklariert wurde, existiert nur in dieser Funktion. Wenn Sie beispielsweise eine Variable namens
str2
in einer Funktion namens
localScope()
deklarieren, steht diese Variable außerhalb der Funktion nicht zur Verfügung.
function localScope()
{
var strLocal:String = "local";
}
localScope();
trace(strLocal); // error because strLocal is not defined globally
Wenn der Name, den Sie für Ihre lokale Variable verwenden, bereits als globale Variable deklariert ist, hat die lokale Definition Vorrang vor der globalen Definition, solange sich die lokale Variable im Gültigkeitsbereich befindet. Die globale Variable existiert weiterhin außerhalb der Funktion. Im folgenden Code wird beispielsweise eine globale Stringvariable namens
str1
und dann eine lokale Variable mit demselben Namen in der Funktion
scopeTest()
erstellt. Die Anweisung
trace
in der Funktion gibt den lokalen Wert der Variablen zurück, und die Anweisung
trace
außerhalb der Funktion gibt den globalen Wert der Variablen zurück.
var str1:String = "Global";
function scopeTest ()
{
var str1:String = "Local";
trace(str1); // Local
}
scopeTest();
trace(str1); // Global
ActionScript-Variablenhaben im Gegensatz zu Variablen in C++ und Java keinen Gültigkeitsbereich auf Blockebene. Ein Codeblock ist eine Gruppe von Anweisungen zwischen einer öffnenden geschweiften Klammer (
{
) und einer schließenden geschweiften Klammer (
}
). In einigen Programmiersprachen, wie beispielsweise C++ und Java, stehen Variablen die in einem Codeblock deklariert wurden, außerhalb dieses Codeblocks nicht zur Verfügung. Diese Einschränkung des Gültigkeitsbereichs wird als Gültigkeitsbereich auf Blockebene bezeichnet. Eine solche Einschränkung gibt es in ActionScript nicht. Wenn Sie also eine Variable innerhalb eines Codeblocks deklarieren, steht die Variable nicht nur in diesem Codeblock, sondern auch in anderen Teilen der Funktion zur Verfügung, zu welcher der Codeblock gehört. Beispielsweise enthält die folgende Funktion Variablen die in verschiedenen Block-Gültigkeitsbereichen definiert sind. Alle Variablen stehen in der gesamten Funktion zur Verfügung.
function blockTest (testArray:Array)
{
var numElements:int = testArray.length;
if (numElements > 0)
{
var elemStr:String = "Element #";
for (var i:int = 0; i < numElements; i++)
{
var valueStr:String = i + ": " + testArray[i];
trace(elemStr + valueStr);
}
trace(elemStr, valueStr, i); // all still defined
}
trace(elemStr, valueStr, i); // all defined if numElements > 0
}
blockTest(["Earth", "Moon", "Sun"]);
Eine interessante Auswirkung des Fehlens eines Gültigkeitsbereichs auf Blockebene ist, dass Sie eine Variable schon vor dem Deklarieren für Lese- und Schreibvorgänge verwenden können, solange sie vor dem Ende der Funktion deklariert wird. Dies beruht auf der so genannten
Hoisting
-Technik (etwa: Hochziehen), die dafür sorgt, dass der Compiler alle Variablendeklarationen an den Anfang der Funktion verschiebt. Beispielsweise kann der folgende Code kompiliert werden, obwohl die erste
trace()
-Funktion für die Variable
num
schon vor der Deklaration der
num
-Variable ausgeführt wird.
trace(num); // NaN
var num:Number = 10;
trace(num); // 10
Der Compiler verschiebt jedoch keine Zuweisungsanweisungen an den Anfang einer Funktion. Dies erklärt, warum die erste
trace()
-Funktion für
num
zum Ergebnis
NaN
(not a number) führt, dem Standardwert für Variablen des Datentyps „Number“. Aus diesem Grund können Sie Variablen schon vor ihrer Deklaration Werte zuweisen. Dies wird im folgenden Beispiel gezeigt:
num = 5;
trace(num); // 5
var num:Number = 10;
trace(num); // 10