Types de données

Un type de données définit un ensemble de valeurs. Par exemple, le type de données Boolean est l’ensemble de deux valeurs exactement : true et false . Outre le type de données Boolean, ActionScript 3.0 définit plusieurs autres types de données couramment utilisés tels que String, Number et Array. Vous pouvez définir vos types de donnés en utilisant des classes ou des interfaces afin de définir un ensemble de valeurs personnalisé. Toutes les valeurs dans ActionScript 3.0, qu’elles soient primitives ou complexes , sont des objets.

Une valeur primitive est une valeur appartenant à l’un des types de données suivants : Boolean, int, Number, String et uint. L’utilisation de valeurs primitives est généralement plus rapide que l’utilisation de valeurs complexes car ActionScript stocke les valeurs primitives de façon à permettre des optimisations de vitesse et de mémoire.

Remarque : pour les lecteurs intéressés par les détails techniques, ActionScript stocke les valeurs primitives en tant qu’objets inaltérables. Le fait qu’elles soient stockées en tant qu’objets inaltérables signifie que le transfert par référence est identique au transfert par valeur. Ceci réduit l’utilisation de la mémoire et augmente la vitesse d’exécution car les références sont généralement beaucoup plus petites que les valeurs elles-mêmes.

Une valeur complexe est une valeur qui n’est pas une valeur primitive. Les types de données qui définissent des ensembles de valeurs complexes comprennent Array, Date, Error, Function, RegExp, XML et XMLList.

De nombreux langages de programmation font la distinction entre les valeurs primitives et leurs enveloppes. Java, par exemple, a une valeur primitive int et la classe java.lang.Integer qui l’enveloppe. Les valeurs primitives de Java ne sont pas des objets, mais leurs enveloppes le sont, ce qui rend les valeurs primitives utiles pour certaines opérations et les enveloppes pour d’autres. Dans ActionScript 3.0, les valeurs primitives et leurs enveloppes ne peuvent être distinguées, à des fins pratiques. Toutes les valeurs, même les valeurs primitives, sont des objets. Le moteur d’exécution traite ces types primitifs comme des cas spéciaux qui se comportent comme des objets n’exigeant pas le temps normal associé à la création d’objets. Cela signifie que les deux lignes de code suivantes sont équivalentes :

var someInt:int = 3; 
var someInt:int = new int(3);

Tous les types de données primitifs et complexes répertoriés ci-dessus sont définis par les classes de base d’ActionScript 3.0. Les classes de base vous permettent de créer des objets à l’aide de valeurs littérales au lieu d’utiliser l’opérateur new . Par exemple, vous pouvez créer un tableau à l’aide d’une valeur littérale ou du constructeur de classe Array, comme suit :

var someArray:Array = [1, 2, 3]; // literal value 
var someArray:Array = new Array(1,2,3); // Array constructor

Vérification des types

La vérification des types peut être effectuée lors de la compilation ou de l’exécution. Les langages typés statiquement (C++ et Java, par exemple) effectuent la vérification des types lors de la compilation. Les langages typés dynamiquement (Smalltalk et Python, par exemple) effectuent la vérification des types lors de l’exécution. En tant que langage typé dynamiquement, ActionScript 3.0 effectue la vérification des types lors de l’exécution mais également lors de la compilation, avec un mode de compilateur spécial appelé mode strict . En mode strict, la vérification des types a lieu à la fois lors de la compilation et de l’exécution, mais en mode standard, elle a lieu lors de l’exécution.

Les langages typés dynamiquement vous permettent de structurer votre code avec une grande souplesse, mais des erreurs de type risquent de se produire lors de l’exécution. Les langages typés statiquement signalent des erreurs de type lors de la compilation mais des informations de type sont requises à ce moment-là.

Vérification des types lors de la compilation

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.

Adobe Flash Builder

Vous pouvez désactiver le mode strict dans Flash Builder par le biais des paramètres du compilateur d’ActionScript dans la boîte de dialogue Project Properties.

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

Vérification des types lors de l’exécution

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

Opérateur is

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

Opérateur as

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.

Classes dynamiques

Une classe dynamique définit un objet qui peut être modifié lors de l’exécution en ajoutant ou en modifiant des propriétés et des méthodes. Une classe qui n’est pas dynamique (la classe String, par exemple), est une classe scellée . Vous ne pouvez pas ajouter de propriétés ni de méthodes à une classe scellée lors de l’exécution.

Vous créez des classes dynamiques en utilisant l’attribut dynamic lorsque vous déclarez une classe. Par exemple, le code suivant crée une classe dynamique appelée Protean :

dynamic class Protean 
{ 
    private var privateGreeting:String = "hi"; 
    public var publicGreeting:String = "hello"; 
    function Protean() 
    { 
        trace("Protean instance created"); 
    } 
}

Si vous instanciez ensuite une occurrence de la classe Protean , vous pouvez lui ajouter des propriétés ou des méthodes en dehors de la définition de classe. Par exemple, le code suivant crée une occurrence de la classe Protean et lui ajoute une propriété appelée aString et une autre appelée aNumber :

var myProtean:Protean = new Protean(); 
myProtean.aString = "testing"; 
myProtean.aNumber = 3; 
trace(myProtean.aString, myProtean.aNumber); // testing 3

Les propriétés que vous ajoutez à une occurrence d’une classe dynamique sont des entités d’exécution. Par conséquent, toute vérification des types est effectuée lors de l’exécution. Vous ne pouvez pas ajouter une annotation de type à une propriété que vous ajoutez de cette façon.

Vous pouvez également ajouter une méthode à l’occurrence myProtean en définissant une fonction et en l’associant à une propriété de l’occurrence myProtean . Le code suivant déplace l’instruction trace dans une méthode appelée traceProtean() :

var myProtean:Protean = new Protean(); 
myProtean.aString = "testing"; 
myProtean.aNumber = 3; 
myProtean.traceProtean = function () 
{ 
    trace(this.aString, this.aNumber); 
}; 
myProtean.traceProtean(); // testing 3

Cependant, les méthodes créées de cette manière n’ont pas accès à des méthodes ou à des propriétés privées de la classe Protean. De plus, même les références à des méthodes ou à des propriétés publiques de la classe Protean doivent être qualifiées avec le mot-clé this ou le nom de classe. L’exemple suivant présente la méthode traceProtean() tentant d’accéder aux variables privées et publiques de la classe Protean .

myProtean.traceProtean = function () 
{ 
    trace(myProtean.privateGreeting); // undefined 
    trace(myProtean.publicGreeting); // hello 
}; 
myProtean.traceProtean();

Descriptions des types de données

Les types de données primitifs peuvent être Boolean, int, Null, Number, String, uint et void. Les classes de base d’ActionScript définissent également les types de données complexes suivants : Object, Array, Date, Error, Function, RegExp, XML et XMLList.

Type de données Boolean

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 .

Type de données int

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 31 ) à 2 147 483 647 (2 31 - 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.

Type de données Null

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.

Type de données Number

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 65 - 1. En utilisant 11 bits pour stocker un exposant, le type de données Number peut élever son significande à une puissance de 2 1023 .

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 53 ) à 9 007 199 254 740 992 (2 53 ).

La valeur NaN est 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 .

Remarque : le résultat de la division par 0 n’est NaN que si le diviseur est également 0 . La division par 0 produit infinity lorsque le dividende est positif ou -infinity lorsqu’il est négatif.

Type de données String

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.

Type de données uint

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 32 -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.

Type de données Void

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é.

Type de données Object

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 .

Conversions de type

Une conversion de type a lieu lorsqu’une valeur est transformée en une valeur d’un type de données différent. Les conversions de type peuvent être implicites ou explicites . Les conversions implicites (ou coercition ) sont parfois effectuées lors de l’exécution. Par exemple, si la valeur 2 est affectée à une variable du type de données Boolean, elle est convertie en la valeur booléenne true avant son affectation. Les conversions explicites (ou association ) ont lieu lorsque votre code demande au compilateur de traiter une variable d’un type de données comme si elle appartenait à un type de données différent. Lorsque des valeurs primitives sont impliquées, l’association convertit les valeurs d’un type de données en un autre. Pour associer un objet à un autre type de données, vous mettez le nom de l’objet entre parenthèses et le faites précéder du nom du nouveau type. Par exemple, le code suivant prend une valeur booléenne et la transforme en entier numérique :

var myBoolean:Boolean = true; 
var myINT:int = int(myBoolean); 
trace(myINT); // 1

Conversions implicites

Les conversions implicites ont lieu lors de l’exécution dans plusieurs contextes :

  • Dans des instructions d’affectation

  • Lorsque des valeurs sont transmises en tant qu’arguments de fonction

  • Lorsque des valeurs sont renvoyées à partir de fonctions

  • Dans les expressions utilisant certains opérateurs tels que l’opérateur d’addition ( + )

    Pour les types définis par l’utilisateur, les conversions implicites ont lieu lorsque la valeur à convertir est une occurrence de la classe de destination ou d’une classe qui dérive de cette dernière. En cas d’échec de la conversion implicite, une erreur se produit. Par exemple, le code suivant contient une conversion implicite ayant réussi et une conversion implicite ayant échoué:

    class A {} 
    class B extends A {} 
     
    var objA:A = new A(); 
    var objB:B = new B(); 
    var arr:Array = new Array(); 
     
    objA = objB; // Conversion succeeds. 
    objB = arr; // Conversion fails.

    Pour les types primitifs, les conversions implicites sont gérées par appel des algorithmes de conversion internes appelés par les fonctions de conversion explicite.

Conversions explicites

Les conversions explicites, ou association, sont utiles lorsque vous compilez en mode strict et que vous ne souhaitez pas qu’une incompatibilité de types génère une erreur de compilation. Ceci peut se produire lorsque vous savez que la coercition convertira vos valeurs correctement lors de l’exécution. Par exemple, lorsque vous utilisez des données reçues d’un formulaire, vous pouvez utiliser la coercition pour convertir certaines valeurs de chaîne en valeurs numériques. Le code suivant génère une erreur de compilation même si le code s’exécute correctement en mode standard :

var quantityField:String = "3"; 
var quantity:int = quantityField; // compile time error in strict mode

Si vous souhaitez continuer à utiliser le mode strict, mais que vous souhaitez que la chaîne soit convertie en nombre entier, vous pouvez utiliser la conversion explicite, comme suit :

var quantityField:String = "3"; 
var quantity:int = int(quantityField); // Explicit conversion succeeds.

Association à int, uint et Number

Vous pouvez associer tout type de données à l’un des trois types de nombre suivants : int, uint et Number. Si, pour une raison quelconque, la conversion du nombre est impossible, la valeur par défaut 0 est affectée pour les types de données int et uint, et la valeur par défaut NaN est affectée pour le type de données Number. Si vous convertissez une valeur booléenne en un nombre, true devient la valeur 1 et false devient la valeur 0.

var myBoolean:Boolean = true; 
var myUINT:uint = uint(myBoolean); 
var myINT:int = int(myBoolean); 
var myNum:Number = Number(myBoolean); 
trace(myUINT, myINT, myNum); // 1 1 1 
myBoolean = false; 
myUINT = uint(myBoolean); 
myINT = int(myBoolean); 
myNum = Number(myBoolean); 
trace(myUINT, myINT, myNum); // 0 0 0

Les valeurs de chaîne qui contiennent des chiffres uniquement peuvent être converties en l’un des types de nombre. Les types de nombre peuvent également convertir des chaînes ressemblant à des nombres négatifs ou des chaînes représentant une valeur hexadécimale (par exemple, 0x1A ). Le processus de conversion ignore les espaces blancs à gauche ou à droite dans la valeur de chaîne. Vous pouvez également associer des chaînes qui ressemblent à des nombres en virgule flottante à l’aide de Number() . Le fait d’inclure une virgule fait que uint() et int() renvoient un entier avec les caractères suivant la virgule ayant été tronqués. Par exemple, les valeurs de chaîne suivantes peuvent être associées à des nombres :

trace(uint("5")); // 5 
trace(uint("-5")); // 4294967291. It wraps around from MAX_VALUE 
trace(uint(" 27 ")); // 27 
trace(uint("3.7")); // 3 
trace(int("3.7")); // 3 
trace(int("0x1A")); // 26 
trace(Number("3.7")); // 3.7

Les valeurs de chaîne qui contiennent des caractères non numériques renvoient 0 lors de l’association à int() ou uint() et NaN lors de l’association à Number() . Le processus de conversion ignore les espaces blancs à gauche et à droite mais renvoie 0 ou NaN si une chaîne contient un espace blanc séparant deux nombres.

trace(uint("5a")); // 0 
trace(uint("ten")); // 0 
trace(uint("17 63")); // 0

Dans ActionScript 3.0, la fonction Number() ne prend plus en charge les nombres octaux, ou de base 8. Si vous fournissez une chaîne avec un zéro à gauche à la fonction Number() d’ActionScript 2.0, le nombre est interprété comme un nombre octal et converti en son équivalent décimal. Ceci ne s’applique pas à la fonction Number() dans ActionScript 3.0, qui ignore le zéro à gauche. Par exemple, le code suivant génère un résultat différent lorsqu’il est compilé à l’aide de différentes versions d’ActionScript :

trace(Number("044"));  
// ActionScript 3.0 44 
// ActionScript 2.0 36

L’association n’est pas nécessaire lorsqu’une valeur d’un type numérique est affectée à une variable d’un type numérique différent. Même en mode strict, les types numériques sont convertis de façon implicite en d’autres types numériques. Ceci signifie que dans certains cas, des valeurs inattendues peuvent être renvoyées lorsque la plage d’un type est dépassée. Les exemples suivants compilent tous en mode strict, même si certains génèrent des valeurs inattendues :

var myUInt:uint = -3; // Assign int/Number value to uint variable 
trace(myUInt); // 4294967293 
 
var myNum:Number = sampleUINT; // Assign int/uint value to Number variable 
trace(myNum) // 4294967293 
 
var myInt:int = uint.MAX_VALUE + 1; // Assign Number value to uint variable 
trace(myInt); // 0 
 
myInt = int.MAX_VALUE + 1; // Assign uint/Number value to int variable 
trace(myInt); // -2147483648

Le tableau suivant récapitule les résultats de l’association au type de données Number, int, ou uint à partir d’autres types de données.

Valeur ou type de données

Résultat de la conversion en Number, int ou uint

Boolean

Si la valeur est true , 1 ; sinon, 0.

Date

Représentation interne de l’objet Date, qui est le nombre de millisecondes depuis le 1er janvier 1970, à minuit, heure universelle.

null

0

Object

Si l’occurrence est null et convertie en Number, NaN ; sinon, 0.

String

Un nombre si la chaîne peut être convertie en nombre ; sinon, NaN si elle est convertie en Number ou 0 si elle convertie en int ou uint.

undefined

Si converti en Number, NaN ; si converti en int ou uint, 0.

Association à Boolean

L’association à Boolean à partir de n’importe quel type de données numériques (uint, int et Number) donne false si la valeur numérique est 0, et true autrement. Pour le type de données Number, la valeur NaN donne également false . L’exemple suivant indique les résultats de l’association des chiffres -1, 0, et 1 :

var myNum:Number; 
for (myNum = -1; myNum<2; myNum++) 
{ 
    trace("Boolean(" + myNum +") is " + Boolean(myNum)); 
}

Le résultat de l’exemple indique que sur les trois chiffres, seul 0 renvoie une valeur false :

Boolean(-1) is true 
Boolean(0) is false 
Boolean(1) is true

L’association à Boolean à partir d’une valeur String renvoie false si la chaîne est null ou une chaîne vide ( "" ). Sinon, elle renvoie true .

var str1:String; // Uninitialized string is null. 
trace(Boolean(str1)); // false 
 
var str2:String = ""; // empty string 
trace(Boolean(str2)); // false 
 
var str3:String = " "; // white space only 
trace(Boolean(str3)); // true

L’association à Boolean à partir d’une occurrence de la classe Object renvoie false si l’occurrence est null , et true autrement :

var myObj:Object; // Uninitialized object is null. 
trace(Boolean(myObj)); // false 
 
myObj = new Object(); // instantiate  
trace(Boolean(myObj)); // true

Les variables booléennes bénéficient d’un traitement particulier en mode strict car vous pouvez affecter des valeurs de tout type de données à une variable booléenne sans association. La coercition implicite de tous les types de données au type de données Boolean a lieu même en mode strict. En d’autres termes, contrairement à la plupart de tous les autres types de données, l’association à Boolean n’est pas nécessaire pour éviter des erreurs en mode strict. Les exemples suivants compilent tous en mode strict et se comportent comme prévu lors de l’exécution :

var myObj:Object = new Object(); // instantiate  
var bool:Boolean = myObj; 
trace(bool); // true 
bool = "random string"; 
trace(bool); // true 
bool = new Array(); 
trace(bool); // true 
bool = NaN; 
trace(bool); // false

Le tableau suivant récapitule les résultats de l’association au type de données Boolean à partir d’autres types de données :

Valeur ou type de données

Résultat de la conversion en Boolean

String

false si la valeur est null ou la chaîne vide ( "" ) ; true autrement.

null

false

Number, int ou uint

false si la valeur est NaN ou 0 ; true autrement.

Object

false si l’occurrence est null ; true autrement.

Association à String

L’association au type de données String à partir de n’importe quel type de données numérique renvoie une représentation sous forme de chaîne du nombre. L’association au type de données String à partir d’une valeur booléenne renvoie la chaîne "true" si la valeur est true , et renvoie la chaîne "false" si la valeur est false .

L’association au type de données String à partir d’une occurrence de la classe Object renvoie la chaîne "null" si l’occurrence est null . Autrement, l’association au type String à partir de la classe Object renvoie la chaîne "[object Object]" .

L’association à String à partir d’une occurrence de la classe Array renvoie une chaîne comprenant une liste séparée par des virgules de tous les éléments du tableau. Par exemple, l’association suivante au type de données String renvoie une chaîne contenant les trois éléments du tableau :

var myArray:Array = ["primary", "secondary", "tertiary"]; 
trace(String(myArray)); // primary,secondary,tertiary

L’association à String à partir d’une occurrence de la classe Date renvoie une représentation sous forme de chaîne de la date que l’occurrence contient. Par exemple, l’exemple suivant renvoie une représentation sous forme de chaîne de l’occurrence de la classe Date (le résultat indiqué correspond à l’heure d’été de la côte ouest des Etats-Unis) :

var myDate:Date = new Date(2005,6,1); 
trace(String(myDate)); // Fri Jul 1 00:00:00 GMT-0700 2005

Le tableau suivant récapitule les résultats de l’association au type de données String à partir d’autres types de données.

Valeur ou type de données

Résultat de la conversion en chaîne

Array

Une chaîne composée de tous les éléments du tableau

Boolean

" true " ou " false "

Date

Une représentation sous forme de chaîne de l’objet Date

null

"null"

Number, int ou uint

Une représentation sous forme de chaîne du nombre

Object

Si l’occurrence est null, "null" ; sinon, "[object Object]" .