Traitement simple des variables : opérateur d'affectation

Le premier opérateur est le symbole égal, = . En tant que symbole mathématique il est utilisé pour l'affectation. En d'autres mots, vous pouvez utiliser le symbole égal pour définir la valeur d'une variable. La valeur que vous attribuez à la variable peut être une valeur simple ou une expression. L'affectation la plus simple est présentée ci-dessous, et la version utilisant une expression sera présente dans certains des exemples à venir. Le code présenté ci-dessous peut également être récupéré ici.

OpenConsole()
nom$ = "John"
hauteur.f = 186.6
poids.f = 80
age.w = 23
copie_hauteur.l = hauteur
PrintN(nom$)
PrintN(StrF(hauteur))
PrintN(Str(copie_hauteur))
PrintN(Str(hauteur))
PrintN(Str(age))
Input()
CloseConsole()
End

Les quatre premières lignes (après la commande OpenConsole()) attribuent les valeurs aux variables (sur la partie gauche de l'opérateur = ) en utilisant les chaînes et les nombres tapés directement dans le code. Vous pouvez seulement définir les valeurs des variables, donc seul un nom de variable peut figurer sur la partie gauche de l'opérateur = quand vous l'utilisez pour l'affectation. Notez que vous devez stocker des chaînes dans des variables chaînes (strings) et des nombres dans des variables numériques sinon le compilateur vous renverra une erreur.

La ligne suivante montre comment définir la valeur d'une variable en utilisant une autre variable - c'est exactement la même chose sauf que vous écrivez sur la partie droite un nom de variable, qui est utilisé en tant que valeur. PureBasic fera automatiquement la conversion entre des types numériques différents (copie_hauteur est un long et hauteur est un float).

Sortie (Output) de l'exemple opérateur d'affectation Les cinq lignes suivantes (commençant par PrintN) vous montrent les différentes valeurs de la variable, et un exemple de commandes que vous pouvez utiliser pour afficher des valeurs. Evidemment ces valeurs devraient être les mêmes que celles que nous avons définies dans le code. Le résultat à l'écran (output) du programme est visible sur la capture d'écran située à droite et les lignes de codes sont expliquées ci-dessous.

Tout d'abord, souvenez-vous que la commande PrintN() prend comme paramètre une chaîne et l'affiche sur la console. La première ligne Print affiche (le contenu de) la variable nom$. Comme elle est de type chaîne, nous pouvons directement passer le nom de la variable en paramètre et elle sera affichée. Comme vous le constatez, "John" s'imprime sur la console, comme nous l'escomptions.

La ligne suivante - PrintN(StrF(hauteur)) - affiche la variable hauteur. Comme les variables numériques (dans ce cas un float) ne sont pas des chaînes nous devons les convertir en chaînes avant de les afficher. La commande pour convertir des nombres à virgule flottante en chaînes est StrF, qui prend un paramètre obligatoire - le nombre à virgule flottante à convertir. C'est pour cette raison que hauteur (le nom de la variable float) est entre parenthèses. La commande StrF() renvoie une chaîne. Vous remarquerez que chaque commande (PrintN et StrF) a son jeu de parenthèses associé, et que la commande StrF est à l'intérieur des parenthèses de PrintN. Cela signifie que le paramètre de la commande PrintN est le résultat de la commande StrF() qui, comme décrit ci-dessus, est une chaîne.

Comme vous pouvez le voir, la valeur affichée est "186.600006" qui ne semble pas correcte - en effet, nous avons défini la valeur de hauteur à 186.6. Ceci est dû à une limitation du format des nombres à virgules flottantes qui touche tous les ordinateurs et les langages qui utilisent ce format numérique (pas seulement PureBasic). Les ordinateurs qui travaillent avec des 1 et des 0 ne peuvent pas toujours stocker avec une précision exacte des valeurs ayant une partie décimale. Cependant, bonne nouvelle : pour en venir à bout, vous pouvez diminuer le nombre de chiffres devant être affichés - cela sera expliqué dans un prochain chapitre. L'autre bonne nouvelle, est que le type "double" sera prochainement ajouté à PureBasic pour une précision accrue (environ deux fois plus précise).

La ligne suivante est PrintN(Str(copie_hauteur)). Elle affiche la valeur de la variable copie_hauteur. C'est une autre variable numérique que nous devons convertir avant de l'afficher. Cette fois le type de la variable est l'un de ceux qui stockent les entiers. Donc, pour la convertir nous devons utiliser la commande Str, qui est la même que StrF mais qui prend pour paramètre une variable de type long. La valeur affichée dans la console est "187", ce qui peut vous paraître étrange. Cependant, souvenez-vous que PureBasic convertit automatiquement les types lorsque vous affectez des valeurs à des variables numériques. Lors de la conversion de types float dans n'importe quel type servant à stocker des nombres entiers, la règle est d'arrondir au nombre le plus proche.

La ligne PrintN(Str(hauteur)) montre ce qui se produit si vous utilisez la mauvaise commande de conversion pour une variable d'un certain type : ici une tentative de conversion d'un float en utilisant la commande prévue pour les nombres entiers. PureBasic essaiera alors de convertir le float dans le type du paramètre attendu par la commande, c'est à dire, ici, en long (type du paramètre de la commande Str, comme nous l'avons vu précédemment). C'est pourquoi nous obtenons le même résultat que la ligne de code précédente.