<< Retour au sommaire

 

Les variables (partie 1)

 

 

 

Le sommaire :

1.      Introduction ;

2.      Les règles ;

3.      Les types de variables :

3.1  Le type de variables String ;

3.2  Les types de variables numériques, Byte, Word, Long et Float ;

3.3  Un exemple avec une variable de type String.

4.      La fonction Define

4.1  Définir un type numérique par défaut ;

4.2  Les déclarations.

5.      Des fonctions :

5.1  La fonction Str ;

5.2  La fonction StrF.

 

 

Introduction

 

Une variable est un espace mémoire qui vous permet de stocker provisoirement des informations durant l’exécution d’un programme.

Les variables sont donc un moyen provisoire de conserver des données, de réaliser des opérations Etc.…

Une variable a un type selon la nature des données que l’on va lui affecter, elle a également un nom et c’est à partir de ce nom que vous allez pouvoir l’utiliser.

D’ailleurs, c’est vous qui allez définir le nom de vos variables.

 

Les règles

 

  1. Le nom d’une variable ne doit pas commencer par un chiffre ;
  2. Aucun caractère autre que les lettres de l’alphabet et les chiffres ne doivent pas être utilisé, ni même les espaces.

 

Ce qu’il faut bien comprendre, au niveau du code de votre fichier source, c’est que le compilateur déduit la nature d’un mot, d’un bloc, par rapport à son écriture.

  1. Un bloc qui est encadrée par des guillemets est considéré comme une donnée de type « chaîne de caractères » ;
  2. Un bloc qui débute par un chiffre est considéré comme une donnée de type numérique ;
  3. Un bloc qui ne commence ni par des guillemets, ni par un chiffre, et qui se termine par des parenthèses est considéré comme une procédure ou une fonction ;
  4. Dans les autres cas de figure, il s’agit d’un mot clé, d’un opérateur, d’une variable ou d’une constante.

 

Le nom d’une variable peut donc être du genre : NomDuClient, AgeDuClient, DomicileDuClient etc.

Mais surtout pas :

Nom du client, Age du client, Domicile du client.

 

Lorsqu’il s’agit de nommer une variable, une constante, une procédure ou une fonction, il s’agit de définir le nom d’un élément, et d’un seul, vous devez donc employer un seul nom, qui peut cependant être composés de plusieurs mots attenants, vous pouvez également utiliser le caractères « souligné » en guise « d’espace ».

 

Le fait de mémoriser une donnée dans une variable est dite une « affectation » et nécessite l’emploi de l’opérateur « égal ».

Par exemple :

NomDuClient = « toto »

Vous pouvez constater que « toto » est placé entre guillemets puisqu’il s’agit d’une donnée de type « chaîne de caractères ».

 

AgeDuClient = 35

Ici pas de guillemets, 35 est une donnée de type numérique.

 


Les types de variables

 

Pas si vite !

Eh oui, en fonction de la nature de la donnée que l’on désire stocker, il faut employer une variable appropriée…

C’est-à-dire qu’une variable à un type, et cette spécificité se désigne par le biais de l’ajout d’un suffixe au nom de la variable.

Attention, le nom de la variable et le suffixe doivent être séparés par un « point »…

 

Le type de variable « String »

 

String doit être traduit par « chaîne de caractères ».

Quant aux valeurs mémorisables par ce type de variables, elles sont dites « alphanumériques ».

C’est-à-dire que ce type est comparable à ce que peut contenir du texte, il intègre toutes les lettres de l’alphabet, mais également les chiffres de 0 à 9, des ponctuations etc.

Dans le cas des chiffres, il faut bien comprendre qu’ils seront traités comme des caractères au même titre que les lettres, et non pas comme des valeurs numériques, donc aucun calcul ne sera réalisable sur ces derniers…

Le nom d’une variable de type String est suivi d’un « dollar », pas de point pour les séparer :

TonNom$ = »Pascal »

 

Les 4 types de variables pour stocker des valeurs numériques :

Les types numériques, Byte, Word, Long et Float

 

Byte, suffixe (.b), peut contenir les valeurs

de -128

à +127 ;

 

Word, suffixe (.w), peut contenir les valeurs

de -32 768

à +32 767 ;

 

Long, suffixe (.l), (ou par défaut s’il n’y a pas de suffixe), peut contenir les valeurs

de -2 147 483 648

A +2 147 483 647 ;

 

Float, suffixe (.f), peut contenir des valeurs illimitées.

 

Les types « Byte », « WORD » et « Long » doivent recevoir des valeurs entières, donc sans partie décimale.

Le type « Float » peut recevoir des valeurs décimales, mais attention, dans le monde de la programmation, on représente la « virgule » par un « point » qui se dit « point décimal ».

Par exemple :

3.75 et non pas 3,75

 

Pourquoi dispose-ton de plusieurs types pour représenter les entiers ?

Eh bien, c’est une histoire de mémoire…

Dès sa création, une variable réserve en mémoire vive un emplacement dont la taille est proportionnel à son type.

En clair, une variable de type « Long » réserve 4 fois plus d’espace mémoire qu’une variable de type  "Byte ».Si vous devez par exemple stocker en mémoire l’âge d’un client encore vivant, vous comprendrez alors aisément que l’usage d’une variable de type « Long » manque malheureusement d’intérêt !

 


Un exemple avec une variable de type String

 

Dans le code suivant, on affecte la chaîne de caractères « Toto » dans la variable Nom, puis on affiche le contenu de la variable en stoppant l’exécution de la console durant 10 secondes.

 

  1. OpenConsole() ;Ouverture de la console
  2. nom$="toto" ; Affectation de "toto" dans la variable Nom
  3. ; Affichage du contenu de la variable dans la console
  4. PrintN(nom$) ; pas de guillemets car Nom est une variable
  5. Print ("Veuillez patienter 10 secondes")
  6. Delay (10000) ; Blocage de l'exécution durant 5 secondes

 

Télécharger le fichier exemple, Source03.pb >>

 

L’intérêt de ce code, est de dire :

  1. La chaîne de caractères « toto » est affectée à la variable intitulée Nom ;
  2. La variable Nom est ensuite passée en paramètre à PrintN, donc affichée dans la console.

La fonction Define

 

La fonction « Define » propose plusieurs fonctionnalités, elle concerne néanmoins uniquement les déclarations et les types de variables…

 

Définir un type par défaut

 

Lorsqu’un nom de variable n’a pas de suffixe, par défaut il est de type « long ».

Grâce à la fonction « Define », vous pouvez définir un autre type par défaut !

 

En effet, rappelez-vous, si vous ne spécifiez aucun suffixe au nom de la variable, le type par défaut est « Long »…

 

La syntaxe :

Define.LettreDuSuffixe

 

La description :

LettreDuSuffix est le suffixe correspondant au type numérique qui doit  être le type par défaut pour les variables numériques n’ayant pas de suffixe.

 

Dans l’exemple qui suit, la ligne « Define » indique que toutes les variables du programme n’ayant pas de suffixe seront de type « Float ».

 

  1. OpenConsole () ; Ouverture de la console
  2. Define.F ; Définition du Flottant comme type numérique par défaut
  3. Valeur1 = 33.75
  4. Valeur2 = 75.50
  5. Somme = Valeur1+Valeur2
  6. PrintN ("La somme est "+Str (Somme))
  7. Print ("Pressez la touche Entree pour continuer...")
  8. Input ()

 

Télécharger le fichier exemple, Source36.pb >>


Les déclarations

 

Concernant les opérations liées aux variables, il existe la déclaration et l’affectation.

 

La déclaration seule, c’est dire qu’il existe une variable sans pour autant lui faire digérer une valeur, et ça, c’est possible !

 

Prenom$

Age.B

 

Remarque :

MaChaine.s

 

Voilà, les variables Prenom$ et Age.B sont déclarées, mais elles sont encore vides.

 

On continue ?

 

Prenom$ = « toto »

Age.B = 350

 

Ici, les variables sont soumises à une affectation, mais pas à la déclaration puisse que nous l’avions fait au préalable…

Toutefois, si nous n’avions pas déclaré les variables avant de les soumettre à leur première affectation, on aurait considéré que ces 2 opérations auraient été réalisées en une seule fois. Et ça, ce n’est pas possible dans tous les langages de programmation, en PureBasic, eh bien, « si »…

 

Grâce à la fonction « Define », vous pouvez en une seule ligne déclarer plusieurs variables dont le type de chacune d’entre elle est passé en suffixe :

La syntaxe :

Define.Suffixe Variable1, Variable2, Variable3 etc.

 

Par exemple, pour définir 3 variables de type « long » :

 

Define.L Variable1, Variable2, Variable3

 

Voici un exemple avec la déclaration d’une variable de type « String » et une autre de type « Byte ».

 

OpenConsole () ; Ouverture de la console

; Déclaration de 2 variables dans Define

Define Nom.s, Age.b

 Nom = "toto" ; Affectation d'une chaîne de caractères dans Nom

Age = 25 ; Affectation d'un entier dans Age

; Go pour une jolie concaténation dans la fonction PrintN

PrintN (Nom+" a exactement "+Str(Age)+" ans !")

Print ("Pressez la touche Entree pour continuer...")

Input ()

 

Bien sûr, sans l’emploi de « Define », il aurait fallu déclarer les 2 variables sur 2 lignes de code distinctes !

 

OpenConsole () ; Ouverture de la console

Nom.s ; Déclaration de la variable Nom de type chaine de caractère

Age.b ; Déclaration de la variable Age de type entier

Nom = "toto" ; Affectation d'une chaîne de caractères dans Nom

Age = 25 ; Affectation d'un entier dans Age

; Go pour une jolie concaténation dans la fonction PrintN

PrintN (Nom+" a exactement "+Str(Age)+" ans !")

Print ("Pressez la touche Entree pour continuer...")

Input ()


Des fonctions

 

La fonction Str

 

Print & PrintN ne peuvent recevoir en paramètres que des données de type « String ».

Du coup, lorsque vous devrez afficher une donnée de type « numérique », il vous faudra la convertir en une chaîne de caractères.

 

La fonction qui permet de réaliser la conversion est Str, et le numérique à convertir, lui, est passé en paramètre.

Cependant, comme il s’agit d’une fonction, la variable et son contenu ne sont pas modifiés, c’est simplement que la fonction Str retourne le résultat de la conversion.

Il faut donc :

  1. Soit récupérer le résultat dans une variable appropriée par le biais d’une affectation ;
  2. Soit placer la fonction Str et son paramètre en paramètre à Print.

 

Dans le code qui suit, j’ai retenu la deuxième solution…

 

  1. OpenConsole() ;Ouverture de la console
  2. age.B=25 ; Affectation de l'âge dans la variable
  3. ; Affichage du contenu de la variable dans la console
  4. Print (Str(age.B))
  5. Print ("Veuillez patienter 10 secondes")
  6. Delay (10000) ; Blocage de l'exécution durant 5 secondes

 

Télécharger le fichier exemple, Source04.pb >>

 

La fonction StrF

 

Cette fonction permet de convertir un numérique décimal en un String.

 

La syntaxe :

Chaine$= = StrF (Nombre.F,NombreDécimal)

 

La description :

Chaine$ est la variable de type String dans laquelle est affecté le résultat de la conversion.

 

Nombre.F est la variable de type Flottant qui est convertie.

 

NombreDécimal est un entier qui indique le nombre de chiffres à récupérer après le point décimal.

Par exemple, pour ne récupérer que 2 chiffres après le point :

Chaine$ =StrF (Nombre.F,2)

 

Au fait, un numérique contenant une partie décimale est dit aussi un « réel »…

 

Remarque :

 

Par exemple, voici un programme qui affichera 20.8 dans la console :

 

  1. OpenConsole ()
  2. Nombre.F = 20.76 ; Affectation d'un Réel dans la variable Nombre.f
  3. Chaine$ =StrF (Nombre.f,1) ; Affectation de la conversion dans Chaîne$ avec un arrondi sur le premier chiffre de la partie décimale
  4. PrintN (Chaine$)
  5. Print ("Pressez la touche Entree pour continuer...")
  6. Input ()

 

Télécharger le fichier exemple, Source09.pb >>

 

Philippe BOULANGER