PC SOFT

DOCUMENTATION EN LIGNE
DE WINDEV, WEBDEV ET WINDEV MOBILE

Nouveauté WINDEV 24 !
  • Ce que vous allez apprendre dans cette leçon
  • Qu'est ce qu'une variable ?
  • Déclarer une variable
  • Affectation et utilisation
  • Les types de variables
  • La portée des variables
  • Portée Globale
  • Portée Locale
  • Schéma récapitulatif de la portée
  • Opérations simples sur les variables
  • Conseils
  • Détail d'un type de variable : les variables de type Chaîne
  • Le type Chaîne
  • Exemple pratique
  • Détail d'un autre type de variable : les tableaux
  • Déclaration
  • Remplissage d'un tableau et accès aux éléments
  • Des tableaux avancés
Leçon 2.1. Les variables
Ce que vous allez apprendre dans cette leçon
  • Qu'est-ce qu'une variable ?
  • Les différents types de variables.
  • La portée des variables.
  • Le type Chaîne en détail.
  • Le type Tableau en détail.

Durée estimée : 1 h
Leçon précédenteSommaireLeçon suivante
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 Portée des variables). La portée est définie principalement par l'endroit où la variable est déclarée.

Déclarer une variable

Avant d'utiliser une variable, il faut tout d'abord la déclarer (c'est-à-dire la créer).
  • Exemple d'une 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 d'une 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.

Affectation et utilisation

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, ... Nous manipulerons ce type de variable dans la suite de ce cours.
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 et résultat 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, consultez Liste des 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).
Détail d'un type de variable : les variables de type Chaîne
Les variables de type Chaîne sont un des types de variables les plus utilisés.
Nous allons détailler une partie des fonctionnalités disponibles sur ce type de variable.

Le type Chaîne

Nous savons déjà que le type Chaîne permet de stocker et manipuler les caractères et les chaînes de caractères.
Nous avons déjà vu comment initialiser une variable de type chaîne :
Nom est une chaîne
// Affectation d'une variable de type chaîne
Nom = "Dupont"
Il n'est pas nécessaire de déclarer la longueur de la chaîne : le WLangage adapte automatiquement cette longueur lors de l'utilisation de la variable.

Astuce

Pour initialiser une variable de type chaîne avec un texte sur plusieurs lignes, utilisez la syntaxe suivante :
<Nom variable> = [
               <Texte de la ligne 1>
               <Texte de la ligne 2>
               ]
Par exemple :
MaChaîne est une chaîne
MaChaîne = [
Exemple de
chaîne multi-ligne
]
Il est également possible d'affecter une variable de type chaîne avec le contenu d'un champ manipulant des chaînes. Ainsi, le code permettant d'affecter une variable de type chaîne avec le contenu d'un champ de saisie est le suivant :
Nom est une chaîne
// Affectation d'une variable de type chaîne
// avec le contenu du champ de saisie SAI_Nom
Nom = SAI_Nom
En plus des opérateurs de comparaison de base, le WLangage propose des opérateurs puissants, permettant de gérer les extractions et concaténations de manière avancée.
Quelques exemples :
  • " + " : pour concaténer des chaînes.
  • " ~= " : pour tester l'égalité souple.
Le WLangage propose également des fonctions spécifiques permettant de réaliser de nombreuses opérations : recherche, extraction, taille, passage en majuscules, ...
Exemples :
ch est une chaîne
ch = "WINDEV est un outil formidable"
// Extraction d'une sous-chaîne à partir de la gauche
Info(Gauche(ch, 6))  // Affiche "WINDEV"
// Extraction d'une sous-chaîne à partir de la droite
Info(Droite(ch, 3))  // Affiche "ble"

Note

Le WLangage permet d'imbriquer les différentes fonctions WLangage. Une fonction WLangage peut être utilisée comme paramètre d'une autre fonction WLangage.
Par exemple :
Info(Milieu(Gauche(ch, 13), 8, 3)) // Affiche "est"
Pour plus de détails, consultez Manipuler les chaînes de caractères et Fonctions de gestion des chaînes de caractères.

Exemple pratique

Pour manipuler les différents concepts de cette leçon, nous allons réaliser différentes fenêtres. Ces fenêtres vont être créées dans le projet "WD Mes premières fenêtres".
  • Ouvrez si nécessaire le projet "WD Mes Premières Fenêtres".
    Pour cela, dans la page d'accueil (Ctrl + <), cliquez sur "Cours d'auto-formation" et sélectionnez le premier projet "Mes premières fenêtres (Exercice)".
Pour manipuler les variables de type Chaîne de caractères que nous venons d'étudier, nous allons réaliser la fenêtre suivante :
Manipulation de chaînes
Cette fenêtre permet de :
  • rechercher une chaîne dans une autre.
  • comparer deux chaînes.
  • Créez une nouvelle fenêtre vierge :
    1. Cliquez sur Création parmi les boutons d'accès rapide. La fenêtre de création d'un nouvel élément s'affiche : cliquez sur "Fenêtre­" puis sur "Fenêtre". L'assistant de création de fenêtres s'affiche.
    2. Sélectionnez "Vierge" et le gabarit "Elegant".
    3. Validez. La fenêtre est automatiquement créée sous l'éditeur. La fenêtre de sauvegarde de l'élément créé apparaît.
    4. Indiquez le titre de l'élément "Variables". Le nom de l'élément "FEN_Variables" est automatiquement proposé.
    5. Validez les informations affichées dans la fenêtre de sauvegarde en cliquant sur le bouton vert.
  • Pour créer le champ de saisie contenant la chaîne de base :
    1. Sous le volet "Création", dans le groupe "Champs usuels", cliquez sur Champ de saisie.
    2. Cliquez à l'emplacement de création du champ de saisie (par exemple en haut, au milieu de la fenêtre).
    3. Faites un clic droit sur le champ et sélectionnez l'option "Description".
    4. Dans l'onglet "Général", indiquez :
      • Le nom du champ : "SAI_Texte".
      • Le libellé du champ : "Texte".
    5. Sélectionnez l'onglet "Contenu". Cet onglet permet de définir la valeur par défaut du champ de saisie. Saisissez "WINDEV est un outil formidable".
    6. Validez la fenêtre de description. Le texte saisi s'affiche directement dans le champ.
  • Le contenu du champ apparaît tronqué sous l'éditeur. Pour afficher correctement le champ :
    1. Sélectionnez le champ.
    2. Agrandissez le champ en largeur à l'aide des poignées de redimensionnement afin que le contenu apparaisse en entier.
Recherche d'une chaîne
  • Pour créer le bouton "Rechercher une chaîne" :
    1. Sous le volet "Création", dans le groupe "Champs usuels", cliquez sur Champ Bouton.
    2. Cliquez à l'emplacement de création du bouton (par exemple en dessous du champ de saisie).
    3. Cliquez sur le bouton que vous venez de créer. Le texte affiché dans le bouton passe en édition. Saisissez le libellé "Rechercher une chaîne".
    4. Validez la saisie avec la touche Entrée.
    5. Adaptez la taille du champ.
    6. Affichez les traitements associés au bouton (touche F2).
    7. Saisissez le code de clic suivant :
      sChaîneARechercher est une chaîne = "WINDEV"
      nPos est un entier
      nPos = Position(SAI_Texte, sChaîneARechercher)
      SI nPos = 0 ALORS
      Info(sChaîneARechercher + " non trouvé dans le texte")
      SINON
      Info(sChaîneARechercher + " trouvé à la position " + nPos)
      FIN
      Examinons ce code :
      • Deux variables sont déclarées : une variable de type Chaîne correspondant à la chaîne à rechercher et une variable de type Entier correspondant à la position de la chaîne recherchée.
      • La fonction WLangage Position permet de rechercher une chaîne dans une autre. Dans notre exemple, nous recherchons le contenu de la variable sChaîneARechercher dans le contenu du champ SAI_Texte.
      • Si la fonction Position renvoie 0, cela signifie que la chaîne à rechercher n'a pas été trouvée. Un message est affiché grâce à la fonction Info.
  • Nous allons tester la fenêtre :
    1. Cliquez sur Go de fenêtre parmi les boutons d'accès rapide (ou utilisez la touche F9).
    2. La fenêtre que vous avez créée s'enregistre puis se lance en exécution. Cliquez sur le bouton. Le mot WINDEV est trouvé.
      Mot trouvé
    3. Modifiez le contenu du champ de saisie (en remplaçant WINDEV par WD par exemple) et cliquez sur le bouton. Le mot WINDEV n'est pas trouvé.
    4. Fermez la fenêtre.
Comparer deux chaînes
  • Pour créer le bouton "Comparer deux chaînes" :
    1. Sous le volet "Création", dans le groupe "Champs usuels", cliquez sur Champ Bouton.
    2. Cliquez à l'emplacement de création du bouton (par exemple à droite du bouton existant).
    3. Cliquez sur le bouton que vous venez de créer. Le texte affiché dans le bouton passe en édition. Saisissez le libellé "Comparer deux chaînes".
    4. Validez la saisie avec la touche Entrée.
    5. Adaptez la taille du champ.
    6. Affichez les traitements associés au bouton (touche F2).
    7. Saisissez le code de clic suivant :
      sChaîneAComparer est une chaîne = "WINDEV"

      SI SAI_Texte ~= sChaîneAComparer ALORS
      Info("Le texte affiché correspond à " + sChaîneAComparer)
      SINON
      Info("Le texte affiché ne correspond pas à " + sChaîneAComparer)
      FIN
      Examinons ce code :
      • Une variable de type Chaîne est déclarée. Cette variable contient la chaîne à comparer.
      • L'opérateur ~= correspond à une égalité souple. Cet opérateur permet de faire une comparaison sans tenir compte de la casse, des espaces avant et après la chaîne et sans tenir compte des accents.
      • Si la comparaison est vraie, le champ de saisie correspond au mot contenu dans la chaîne à comparer quelle que soit la casse utilisée.
  • Nous allons tester la fenêtre :
    1. Cliquez sur Go de fenêtre parmi les boutons d'accès rapide (ou utilisez la touche F9).
    2. Cliquez sur le bouton "Comparer deux chaînes". Le message indique que la comparaison n'est pas bonne.
      Mot non trouvé
    3. Validez le message.
    4. Dans le champ de saisie, saisissez "WINDEV" en majuscules, puis cliquez sur le bouton "Comparer deux chaînes". Le mot WINDEV est trouvé. Validez le message.
    5. Modifiez le contenu du champ de saisie (en remplaçant WINDEV par WinDev par exemple) et cliquez sur le bouton. Le mot WINDEV est également trouvé. Validez le message.
    6. Fermez la fenêtre.
Détail d'un autre type de variable : les tableaux
Les tableaux sont également un type de variable très utilisé.
Un tableau est un type structuré qui permet de regrouper une série d'éléments de même type. Chaque élément du tableau est accessible directement par son numéro d'ordre (indice).
Des fonctions WLangage spécifiques permettent de manipuler les tableaux et leurs éléments. Ces fonctions commencent par le préfixe "Tableau".

Déclaration

La déclaration d'une variable de type tableau se fait de la façon suivante :
<Nom du tableau> est un tableau de <Type des éléments du tableau>
Par exemple :
tabChaîne est un tableau de chaînes
tabEntier est un tableau d'entiers

Remplissage d'un tableau et accès aux éléments

Lors de sa déclaration, le tableau est vide. L'ajout d'éléments est réalisé par la fonction Ajoute grâce à la syntaxe suivante :
Ajoute(<Nom du tableau>, <Valeur de l'élément>)
Pour accéder aux éléments d'un tableau, il suffit d'utiliser la syntaxe suivante :
<Nom du tableau> [<Indice de l'élément>]

Important

Les indices des éléments du tableau commencent à 1.
Exemple :
// Création d'un tableau de chaînes
MonTableau est un tableau de chaînes
// Ajout d'éléments
Ajoute(MonTableau, "WINDEV")
Ajoute(MonTableau, "WEBDEV")
Ajoute(MonTableau, "WINDEV Mobile")
// Affichage du contenu du troisième élément
Trace(MonTableau[3])  // Affiche "WINDEV Mobile"

Astuce

Initialisation rapide d'un tableau
Pour initialiser un tableau, il est également possible d'utiliser la syntaxe suivante :
// Déclare un tableau
tabJour est un tableau de chaînes
// Initialisation avec
// les noms des jours de la semaine
tabJour = ["Lundi", "Mardi", "Mercredi", "Jeudi",
"Vendredi", "Samedi", "Dimanche"]
Pour plus de détails, consultez Tableau.

Des tableaux avancés

Le WLangage propose également des tableaux avancés : tableau à plusieurs dimensions, tableau de tableaux, tableau associatif, tableau de structures, tableau d'objets, ...
Pour plus de détails, consultez Tableau et Tableau associatif.
Leçon précédenteSommaireLeçon suivante
Version minimum requise
  • Version 24
Commentaires
Cliquez sur [Ajouter] pour publier un commentaire