Lorsque vous utilisez des données, il est souvent nécessaire de convertir des variables d'un type de données en un autre. Par exemple, l'affichage du résultat d'un calcul requiert de convertir le type float en type string.
Dans Verse, toutes les conversions de type sont explicites, c'est pourquoi vous devez utiliser une fonction telle que ToString()
ou un opérateur de multiplication (*
) pour convertir un objet en un type de données différent. La conversion explicite d'un type en un autre est également appelée conversion de type.
Convertir le type float en Int
La conversion d'un type float en type int requiert une fonction qui spécifie de manière explicite comment elle convertira un nombre à virgule décimale flottante en nombre entier. Les fonctions suivantes gèrent toutes la conversion, mais leur fonctionnement est différent. Vous êtes libre de choisir celle qui correspond le mieux à une situation donnée.
Dans cet exemple, différentes fonctions convertissent quatre valeurs littérales float
en valeurs int
. Ensuite, set
assigne les valeurs aux variables de type int
. L'expression if
crée le contexte d'échec pour ces fonctions faillibles.
var WoodCollected:int = 0
var StoneCollected:int = 0
var GoldCollected:int = 0
var FoodCollected:int = 0
if:
# WoodCollected est à présent de 2
set WoodCollected = Round[1.5]
# StoneCollected est à présent de 1
set StoneCollected = Floor[1.9]
# GoldCollected est à présent de 2
set GoldCollected = Ceil[1.2]
# FoodCollected est à présent de 1
set FoodCollected = Int[1.56]
Print("WoodCollected: {WoodCollected}")
Print("StoneCollected: {StoneCollected}")
Print("GoldCollected: {GoldCollected}")
Print("FoodCollected: {FoodCollected}")
Convertir le type Int en float
La méthode de conversion d'un type de données int en type de données float consiste à multiplier l'entier par 1,0. L'opérateur de multiplication (*
) convertit l'entier ("int") en nombre à virgule décimale avant d'effectuer la multiplication.
Ce code convertit la variable int
StartingPositionX
en float
par multiplication pour pouvoir l'utiliser dans la déclaration d'une variable vector3
. Le type de données vector3
requiert des valeurs de type float
pour ses champs X
, Y
et Z
.
var StartingPositionX:int = 960
# CurrentX = 960.0
var CurrentX:float = StartingPositionX * 1.0
var CurrentPosition:vector3 = vector3{X := CurrentX, Y := 0.0, Z := 0.0}
Print("CurrentX: {CurrentX}")
Convertir en chaîne
Vous pouvez convertir plusieurs types de données en string
à l'aide d'une fonction ToString()
ou d'une interpolation de chaîne, qui appelle une fonction ToString()
. Actuellement, les types suivants ont des fonctions ToString()
intégrées dans Verse.
- float
- int
- []char
- char
- vector2
- vector3
- rotation
Dans cet exemple, les variables sont converties en chaîne par interpolation de chaîne et via la fonction ToString()
. Les deux méthodes donnent le même résultat, car l'interpolation de chaîne appelle ToString()
.
var WoodCollected:int = 100
# Convertir à l'aide de l'interpolation de chaîne
Print("WoodCollected: { WoodCollected }")
# ou de la fonction ToString()
Print("WoodCollected: " + ToString(WoodCollected))
var InitialDistance:float = 3.625
# Convertir à l'aide de l'interpolation de chaîne
Print("InitialDistance: { InitialDistance }")
# ou de la fonction ToString()
Print("InitialDistance: " + ToString(InitialDistance))
var CurrentPosition : vector3 = vector3{X:= 960.0, Y:= 540.0, Z := 20.0}
# Convertir à l'aide de l'interpolation de chaîne
Print("CurrentPosition: { CurrentPosition }")
# ou de la fonction ToString()
Print("CurrentPosition: " + ToString(CurrentPosition))
Convertir un type de données personnalisé en chaîne
Les types de données personnalisés peuvent également être convertis en chaînes en implémentant une fonction ToString(custom_type)
pour le type de données. Si une fonction ToString(custom_type)
existe, l'interpolation de chaîne l'utilisera pour convertir automatiquement les types de données en chaînes.
Voici un exemple de fonction personnalisée ToString()
pour une enum
de fruits.
fruit := enum:
Apple
Banana
Strawberry
ToString(Fruit: fruit):string =
case(Fruit):
fruit.Apple => "Pomme"
fruit.Banana => "Banane"
fruit.Strawberry => "Fraise"
PickUpFruit():void =
# Exemples d'utilisation de l'interpolation de chaîne pour convertir des données en chaînes
var FruitItem:fruit = fruit.Banana
# Choix : Banane
Print("Choix : {FruitItem}")
set FruitItem = fruit.Apple
# Choix : Pomme
Print("Choix : {FruitItem}")
Voici un exemple de fonction ToString()
personnalisée pour une classe personnalisée. Notez que la fonction ToString()
est déclarée hors de la classe waypoint
. Dans la fonction SetDestination()
, l'interpolation de chaîne de Destination
appelle la fonction ToString()
personnalisée.
# Classe personnalisée avec un constructeur et une fonction ToString()
waypoint := class():
DisplayName:string
Position:vector3 = vector3{}
MakeWaypoint<constructor>(Name:string, X:float, Y:float, Z:float) := waypoint:
DisplayName := Name
Position := vector3{X := X, Y := Y, Z := Z}
ToString(Waypoint: waypoint):string =
return "{Waypoint.DisplayName} at {Waypoint.Position}"
SetDestination():void =
Destination:waypoint = MakeWaypoint("River", 919.0, 452.0, 545.0)
# Rivière ("River") à {x=919.0, y=452.0, z=545.0}
Print("Destination: {Destination}")
Convertir une référence d'objet en type différent
Vous pouvez convertir explicitement des références à des objets (ou conversion de type) en classes ou interfaces différentes à l'aide de la syntaxe suivante :
if (NewObjectReference := object_type_to_cast_to[ObjectReference]) {}
object_type_to_cast_to représente la classe ou l'interface vers laquelle vous essayez de convertir la référence. Cett expression est faillible, car la conversion de type échoue si l'objet ne peut pas être converti dans le type spécifié. La tentative de conversion d'une référence d'objet en classe échoue si la classe ne correspond pas au type de l'objet, au type d'une superclasse ou à une interface que la classe de l'objet implémente.
Ce code déclare une interface positionable
, une classe abstraite shape
qui hérite de l'interface positionable
et deux sous-classes de shape
: triangle
et square
. Puis, il crée un objet de type square
appelé MyShape
et tente de le convertir en trois autres types. Voici un aperçu des résultats.
Conversion de type square en |
Résultat |
---|---|
square |
réussit, car MyShape est un square . |
triangle |
échoue, car triangle n'est pas une superclasse desquare et triangle n'est pas une interface implémentée par square . |
positionable |
réussit, car square est une sous-classe de shape et toutes les sous-classes de shape doivent implémenter positionable . |
# Définitions de classe et d'interface
positionable := interface() {}
shape := class<abstract>(positionable) {}
triangle := class(shape) {}
square := class(shape) {}
# Créer un objet carré répertorié à l'aide de la forme de type superclasse
MyShape:shape = square{}
# Cela réussira, car MySquare est un objet carré
if(MySquare := square[MyShape]):
Print("Successfully cast shape to square")
if(MyTriangle := triangle[MyShape]):
Print("This will never print.")
else:
Print("Failed to cast MyShape to triangle. This is expected behavior.")
# Cela réussira, car l'interface positionnable doit être implémentée par des sous-classes de forme
if(MyDrawable := positionable[MyShape]):
Print("Successfully cast shape to positionable")
Dans le dernier exemple, la conversion de type fonctionnera, mais n'est pas nécessaire. Ce code produira le même résultat :
MyDrawable:positionable = MyShape
Exemples utilisant la conversion de type
Par exemple, une conversion de type d'objet dans l'UEFN peut consister à rechercher des acteurs d'un certain type et à appeler des fonctions basées sur ce type. Pour savoir comment procéder, reportez-vous à la section Rechercher des acteurs dotés d'une balise de jeu dans Balises de jeu.