En variabels omfång är det område i koden där variabeln kan nås av en lexikalreferens. En global variabel har definierats i alla kodens områden, medan en lokal variabel bara har definierats i en viss del av koden. I ActionScript 3.0 tilldelas variabler alltid det omfång av den funktion eller den klass som de deklarerats i. En global variabel definierar du utanför en funktions- eller klassdefinition. I följande kod skapas till exempel den globala variabeln strGlobal eftersom den deklareras utanför en funktion. I exemplet visas att en global variabel är tillgänglig både inuti och utanför funktionsdefinitionen.
var strGlobal:String = "Global";
function scopeTest()
{
trace(strGlobal); // Global
}
scopeTest();
trace(strGlobal); // Global
Du deklarerar en lokal variabel inuti en funktionsdefinition. Det minsta område i en kod för vilket du kan definiera en lokal variabel är en funktionsdefinition. En lokal variabel som deklareras inuti en funktion finns bara i den funktionen. Om du exempelvis deklarerar en variabel med namnet str2 i en funktion som heter localScope() är den variabeln inte tillgänglig utanför funktionen.
function localScope()
{
var strLocal:String = "local";
}
localScope();
trace(strLocal); // error because strLocal is not defined globally
Om det variabelnamn du använder för den lokala variabeln redan har deklarerats som en global variabel, är det den lokala definitionen som döljer (eller skuggar) den globala definitionen när den lokala variabeln finns i omfånget. Utanför funktionen kommer den globala variabeln fortfarande att gälla. I följande kod skapas en global variabel med namnet str1 och därefter kommer en lokal variabel med samma namn att skapas i funktionen scopeTest(). Programsatsen trace inuti funktionen matar ut variabelns lokala värde, och programsatsen trace utanför funktionen matar ut variabelns globala värde.
var str1:String = "Global";
function scopeTest ()
{
var str1:String = "Local";
trace(str1); // Local
}
scopeTest();
trace(str1); // Global
ActionScript-variabler har inte blocknivåomfång, vilket variabler i C++ och Java har. Ett kodblock är en grupp programsatser mellan en inledande klammerparentes ( { ) och en avslutande klammerparentes (}). I vissa programmeringsspråk, till exempel C++ och Java, är variabler som deklarerats inuti ett kodblock inte tillgängliga utanför kodblocket. Denna begränsning av omfånget kallas blocknivåomfång och finns inte i ActionScript. Om du deklarerar en variabel inuti ett kodblock är denna variabel tillgänglig inte bara i det kodblocket, utan även i andra delar av funktionen som kodblocket hör till. Följande funktion innehåller variabler som definierats i olika blockomfång. Alla variablerna är tillgängliga i hela funktionen.
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"]);
En intressant konsekvens av att det inte finns något blocknivåomfång är att du kan läsa eller skriva till en variabel innan den är deklarerad, förutsatt att den deklareras innan funktionen avslutas. Detta tack vare en teknik som kallas hoisting, som innebär att kompilatorn flyttar alla variabeldeklarationer till funktionens översta nivå. Följande kod kompileras till exempel även om den initiala funktionen trace() för variabeln num inträffar innan variabeln num har deklarerats:
trace(num); // NaN
var num:Number = 10;
trace(num); // 10
Kompilatorn lyfter inte några tilldelningsprogramsatser. Detta förklarar varför den initiala funktionen trace() för num resulterar i NaN (not a number), vilket är standardvärdet för variabler för datatypen Number. Detta betyder att du kan tilldela variabler värden även innan de har deklarerats, vilket visas i följande exempel:
num = 5;
trace(num); // 5
var num:Number = 10;
trace(num); // 10
