La vérification des types lors de la compilation est souvent favorisée dans les projets plus importants car au fur et à mesure que la taille du projet augmente, la flexibilité du type de données devient généralement moins importante que la capture d’erreurs de type aussitôt que possible. C’est pourquoi le compilateur d’ActionScript dans Flash Professional et dans Flash Builder est exécuté en mode strict, par défaut.

Pour que la vérification des types soit exécutée lors de la compilation, le compilateur doit connaître les informations de type de données des variables ou expressions que contient votre code. Pour déclarer explicitement un type de données pour une variable, ajoutez l’opérateur deux points (:) suivi du type de données comme suffixe du nom de variable. Pour associer un type de données à un paramètre, utilisez l’opérateur deux points suivi du type de données. Par exemple, le code suivant ajoute des informations de type de données au paramètre xParam, et déclare une variable myParam avec un type de données explicite :

function runtimeTest(xParam:String) 
{ 
    trace(xParam); 
} 
var myParam:String = "hello"; 
runtimeTest(myParam);

En mode strict, le compilateur d’ActionScript signale des incompatibilités de type comme erreurs de compilateur. Par exemple, le code suivant déclare un paramètre de fonction xParam, de type Object, mais tente ensuite d’affecter des valeurs de type String et Number à ce paramètre. Ceci produit une erreur de compilateur en mode strict.

function dynamicTest(xParam:Object) 
{ 
    if (xParam is String) 
    { 
        var myStr:String = xParam; // compiler error in strict mode 
        trace("String: " + myStr); 
    } 
    else if (xParam is Number) 
    { 
        var myNum:Number = xParam; // compiler error in strict mode 
        trace("Number: " + myNum); 
    } 
}

Même en mode strict, cependant, vous pouvez choisir d’abandonner la vérification des types lors de la compilation en laissant la partie droite d’une instruction d’affectation non typée. Vous pouvez marquer une variable ou une expression comme non typée soit en omettant une annotation de type, soit à l’aide de l’annotation de type astérisque (*) spéciale. Par exemple, si le paramètre xParam de l’exemple précédent est modifié de façon à ne plus avoir d’annotation de type, la compilation s’effectue en mode strict :

function dynamicTest(xParam) 
{ 
    if (xParam is String) 
    { 
        var myStr:String = xParam; 
        trace("String: " + myStr); 
    } 
    else if (xParam is Number) 
    { 
        var myNum:Number = xParam; 
        trace("Number: " + myNum); 
    } 
} 
dynamicTest(100) 
dynamicTest("one hundred");

La vérification des types lors de l’exécution s’applique dans ActionScript 3.0 quel que soit le mode, strict ou standard. Imaginez que la valeur 3 est transmise en tant qu’argument à une fonction qui attend un tableau. En mode strict, le compilateur génère une erreur car la valeur 3 n’est pas compatible avec le type de données Array. Si vous désactivez le mode strict et utilisez le mode standard, le compilateur ne signale pas l’incompatibilité de type, mais la vérification des types lors de l’exécution provoque une erreur d’exécution.

L’exemple suivant présente une fonction appelée typeTest() qui attend une instruction Array mais qui reçoit une valeur de 3. Ceci provoque une erreur d’exécution en mode standard car la valeur 3 n’est pas un membre du type de données déclaré (Array) du paramètre.

function typeTest(xParam:Array) 
{ 
    trace(xParam); 
} 
var myNum:Number = 3; 
typeTest(myNum);  
// run-time error in ActionScript 3.0 standard mode

Il se peut également que vous obteniez une erreur de type lors de l’exécution alors que vous êtes en mode strict. Ceci est possible si vous utilisez le mode strict mais que vous abandonnez la vérification des types lors de la compilation à l’aide d’une variable non typée. Lorsque vous utilisez une variable non typée, vous n’éliminez pas la vérification des types mais la remettez à plus tard, au moment de l’exécution. Par exemple, si le type de données de la variable myNum de l’exemple précédent n’est pas déclaré, le compilateur ne peut pas détecter l’incompatibilité de type, mais le code génère une erreur d’exécution car il compare la valeur d’exécution de myNum (définie sur 3 en raison de l’instruction d’affectation) avec le type de xParam (défini sur Array).

function typeTest(xParam:Array) 
{ 
    trace(xParam); 
} 
var myNum = 3; 
typeTest(myNum);  
// run-time error in ActionScript 3.0

La vérification des types lors de l’exécution permet également d’utiliser l’héritage avec davantage de souplesse que la vérification lors de la compilation. En remettant la vérification des types au moment de l’exécution, le mode standard vous permet de référencer des propriétés d’une sous-classe même si vous effectuez un upcast. Un upcast a lieu lorsque vous utilisez une classe de base pour déclarer le type d’une occurrence de classe mais une sous-classe pour l’instancier. Par exemple, vous pouvez créer une classe appelée ClassBase qui peut être étendue (les classes avec l’attribut final ne peuvent pas être étendues) :

class ClassBase 
{ 
}

Vous pouvez ensuite créer une sous-classe de ClassBase appelée ClassExtender, qui possède une propriété appelée someString, comme suit :

class ClassExtender extends ClassBase 
{ 
    var someString:String; 
}

Vous pouvez utiliser les deux classes pour créer une occurrence de classe déclarée à l’aide du type de données ClassBase mais instanciée avec le constructeur ClassExtender. Un upcast est considéré comme une opération sûre car la classe de base ne contient aucune propriété ni méthode ne se trouvant pas dans la sous-classe.

var myClass:ClassBase = new ClassExtender();

Une sous-classe, néanmoins, contient des propriétés et des méthodes que sa classe de base ne contient pas. Par exemple, la classe ClassExtender contient la propriété someString qui n’existe pas dans la classe ClassBase. Dans ActionScript 3.0 en mode standard, vous pouvez référencer cette propriété à l’aide de l’occurrence myClass sans générer d’erreur d’exécution, comme indiqué dans l’exemple suivant :

var myClass:ClassBase = new ClassExtender(); 
myClass.someString = "hello"; 
// no error in ActionScript 3.0 standard mode

L’opérateur is permet de tester si une variable ou une expression est membre d’un type de données. Dans les versions précédentes d’ActionScript, l’opérateur instanceof offrait cette fonctionnalité, mais dans ActionScript 3.0, l’opérateur instanceof ne doit pas être utilisé pour tester l’appartenance à un type de données. L’opérateur is doit être utilisé à la place de l’opérateur instanceof pour la vérification des types manuelle car l’expression x instanceof y vérifie simplement la chaîne de prototype de x pour voir si y existe (et dans ActionScript 3.0, la chaîne de prototype ne donne pas une image complète de la hiérarchie d’héritage).

L’opérateur is examine sa hiérarchie d’héritage et peut être utilisé pour vérifier non seulement si un objet est une occurrence d’une classe particulière mais également si un objet est une occurrence d’une classe qui implémente une interface particulière. L’exemple suivant crée une occurrence de la classe Sprite appelée mySprite et utilise l’opérateur is pour tester si mySprite est une occurrence des classes Sprite et DisplayObject, et si elle implémente l’interface IEventDispatcher :

var mySprite:Sprite = new Sprite(); 
trace(mySprite is Sprite); // true 
trace(mySprite is DisplayObject);// true 
trace(mySprite is IEventDispatcher); // true

L’opérateur is vérifie la hiérarchie d’héritage et signale correctement que mySprite est compatible avec les classes Sprite et DisplayObject (la classe Sprite est une sous-classe de la classe DisplayObject). L’opérateur is vérifie également si mySprite hérite d’une classe qui implémente l’interface IEventDispatcher. Etant donné que la classe Sprite hérite de la classe EventDispatcher, qui implémente l’interface IEventDispatcher, l’opérateur is signale correctement que mySprite implémente la même interface.

L’exemple suivant présente les mêmes tests que l’exemple précédent, mais avec instanceof au lieu de l’opérateur is. L’opérateur instanceof identifie correctement que mySprite est une occurrence de Sprite ou de DisplayObject, mais il renvoie false lorsqu’il est utilisé pour tester si mySprite implémente l’interface IEventDispatcher.

trace(mySprite instanceof Sprite); // true 
trace(mySprite instanceof DisplayObject);// true 
trace(mySprite instanceof IEventDispatcher); // false

L’opérateur as permet également de vérifier si une expression est membre d’un type de données. Contrairement à l’opérateur is, cependant, l’opérateur as ne renvoie pas de valeur booléenne. L’opérateur as renvoie la valeur de l’expression au lieu de true, et null au lieu de false. L’exemple suivant indique les résultats obtenus si vous utilisez l’opérateur as au lieu de l’opérateur is pour vérifier simplement si une occurrence de Sprite appartient aux types de données DisplayObject, IEventDispatcher et Number.

var mySprite:Sprite = new Sprite(); 
trace(mySprite as Sprite);                 // [object Sprite] 
trace(mySprite as DisplayObject);                 // [object Sprite] 
trace(mySprite as IEventDispatcher);                 // [object Sprite] 
trace(mySprite as Number);                                       // null

Lorsque vous utilisez l’opérateur as, l’opérande à droite doit être un type de données. Vous obtenez une erreur si vous tentez d’utiliser une expression autre qu’un type de données comme opérande à droite.

Le type de données Boolean comporte deux valeurs : true et false. Les variables du type booléen ne prennent en charge aucune autre valeur. La valeur par défaut d’une variable booléenne qui a été déclarée mais non initialisée est false.

Le type de données int est stocké en interne en tant que nombre entier 32 bits et comprend l’ensemble des entiers allant de

-2 147 483 648 (-2³¹) à 2 147 483 647 (2³¹ - 1), inclus. Les versions précédentes d’ActionScript offraient uniquement le type de données Number, qui était utilisé à la fois pour les nombres entiers et les nombres en virgule flottante. Dans ActionScript 3.0, vous avez maintenant accès à des types machine de bas niveau pour les nombres entiers 32 bits signés et non signés. Si la variable ne doit pas utiliser de nombres en virgule flottante, il est plus rapide et efficace d’utiliser le type de données int plutôt que le type de données Number.

Pour les valeurs entières en dehors de la plage des valeurs int minimum et maximum, utilisez le type de données Number, qui peut gérer des valeurs positives et négatives 9 007 199 254 740 992 (valeurs entières 53 bits). La valeur par défaut pour des variables du type de données int est 0.

Le type de données Null contient une seule valeur, null. Il s’agit de la valeur par défaut pour le type de données String et toutes les classes qui définissent des types de données complexes, y compris la classe Object. Aucun des autres types de données primitifs (Boolean, Number, int et uint) ne contient la valeur null. A l’exécution, la valeur null est convertie en la valeur par défaut appropriée si vous tentez d’affecter null à des variables de type Boolean, Number, int ou uint. Vous ne pouvez pas utiliser ce type de donnés comme annotation de type.

Dans ActionScript 3.0, le type de données Number peut représenter des entiers, des entiers non signés et des nombres en virgule flottante. Néanmoins, pour optimiser les performances, utilisez le type de données Number uniquement pour des valeurs entières supérieures à ce que les types int et uint 32 bits peuvent stocker ou pour des nombres en virgule flottante. Pour stocker un nombre en virgule flottante, vous devez y insérer une virgule. Si vous omettez la virgule, le nombre est stocké comme nombre entier.

Le type de données Number utilise le format à deux décimales (64 bits) conformément à la norme IEEE 754. Cette norme dicte comment les nombres en virgule flottante sont stockés à l’aide des 64 bits disponibles. Un bit est utilisé pour désigner si le nombre est positif ou négatif. Onze bits sont utilisés pour l’exposant, qui est stocké comme base 2. Les 52 bits restants sont utilisés pour stocker le significande (également appelé mantisse), qui correspond au nombre élevé à la puissance indiqué par l’exposant.

En utilisant certains de ses bits pour stocker un exposant, le type de données Number peut stocker des nombres en virgule flottante beaucoup plus grands que s’il utilisait tous ses bits pour le significande. Par exemple, si le type de données Number utilisait les 64 bits pour stocker le significande, il pourrait stocker un nombre aussi grand que 2⁶⁵ - 1. En utilisant 11 bits pour stocker un exposant, le type de données Number peut élever son significande à une puissance de 2¹⁰²³.

Les valeurs maximum et minimum que le type Number peut représenter sont stockées dans des propriétés statiques de la classe Number appelées Number.MAX_VALUE et Number.MIN_VALUE.

Number.MAX_VALUE == 1.79769313486231e+308 
Number.MIN_VALUE == 4.940656458412467e-324

Bien que cette plage de nombres soit énorme, elle est d’une grande précision. Le type de données Number utilise 52 bits pour stocker le significande. Par conséquent, les nombres nécessitant plus de 52 bits pour une représentation précise (la fraction 1/3, par exemple) ne sont que des approximations. Si votre application exige une précision absolue avec des nombres décimaux, vous devez utiliser le logiciel qui implémente l’arithmétique flottante décimale plutôt que l’arithmétique flottante binaire.

Lorsque vous stockez des valeurs entières avec le type de données Number, seuls les 52 bits du significande sont utilisés. Le type de données Number utilise ces 52 bits et un bit masqué spécial pour représenter des nombres entiers de -9 007 199 254 740 992 (-2⁵³) à 9 007 199 254 740 992 (2⁵³).

La valeur NaNest utilisée non seulement comme valeur par défaut pour des variables de type Number, mais également comme résultat de toute opération devant renvoyer un nombre mais ne le faisant pas. Par exemple, si vous tentez de calculer la racine carrée d’un nombre négatif, le résultat est NaN. D’autres valeurs Number spéciales comprennent l’infini positif et l’infini négatif.

Le type de données String représente une séquence de caractères 16 bits. Les chaînes sont stockées en interne sous forme de caractères Unicode, au format UTF-16. Les chaînes sont des valeurs inaltérables, comme dans le langage de programmation Java. Toute opération effectuée sur une valeur String renvoie une nouvelle occurrence de la chaîne. La valeur par défaut d’une variable déclarée avec le type de données String est null. La valeur null n’est pas identique à la chaîne vide (""). Elle signifie qu’aucune valeur n’est stockée dans la variable, alors que la chaîne vide indique que la valeur de la variable est une chaîne ne contenant pas de caractères.

Le type de données uint est stocké en interne sous la forme d’un entier 32 bits non signé et est constitué de l’ensemble d’entiers compris entre 0 et 4 294 967 295 (2³²-1), inclus. Utilisez le type de données uint dans des situations spéciales nécessitant des entiers non négatifs. Par exemple, vous devez utiliser le type de données uint pour représenter les valeurs de couleur des pixels car le type de données int a un bit de signe interne non approprié pour la gestion des valeurs de couleur. Pour les valeurs d’entiers supérieures à la valeur uint maximale, utilisez le type de données Number qui peut gérer des valeurs d’entiers 53 bits. La valeur par défaut pour des variables du type de données uint est 0.

Le type de données void contient une seule valeur, undefined. Dans les versions précédentes d’ActionScript, undefined était la valeur par défaut des occurrences de la classe Object. Dans ActionScript 3.0, la valeur par défaut des occurrences Object est null. Si vous tentez d’affecter la valeur undefined à une occurrence de la classe Object, la valeur est convertie en null. Vous pouvez affecter uniquement une valeur de undefined à des variables non typées. Les variables non typées sont des variables dépourvues de toute annotation de type, ou qui utilisent l’astérisque (*) pour l’annotation de type. Vous pouvez utiliser void uniquement comme annotation de type renvoyé.

Ce type de données est défini par la classe Object. La classe Object sert de classe de base pour toutes les définitions de classe dans ActionScript. La version d’ActionScript 3.0 du type de données Object diffère de celle des versions précédentes de trois façons. Premièrement, le type de données Object n’est plus le type de données par défaut affecté aux variables sans annotation de type. Deuxièmement, le type de données Object ne comprend plus la valeur undefined, qui était la valeur par défaut des occurrences Object. Troisièmement, dans ActionScript 3.0, la valeur par défaut des occurrences de la classe Object est null.

Dans les versions précédentes d’ActionScript, une variable sans annotation de type était affectée automatiquement au type de données Object. Ceci n’est plus valable dans ActionScript 3.0, qui inclut maintenant la notion de variable parfaitement non typée. Les variables sans annotation de type sont désormais considérées comme non typées. Si vous souhaitez faire comprendre aux lecteurs de votre code que vous souhaitez laisser une variable non typée, vous pouvez utiliser l’astérisque (*) pour l’annotation de type, ce qui revient à omettre celle-ci. L’exemple suivant présente deux instructions équivalentes qui déclarent une variable non typée x :

var x 
var x:*

Seules les variables non typées peuvent contenir la valeur undefined. Si vous tentez d’affecter la valeur undefined à une variable ayant un type de données, le moteur d’exécution convertit la valeur undefined en la valeur par défaut pour ce type de données. Pour des occurrences du type de données Object, la valeur par défaut est null ; autrement dit, si vous tentez d’affecter la valeur undefined à une occurrence d’Object, la valeur est convertie en null.