Variables

Les variables vous permettent de stocker des valeurs que vous utilisez dans votre programme. Pour déclarer une variable, vous devez utiliser l’instruction var avec le nom de variable. Dans ActionScript 3.0, l’utilisation de l’instruction var est obligatoire. Par exemple, la ligne d’ActionScript suivante déclare une variable appelée i :

var i;

Si vous omettez l’instruction var lors de la déclaration d’une variable, vous obtenez une erreur de compilateur en mode strict et une erreur d’exécution en mode standard. Par exemple, la ligne de code suivante provoque une erreur si la variable i n’a pas été définie précédemment :

i; // error if i was not previously defined

Vous devez associer une variable à un type de données lorsque vous déclarez la variable. La déclaration d’une variable sans désigner son type est autorisée mais provoque un avertissement du compilateur en mode strict. Vous désignez le type d’une variable en ajoutant le nom de variable avec deux-points (:), suivi par le type de variable. Par exemple, le code suivant déclare une variable i de type int :

var i:int;

Vous pouvez affecter une valeur à une variable à l’aide de l’opérateur d’affectation (=). Par exemple, le code suivant déclare une variable i et lui affecte la valeur 20 :

var i:int; 
i = 20;

Il peut être plus pratique d’affecter une valeur à une variable au moment où vous déclarez cette dernière, comme dans l’exemple suivant :

var i:int = 20;

La technique d’affectation d’une valeur à une variable au moment de sa déclaration est couramment utilisée non seulement lors de l’affectation de valeurs primitives (nombres entiers et chaînes) mais également lors de la création d’un tableau ou de l’instanciation de l’occurrence d’une classe. L’exemple suivant illustre un tableau déclaré auquel est affectée une valeur à l’aide d’une ligne de code.

var numArray:Array = ["zero", "one", "two"];

Vous pouvez créer une occurrence d’une classe à l’aide de l’opérateur new. L’exemple suivant crée une occurrence d’une classe appelée CustomClass et affecte une référence à l’occurrence de classe nouvellement créée sur la variable appelée customItem :

var customItem:CustomClass = new CustomClass();

Si vous avez plusieurs variables à déclarer, vous pouvez le faire sur une ligne de code à l’aide de l’opérateur virgule (,) pour séparer les variables. Par exemple, le code suivant déclare trois variables sur une ligne de code :

var a:int, b:int, c:int;

Vous pouvez également affecter des valeurs à chacune des variables sur une même ligne de code. Par exemple, le code suivant déclare trois variables (a, b, et c) et affecte une valeur à chacune d’entre elles :

var a:int = 10, b:int = 20, c:int = 30;

Bien que vous puissiez utiliser l’opérateur virgule pour regrouper des déclarations de variable dans une instruction, ceci risque de rendre votre code moins lisible.

Présentation du domaine d’une variable

Le domaine d’une variable est la partie de votre code dans laquelle une référence lexicale peut accéder à la variable. Une variable globale est une variable définie dans toutes les parties de votre code, alors qu’une variable locale est une variable définie dans une seule partie de votre code. Dans ActionScript 3.0, le domaine des variables est toujours limité à la fonction ou à la classe dans laquelle elles sont déclarées. Une variable globale est une variable que vous définissez en dehors de toute définition de classe ou de fonction. Par exemple, le code suivant crée une variable globale strGlobal en la déclarant en dehors de toute fonction. L’exemple indique qu’une variable globale est disponible à la fois à l’intérieur et à l’extérieur de la définition de fonction.

var strGlobal:String = "Global"; 
function scopeTest() 
{ 
    trace(strGlobal); // Global 
} 
scopeTest(); 
trace(strGlobal); // Global

Vous déclarez une variable locale en déclarant la variable à l’intérieur d’une définition de fonction. La plus petite partie de code pour laquelle vous pouvez définir une variable locale est une définition de fonction. Une variable locale déclarée dans une fonction existe uniquement dans celle-ci. Par exemple, si vous déclarez une variable appelée str2 dans la fonction localScope(), cette variable n’est pas disponible en dehors de la fonction.

function localScope() 
{ 
    var strLocal:String = "local"; 
} 
localScope(); 
trace(strLocal); // error because strLocal is not defined globally

Si le nom attribué à votre variable locale est déjà déclaré en tant que variable globale, la définition locale masque la définition globale tant que la variable locale est dans le domaine. La variable globale persiste en dehors de la fonction. Par exemple, le code suivant crée une variable globale de type chaîne appelée str1, puis une variable locale du même nom dans la fonction scopeTest(). L’instruction trace placée dans la fonction génère la valeur locale de la variable, tandis que celle qui est placée en dehors de la fonction génère la valeur globale de la variable.

var str1:String = "Global"; 
function scopeTest () 
{ 
    var str1:String = "Local"; 
    trace(str1); // Local 
} 
scopeTest(); 
trace(str1); // Global

Les variables ActionScript, contrairement aux variables dans C++ et Java, n’ont pas de domaine de niveau bloc. Un bloc de code est un groupe d’instructions placé entre une accolade d’ouverture ( { ) et une accolade de fermeture (}). Dans certains langages de programmation tels que C++ et Java, les variables déclarées dans un bloc de code ne sont pas disponibles en dehors de ce bloc de code. Cette restriction de domaine est appelée domaine de niveau bloc et n’existe pas dans ActionScript. Si vous déclarez une variable à l’intérieur d’un bloc de code, elle est disponible non seulement dans celui-ci mais également dans d’autres parties de la fonction à laquelle il appartient. Par exemple, la fonction suivante contient des variables définies dans différents domaines de bloc. Toutes les variables sont disponibles dans la fonction.

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"]);

Une implication intéressante de l’absence de domaine de niveau bloc est que vous pouvez lire ou écrire dans une variable avant de la déclarer, tant qu’elle est déclarée avant que la fonction se termine. Ceci est dû à une technique appelée hissage, qui signifie que le compilateur déplace toutes les déclarations de variable en haut de la fonction. Par exemple, le code suivant compile même si la fonction trace() initiale pour la variable num se produit avant la déclaration de la variable num :

trace(num); // NaN 
var num:Number = 10; 
trace(num); // 10

Néanmoins, le compilateur ne hisse aucune instruction d’affectation. Ceci explique pourquoi la fonction trace() initiale de num fournit NaN (pas un nombre), qui est la valeur par défaut pour des variables du type de données Number. Cela signifie que vous pouvez affecter des valeurs à des variables même avant leur déclaration, comme indiqué dans l’exemple suivant :

num = 5; 
trace(num); // 5 
var num:Number = 10; 
trace(num); // 10

Valeurs par défaut

Une valeur par défaut est le contenu d’une variable avant que vous définissiez sa valeur. Vous initialisez une variable lorsque vous lui affectez sa première valeur. Si vous déclarez une variable sans définir sa valeur, cette variable est non initialisée. La valeur d’une variable non initialisée dépend de son type de données. Le tableau suivant décrit les valeurs par défaut des variables, organisées par type de données :

Type de données

Valeur par défaut

Boolean

false

int

0

Number

NaN

Object

null

String

null

uint

0

Non déclaré (équivalent à l’annotation de type *)

undefined

Toutes les autres classes, y compris celles définies par l’utilisateur

null

Pour les variables de type Number, la valeur par défaut est NaN (pas un nombre), qui est une valeur spéciale définie par la norme IEEE-754 pour indiquer une valeur qui ne représente pas un nombre.

Si vous déclarez une variable mais pas son type de données, le type de données par défaut * lui est attribué, ce qui signifie qu’elle n’est pas typée. Si vous n’initialisez pas non plus de variable non typée avec une valeur, sa valeur par défaut est undefined.

Pour les types de données autres que Boolean, Number, int, et uint, la valeur par défaut d’une variable non initialisée est null. Ceci s’applique à toutes les classes définies par ActionScript 3.0, ainsi qu’aux classes personnalisées que vous créez.

La valeur null n’est pas une valeur valide pour des variables de type Boolean, Number, int ou uint. Si vous tentez d’affecter la valeur null à une telle variable, la valeur est convertie en la valeur par défaut pour ce type de données. Pour les variables de type Object, vous pouvez affecter une valeur null. Si vous tentez d’affecter la valeur undefined à une variable de type Object, la valeur est convertie en null.

Pour les variables de type Number, il existe une fonction de niveau supérieur spéciale appelée isNaN() qui renvoie la valeur Boolean true si la variable n’est pas un nombre, et false autrement.