PC SOFT

DOCUMENTATION EN LIGNE
DE WINDEV, WEBDEV ET WINDEV MOBILE

  • Ce que vous allez apprendre dans cette leçon
  • Les variables
  • Qu'est ce qu'une variable ?
  • Déclarer et affecter une variable
  • Les types de variables
  • La portée des variables
  • Opérations simples sur les variables
  • Conseils
  • Les instructions conditionnelles SI et SELON
  • L'instruction SI
  • L'instruction SELON
  • Les boucles
  • L'instruction POUR
  • L'instruction BOUCLE
  • L'instruction TANTQUE
  • Les procédures
  • Types de procédure
  • Création et appel d'une procédure
  • Paramètres d'une procédure
  • Résultat d'une procédure
Leçon 4.2. Les bases du WLangage
Ce que vous allez apprendre dans cette leçon
  • Les différents types de variables.
  • Instructions de base du WLangage.
  • Les opérateurs de base du WLangage.
  • Procédures et fonctions.
  • Traitement des chaînes, des numériques et des monétaires.

Durée estimée : 1 heure
Leçon précédenteSommaireLeçon suivante
Les variables

Qu'est ce qu'une variable ?

Dans un langage de programmation, une variable permet de conserver des données. Ce sont des parties de la mémoire qui contiennent des chaînes, des nombres, etc.
Les variables permettent d'effectuer des calculs mathématiques, de faire des comparaisons ou tout simplement de stocker des informations pour les retrouver plus tard.
Une variable est représentée par :
  • un nom : Nom donné à la variable afin de la manipuler par le langage.
  • un type : Nature de la donnée stockée dans la variable (voir Types de variables).
  • une valeur : Information stockée dans la variable.
  • une portée : Limite d'utilisation de la variable dans le programme (voir le paragraphe Portée des variables). La portée est définie principalement par l'endroit où la variable est déclarée.

Déclarer et affecter une variable

Avant d'utiliser une variable, il faut tout d'abord la déclarer (c'est-à-dire la créer).
  • Exemple de déclaration simple :
    Prix est un monétaire
    • Prix représente le nom de la variable.
    • est un permet de déclarer la variable. Le WLangage utilise le langage naturel en français.
    • monétaire correspond au type de la variable.
  • Exemple de déclaration multiple :
    Nom, Prénom sont des chaînes
    • Nom, Prénom représentent les noms des variables.
    • sont des permet de déclarer un ensemble de variables.
    • chaînes représente le type des variables.
Lorsque la variable est déclarée, il est possible de l'affecter (ou lui donner une valeur). Par exemple :
// Affectation d'une variable de type monétaire
Prix = 1256.67
// Affectation d'une variable de type chaîne
Nom = "Dupont"
L'opérateur = permet d'effectuer cette affectation.

Note

En WLangage, le caractère " (double quote) est le caractère utilisé pour délimiter une chaîne de caractères. Dans l'exemple ci-dessus, les doubles quotes sont utilisées pour affecter la valeur Dupont à la variable Nom.
Le contenu d'une variable peut aussi être lu et manipulé : il suffit d'utiliser le nom donné à la variable pour y accéder.
L'exemple suivant permet de lire et d'afficher le contenu de la variable Prix à l'écran :
Info(Prix)

Les types de variables

Le type de la variable permet d'indiquer quelle est la forme de l'information que l'on stocke dans la variable. Les types les plus basiques sont :
  • booléen (Vrai ou Faux),
  • chaîne ("Dupont"),
  • entier (1234),
  • monétaire (12.32),
  • réel (7.766666),
  • etc.

Important

Utilisez le type correspondant à l'information que vous voulez stocker. Vous optimisez ainsi l'utilisation de la mémoire mais surtout vous évitez des erreurs de calcul ou de traitement lors de l'utilisation des variables dans les fonctions du WLangage.
Pendant ce cours d'auto-formation, nous allons utiliser la plupart de ces types de variables.
Pour plus de détails, consultez l'aide concernant le type voulu (voir Les différents types de variables).

Note

D'autres types existent comme les tableaux, les structures, les dates, les heures, ...
Il existe également des variables de type "avancé". Ces types avancés regroupent toutes les caractéristiques de l'élément manipulé en une seule variable.
Il existe des types avancés notamment pour manipuler les documents XML, les emails, les fichiers XLS, ...

La portée des variables

Il est possible de déclarer les variables à n'importe quel endroit dans le code. Cependant, en fonction de la position de sa déclaration, la variable n'est pas utilisable (ou visible) pour effectuer des traitements ou des calculs. On parle alors de portée des variables.
Il existe 2 types de portée :
  • Globale.
  • Locale.
Portée Globale
Le terme Global(e) signifie que la variable a une visibilité étendue dans le code. La variable est visible en dehors de l'endroit où elle a été déclarée. Il y a plusieurs niveaux de Globalité :
  • niveau Projet et Collection de procédures,
  • niveau Fenêtre, Fenêtre Mobile, Page, Etat.
Une variable déclarée au niveau du projet a la visibilité la plus importante dans le programme. La variable est visible partout, dans tous les traitements du programme. Attention toutefois à ne pas trop déclarer de variables de cette portée : en effet, la mémoire occupée par la variable est toujours réservée même si la variable n'est pas utilisée. L'utilisation massive de variables globales n'est pas conseillée dans l'architecture d'un programme informatique. Pour passer les variables à un traitement, il est conseillé d'utiliser des paramètres (pour plus de détails, consultez "Paramètres d'une procédure").
Une variable déclarée au niveau d'une Collection de procédures à la même visibilité qu'une variable déclarée au niveau du projet. L'avantage de déclarer une variable au niveau d'une Collection est de regrouper (ou classer) les variables par thème (collection) afin de rendre plus lisible le traitement d'initialisation du projet.
Une variable déclarée au niveau d'une Fenêtre, Fenêtre Mobile, Page ou Etat limite la portée de la variable à tous les traitements de l'élément (Fenêtre, Fenêtre Mobile, Page ou Etat) et de ses champs. Cela permet d'encapsuler et de limiter les utilisations.
Portée Locale
Le terme Local(e) signifie que la variable a une visibilité très limitée dans le code. La variable est visible uniquement dans le traitement où elle a été déclarée. Cela permet ainsi de restreindre l'utilisation de la variable au traitement.
Schéma récapitulatif de la portée

Une variable est globale lorsqu'elle est déclarée :
  • dans le code d'initialisation du projet (ou dans le code de déclaration de la collection de procédures). La variable est globale au projet.
  • dans le code de déclaration des globales de la fenêtre, de la page ou de l'état. La variable est globale à l'élément (fenêtre, page ou état) dans lequel elle a été déclarée.
Dans tous les autres cas, une variable est locale au traitement dans lequel elle est déclarée.

Opérations simples sur les variables

Pour effectuer des calculs sur des variables, le WLangage met à disposition les opérateurs mathématiques classiques :
  • + pour faire une addition.
  • - pour faire une soustraction.
  • * pour faire une multiplication.
  • / pour faire une division.
D'autres opérateurs peuvent être utilisés pour réaliser des calculs :
  • ++ pour incrémenter de 1 (additionner 1 à la variable).
  • - - pour décrémenter de 1 (soustraire 1 à la variable).
  • += pour affecter en additionnant une valeur.
  • - = pour affecter en soustrayant une valeur.
Exemples :
// Déclaration de variables
Cpt est un entier
V1 est un entier
Res est un numérique

// Affectation
Cpt = 10
V1 = 3

// Utilisation des opérateurs
Cpt = Cpt + 3   // Cpt vaut 13
Cpt ++ // Cpt vaut 14
Cpt -= 8 // Cpt vaut 6
Cpt = Cpt * V1 // Cpt vaut 18
Res = Cpt / 5 // Res vaut 3.6
Des opérateurs de comparaison sont également disponibles :
  • < inférieur strict
  • > supérieur strict
  • <= inférieur ou égal
  • >= supérieur ou égal
  • <> différent de
  • = égal à
D'autres opérateurs sont disponibles. Pour plus de détails sur les opérateurs, consulter l'aide en ligne (mot-clé : "Opérateurs").

Conseils

  • Il est très pratique de nommer les variables avec des noms longs (et éviter les noms très courts i, j, k ...). Lors de la relecture du programme, il est ainsi possible de se rappeler à quoi sert la variable.
  • Pour définir le nom des variables, le WLangage accepte tous les caractères Unicode, y compris les accents. Autant en profiter pour plus de lisibilité ! Attention toutefois : certains caractères sont interdits : espace, =, point, virgule, ...
  • Il est très important de donner le bon type à la variable en fonction de son utilisation. Par exemple, pour stocker une suite de chiffres, il peut être nécessaire :
    • d'utiliser une variable de type numérique si cette variable doit être utilisée pour des calculs.
    • d'utiliser une variable de type chaîne si cette variable permet de stocker des chiffres sans effectuer de calculs (par exemple pour mémoriser le numéro de sécurité sociale).
Les instructions conditionnelles SI et SELON

L'instruction SI

Cette instruction permet d'exécuter une action ou une autre en fonction du résultat d'une expression. Si l'expression est vérifiée, un traitement est lancé; si l'expression n'est pas vérifiée, un autre traitement peut être lancé.
L'instruction SI s'utilise comme ci-dessous :
SI <Expression à vérifier> ALORS
  Traitement à exécuter dans le cas où l'expression est vérifiée
SINON
  Traitement à exécuter dans le cas contraire
FIN
Exemple de code : Le code suivant sélectionne un nombre au hasard et selon la valeur affiche un message.
Tot est un monétaire
// Prend un nombre au hasard entre 100 et 4000
Tot = Hasard(100, 4000)
SI Tot>2000 ALORS
Info("Le montant est supérieur à 2000")
SINON
Info("Le montant est inférieur ou égal à 2000")
FIN

Dans ce cas, l'expression à vérifier correspond à "Tot>2000".
Remarque : Il est possible d'exécuter plusieurs lignes de code lors du traitement correspondant à une condition. Dans ce cas, la syntaxe à utiliser est la suivante :
SI <Expression à vérifier> ALORS
Ligne de code 1
Ligne de code N
SINON
Ligne de code 1
Ligne de code N
FIN

L'instruction SELON

Cette instruction permet d'évaluer une expression et d'exécuter un traitement pour chaque valeur possible de l'expression.
L'instruction SELON s'utilise selon la syntaxe ci-dessous :
SELON <Expression>
CAS Valeur 1 :
Traitement 1...
CAS Valeur 2 :
Traitement 2...
...
CAS Valeur N :
Traitement N...

AUTRES CAS
Traitement ...
FIN
Exemple : Le code suivant récupère la date du jour et selon sa valeur affiche un message différent. Pour le 1er et le 15 du mois, un message spécifique est affiché. Dans les autres cas, la date du jour est affichée.
D est une Date
D = DateDuJour()
SELON D..Jour // Teste le jour de la date
CAS 1 : Info("On est le premier jour du mois")
CAS 15 : Info("On est le 15 du mois.")
AUTRES CAS : Info("On est le : " + DateVersChaîne(D))
FIN
Remarques :
  • Si la ligne de code "CAS 1:..." est exécutée, les autres lignes de code correspondant aux valeurs possibles ne sont pas exécutées.
  • Il est possible de regrouper dans le même cas plusieurs valeurs. Les différentes valeurs sont séparées par une virgule. Par exemple :
    Ind est un entier = 2
    SELON Ind
           CAS 1,2 : Info("Cas 1 ou 2")
           CAS 3 : Info("Cas 3")        
           AUTRE CAS : Info("Autre cas")        
    FIN
  • Il est possible d'exécuter plusieurs lignes de code lors du traitement correspondant à une condition. Dans ce cas, la syntaxe à utiliser est la suivante :
    SELON <Expression>
    CAS Valeur 1 :
    Traitement 1 - Ligne de code 1...
    Traitement 1 - Ligne de code 2...
    CAS Valeur N :
    Traitement N - Ligne de code 1...
    Traitement N - Ligne de code 2...
    FIN
Les boucles
Les instructions de boucle permettent d'exécuter un traitement de manière récurrente. Selon le nombre d'occurrences (connu ou pas) on utilise une instruction de boucle particulière. Il existe plusieurs instructions pour faire des boucles :
  • POUR ...
  • BOUCLE ...
  • TANTQUE ...

L'instruction POUR

L'instruction POUR est utilisée lorsque l'on connaît le nombre d'occurrences à traiter. Cette instruction permet de gérer le nombre d'occurrences à l'aide d'une variable dans laquelle on va compter les passages effectués dans la boucle.
La syntaxe de l'instruction POUR est la suivante :
POUR Indice = Valeur de départ A Valeur de fin
Traitement à exécuter
FIN
Par exemple, le code suivant exécute 2000 fois le traitement :
POUR nCpt = 1 À 2000
// Traitement à exécuter
FIN
Remarque : Il est possible de définir un pas d'incrémentation de l'indice grâce au mot-clé PAS. Par exemple, le code suivant exécute 200 fois le traitement et la variable nCpt diminue de 10 en 10 :
POUR nCpt = 2000 À 1 PAS -10
// Traitement à exécuter
FIN

L'instruction BOUCLE

L'instruction BOUCLE est utilisée pour faire des boucles lorsque le nombre d'occurrences à traiter n'est pas connu. Dans ce cas, il faut utiliser un test pour sortir de la boucle.
La syntaxe de l'instruction BOUCLE est la suivante :
BOUCLE
Traitement à exécuter
SI <Expression> ALORS SORTIR
FIN
Par exemple :
Compteur est un entier
Compteur = 10
BOUCLE
// Traitement à exécuter
Compteur = Compteur - 1
SI Compteur = 0 ALORS SORTIR
FIN

Astuce

L'instruction BOUCLE permet d'avoir le même comportement qu'une instruction POUR : il suffit d'utiliser la syntaxe avec sortie selon le nombre d'itérations :
BOUCLE (<Nombre d'itérations>)
...
FIN
Exemple :
BOUCLE(10)
// Traitement à exécuter
FIN

L'instruction TANTQUE

L'instruction TANTQUE fonctionne sur le même principe que l'instruction BOUCLE. La différence réside dans le fait que le test de la condition de sortie est effectué AVANT l'exécution du code de la boucle. Ce test permet de comparer une variable. Cette variable commence à une valeur de départ et est modifiée dans la boucle jusqu'à arriver à la valeur qui provoque la sortie de la boucle.
La syntaxe de l'instruction TANTQUE est la suivante :
<Initialisation de la variable à sa valeur de début>
TANTQUE <Comparaison de la variable à sa valeur de fin>
Traitement à exécuter
<Modification de la variable>
FIN
Par exemple :
Compteur est un entier
Compteur = 0
TANTQUE Compteur<10
// Traitement à exécuter
Compteur = Compteur + 1
FIN
Les procédures
Une procédure permet d'associer un identificateur à une portion de code afin de la réutiliser.
Dans cette leçon, nous allons voir les différents types de procédures existant en WLangage, leur mode de création, comment les appeler, leur passer des paramètres et récupérer un résultat.

Types de procédure

Les procédures peuvent être de trois types :
  • Procédure globale : utilisable dans tous les traitements du projet (déclarée dans une collection de procédures).
  • Procédure locale à une Fenêtre, Page ou Fenêtre mobile : utilisable dans tous les traitements dépendant de l'objet dans lequel cette procédure a été déclarée.
  • Procédure interne à un traitement : utilisable uniquement dans le traitement dans lequel elle a été déclarée.

Note

Portée des procédures
Les procédures respectent les règles de portée que nous avons détaillées pour les variables (voir "La portée des variables").

Création et appel d'une procédure

Pour créer une procédure globale, il faut :
  1. Créer si nécessaire une collection de procédures (via le volet "Explorateur de projet", dossier "Procédures"). Donner un nom à la collection de procédures.
  2. Créer une procédure globale dans la collection de procédures (via le volet "Explorateur de projet", dossier "Procédures, Nom de la collection"). Donner un nom à la procédure.
  3. Saisir le code de la procédure globale. Le code de la procédure est de la forme :
    PROCEDURE <Nom de la procédure globale>()
Pour créer une procédure locale, il faut :
  1. Sélectionner l'élément associé à la procédure (fenêtre, page, ...).
  2. Créer une procédure locale (par exemple via le volet "Explorateur de projet", déroulez le nom de l'élément, dossier "Procédures locales").
  3. Donner un nom à la procédure.
  4. Saisir le code de la procédure locale. Le code de la procédure est de la forme :
    PROCEDURE <Nom de la procédure locale>()
Pour créer une procédure interne, il suffit de saisir le code suivant dans le traitement voulu :
PROCEDURE INTERNE <Nom de la procédure>()
<Code de la procédure interne>
FIN
Pour appeler une procédure, il suffit d'utiliser directement le nom de la procédure (avec éventuellement les paramètres à lui passer).
<Nom de la procédure>(<Paramètre 1>, ..., <Paramètre N>)
Pour plus de détails, consultez Procédure/Fonction.

Paramètres d'une procédure

Qu'est-ce qu'un paramètre ?
Un paramètre est une valeur envoyée à une procédure lors de l'appel de la procédure.
L'exemple suivant permet d'appeler la procédure Multiplie10 en lui passant en paramètre la valeur à manipuler dans la procédure :
Multiplie10(50)
Il est possible de passer de 0 à plusieurs valeurs en paramètre à une procédure. Ces valeurs peuvent être de tout type (comme pour les variables).
Le paramètre est spécifié dans la déclaration de la procédure sous forme de variable. Par exemple, pour la procédure Multiplie10, le code de la procédure est :
PROCEDURE Multiplie10(P)
P=P*10
P est le paramètre attendu par la procédure.

Note

Pour préciser la fonction du paramètre dans la procédure, il est possible de typer le paramètre dans la déclaration de la procédure.
Par exemple, pour n'utiliser que des numériques, il est possible de déclarer :
PROCEDURE Multiplie10(P est un numérique)
Dans l'exemple suivant, la procédure Multiplication attend deux paramètres de type Entier et renvoie le résultat de la multiplication.
Le code de la procédure est le suivant :
PROCÉDURE Multiplication(Nb1 est un entier, Nb2 est un entier)
MonRésultat est un entier
MonRésultat = Nb1 * Nb2
RENVOYER MonRésultat
Le code permettant d'appeler la procédure est le suivant :
res est un entier
res = Multiplication(10, 50)
// Res vaut 500
Comment utiliser les paramètres ?
Par défaut, le WLangage utilise le passage de paramètre par référence (ou par adresse). Le paramètre dans la procédure représente (référence) directement la variable passée lors de l'appel.
Ainsi, lorsqu'une instruction de la procédure modifie la valeur du paramètre, la valeur de la variable correspondant à ce paramètre est modifiée.
Exemple :
  • Le code de la procédure est le suivant :
    PROCÉDURE Test_adresse(P1)
    P1 = P1 * 2
  • Le code permettant d'appeler la procédure est le suivant :
    T est un entier
    T = 12 // T vaut 12 avant l'appel
    Test_adresse(T)
    // T vaut 24 après l'appel
Pour ne pas modifier la valeur de la variable correspondant au paramètre, il suffit d'utiliser le passage de paramètre par valeur. Le passage de paramètre par valeur permet de manipuler une copie de la valeur du paramètre. Si le code de la procédure modifie la valeur de la variable, la valeur de la variable correspondant au paramètre n'est pas modifiée.
Pour forcer le passage d'un paramètre par valeur à une procédure, il faut utiliser le mot-clé LOCAL devant le nom du paramètre dans la déclaration de la procédure. Ce mot-clé indique que le paramètre suivant ne sera pas modifié par la procédure.
Exemple :
  • Le code de la procédure est le suivant :
    PROCÉDURE Test_valeur(LOCAL P1)
    // Local indique que le paramètre sera passé par valeur
    P1 = P1 * 2
  • Le code permettant d'appeler la procédure est le suivant :
    T est un entier
    T = 12 // T vaut 12
    Test_valeur(T)
    // T ne change pas

Note

Dans une même procédure, certains paramètres peuvent être passés par adresse et d'autres paramètres peuvent être passés par valeur. Il suffit d'utiliser le mot-clé LOCAL devant chaque paramètre passé par valeur.
Paramètres obligatoires ou optionnels ?
Les paramètres reçus dans la procédure peuvent être obligatoires ou optionnels. Un paramètre obligatoire doit être renseigné lors de l'appel de la procédure, alors qu'un paramètre optionnel peut être omis : il prendra dans ce cas la valeur par défaut définie lors de la déclaration des paramètres de la procédure.

Note

Dans la déclaration d'une procédure, les paramètres optionnels sont toujours les derniers paramètres spécifiés (après tous les paramètres obligatoires).
Dans l'exemple suivant, la procédure Multiplication utilise un paramètre optionnel, Nb2. Ce paramètre optionnel est indiqué après les paramètres obligatoires, en précisant sa valeur par défaut. Dans cet exemple, le paramètre optionnel a pour valeur par défaut 10.
PROCÉDURE Multiplication(Nb1 est un entier, Nb2 est un entier=10)
MonRésultat est un entier
MonRésultat = Nb1 * Nb2
RENVOYER MonRésultat
Le code d'appel de la procédure est le suivant :
res est un entier
res = Multiplication(6)
// Res vaut 60
Dans cet exemple, le second paramètre n'a pas été précisé. C'est donc sa valeur par défaut qui est utilisée.

Résultat d'une procédure

Les procédures peuvent retourner un ou plusieurs résultats. Le résultat peut être typé. Il faut utiliser le mot-clé RENVOYER pour retourner une valeur.
Pour plus de détails, consultez Instruction RENVOYER.
Leçon précédenteSommaireLeçon suivante
Version minimum requise
  • Version 23
Documentation également disponible pour…
Commentaires
Cliquez sur [Ajouter] pour publier un commentaire