Conversions de type -- Flash CS3

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 par Flash Player lors de l'exécution. Par exemple, si la valeur 2 est affectée à une variable du type de données Boolean, Flash Player convertit la valeur 2 en la valeur booléenne true avant d'affecter la valeur à la variable. 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 l'associe à un entier numérique :

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

Sous-rubriques

Conversions implicites

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

Pour les types définis par l'utilisateur, les conversions implicites ont lieu lorsque la valeur à convertir est une instance 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; // Succès de la conversion.
objB = arr; // Echec de la conversion.

Pour les types primitifs, les conversions implicites sont gérées en appelant les mêmes algorithmes de conversion internes appelés par les fonctions de conversion explicite. La section suivante traite de ces conversions de type primitif dans les détails.

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; // erreur de compilation en mode strict

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); // Succès de la conversion explicite.

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 Flash Player ne peut pas convertir le nombre, 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. Renvoi depuis 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 a 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; // Affectation de la variable int/Number à la variable uint
trace(myUInt); // 4294967293

var myNum:Number = sampleUINT; // Affectation de la variable int/uint à la variable Number
trace(myNum) // 4294967293

var myInt:int = uint.MAX_VALUE + 1; // Affectation de la variable Number à la variable uint
trace(myInt); // 0

myInt = int.MAX_VALUE + 1; // Affectation de la variable uint/Number à la variable int
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	La 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'instance est `null` et convertie en Number, `NaN` ; sinon, 0.
String	Un nombre si Flash Player peut convertir la chaîne en un nombre ; autrement, `NaN` si converti en Number ou 0 si converti 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 nombres -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 nombres, 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;       // La chaîne non initialisée est null.
trace(Boolean(str1));  // false

var str2:String = "";  // chaîne vide
trace(Boolean(str2));  // false

var str3:String = " "; // espace blanc uniquement
trace(Boolean(str3));  // true

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

var myObj:Object;      // L'objet non initialisé est null.
trace(Boolean(myObj)); // false

myObj = new Object();  // instanciation 
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();  // instanciation 
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'instance 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 instance de la classe Object renvoie la chaîne "null" si l'instance 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 instance 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)); // primaire,secondaire,tertiaire

L'association à String à partir d'une instance de la classe Date renvoie une représentation sous forme de chaîne de la date que l'instance contient. Par exemple, l'exemple suivant renvoie une représentation sous forme de chaîne de l'instance 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)); // vendredi 1er juillet 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 comprenant tous les éléments de 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'instance est null, `"null"` ; sinon, `"[object Object]".`