Variables -- Flash CS3

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 2.0, l'utilisation de l'instruction var est nécessaire uniquement si vous utilisez des annotations de type. Dans ActionScript 3.0, l'utilisation de l'instruction var est toujours nécessaire. 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; // erreur si i n'a pas été définie précédemment

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'instance d'une classe. L'exemple suivant illustre un tableau déclaré auquel est affecté une valeur à l'aide d'une ligne de code.

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

Vous pouvez créer une instance d'une classe à l'aide de l'opérateur new. L'exemple suivant crée une instance d'une classe appelée CustomClass, et affecte une référence à l'instance 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 valeurs sur la 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.

Sous-rubriques

Présentation du domaine de 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); // Globale
}
scopeTest();
trace(strGlobal); // Globale

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 cette fonction. Par exemple, si vous déclarez une variable nommée str2 dans une fonction appelée localScope(), cette variable ne sera pas disponible en dehors de cette fonction.

function localScope()
{
    var strLocal:String = "local";
}
localScope();
trace(strLocal); // erreur car strLocal n'est pas définie globalement

Si le nom utilisé pour votre variable locale est déjà déclaré en tant que variable globale, la définition locale masque la définition globale alors 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); // Locale
}
scopeTest();
trace(str1); // Globale

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 ce bloc de code mais également dans d'autres parties de la fonction à laquelle le bloc de code 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);   // toutes toujours définies
    }
    trace(elemStr, valueStr, i); // toutes définies si 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 sans déclarer son type de données, le type de données par défaut * s'applique, ce qui signifie que la variable 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 l'API de Flash Player, 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 une valeur null à une telle variable, la valeur est convertie à 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.