Conversion de type
La conversion de type est l'opération consistant à changer une valeur d'un certain type en un autre. La chaîne "1234", par exemple, peut être convertie en nombre. Par ailleurs, vous pouvez convertir des données de n'importe quel type en type String. Certaines conversions de type échoueront toujours. Ainsi, un objet Date ne peut pas être converti en objet ActiveXObject.
Les conversions de type peuvent être étendues ou restrictives : les conversions étendues ne se heurtent jamais à un dépassement de capacité et réussissent toujours tandis que les conversions restrictives entraînent une perte d'informations et peuvent échouer.
Les deux types de conversion peuvent être explicites (à l'aide de l'identificateur du type de données) ou implicites (sans cet identificateur). Les conversions explicites valides réussissent toujours même si elles aboutissent à une perte d'informations. Les conversions implicites ne réussissent qu'en l'absence de toute perte de données; sinon, elles échouent et génèrent une erreur d'exécution ou de compilation.
Des conversions entraînent parfois des pertes de données lorsque le type de données d'origine n'a pas d'équivalent dans le type de la conversion cible. La chaîne "Fred", par exemple, ne peut pas être convertie en nombre. Dans de tels cas, la fonction de conversion de type retourne une valeur par défaut. Pour le type Number, la valeur par défaut est NaN ; pour le type int, il s'agit de zéro.
Certaines conversions, d'une chaîne vers un nombre par exemple, peuvent prendre beaucoup de temps. Moins votre programme a recours aux conversions, plus il sera efficace.
Conversions implicites
La plupart des conversions de type, telles que l'assignation d'une valeur à une variable, interviennent automatiquement. Le type de données de la variable détermine le type de données cible de la conversion de l'expression.
L'exemple ci-dessous illustre comment des données peuvent être implicitement converties entre une valeur int , une valeur String et une valeur double.
var i : int;
var d : double;
var s : String;
i = 5;
s = i; // Widening: the int value 5 coverted to the String "5".
d = i; // Widening: the int value 5 coverted to the double 5.
s = d; // Widening: the double value 5 coverted to the String "5".
i = d; // Narrowing: the double value 5 coverted to the int 5.
i = s; // Narrowing: the String value "5" coverted to the int 5.
d = s; // Narrowing: the String value "5" coverted to the double 5.
Lors de la compilation de ce code, des avertissements peuvent vous informer que les conversions restrictives sont lentes ou susceptibles d'échouer.
Il est possible que des conversions restrictives implicites échouent si elles provoquent une perte d'informations. Le code suivant, par exemple, échouera :
var i : int;
var f : float;
var s : String;
f = 3.14;
i = f; // Run-time error. The number 3.14 cannot be represented with an int.
s = "apple";
i = s; // Run-time error. The string "apple" cannot be converted to an int.
Conversions explicites
Pour convertir explicitement une expression en un type de données spécifique, utilisez l'identificateur de type de données suivi de l'expression à convertir entre parenthèses. Les conversions explicites requièrent plus de saisie que les conversions implicites. Toutefois, vous pouvez être certain du résultat obtenu. En outre, les conversions explicites peuvent gérer des conversions entraînant des pertes de données.
L'exemple ci-dessous illustre comment des données peuvent être explicitement converties entre une valeur int , une valeur String et une valeur double.
var i : int;
var d : double;
var s : String;
i = 5;
s = String(i); // Widening: the int value 5 coverted to the String "5".
d = double(i); // Widening: the int value 5 coverted to the double 5.
s = String(d); // Widening: the double value 5 coverted to the String "5".
i = int(d); // Narrowing: the double value 5 coverted to the int 5.
i = int(s); // Narrowing: the String value "5" coverted to the int 5.
d = double(s); // Narrowing: the String value "5" coverted to the double 5.
En général, les conversions restrictives explicites fonctionnent même si elles provoquent une perte d'informations. Il est impossible d'utiliser la conversion explicite pour convertir des types de données incompatibles. Ainsi, vous ne pouvez pas convertir des données de type Date en données de type RegExp, et inversement. En outre, il est impossible de convertir certaines valeurs parce qu'il n'existe aucune valeur logique de conversion. Ainsi, une erreur est levée lorsque vous tentez de convertir explicitement la valeur double NaN en décimale. En effet, il n'existe aucune valeur décimale logique qui peut être identifiée à NaN.
Dans cet exemple, un nombre comportant une partie décimale est converti en entier et une chaîne est convertie en entier.
var i : int;
var d : double;
var s : String;
d = 3.14;
i = int(d);
print(i);
s = "apple";
i = int(s);
print(i);
Le résultat est le suivant :
3
0
Le comportement de la conversion explicite dépend du type de données d'origine et du type de données cible.