Conversions de type

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 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; // 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 Flash Player ou Adobe AIR 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. 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.

null

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 :

null

false

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.

null

"null"