DOCUMENTATION EN LIGNE
DE WINDEVWEBDEV ET WINDEV MOBILE

Nouveauté WEBDEV 2024 !
Aide / Tuto WEBDEV / Tuto - Les bases du WLangage
  • Leçon 2 - Les variables
  • Exemple pratique
  • Qu'est-ce qu'une variable ?
  • Déclarer une variable
  • Affectation et utilisation
  • Les types de variables
  • Opérations simples sur les variables
  • Conseils
  • Détail d'un type de variable : les variables de type Chaîne
  • Le type Chaîne
  • Construction d'une chaîne
  • Opérations sur une chaîne
  • Recherche d'une chaîne
  • Comparer deux chaînes
  • En résumé

Tuto - Les bases du WLangage

Leçon 2 - Les variables
Ce que vous allez apprendre :
  • Qu'est-ce qu'une variable ?
  • Les différents types de variables.
  • Le type Chaîne en détail.
Durée de la leçon 20 mn
Exemple pratique
Pour réaliser directement les manipulations de cette leçon, nous allons travailler dans le projet "WLangage" (créé dans la leçon précédente (consultez le paragraphe Un projet pour découvrir le WLangage de la leçon 1).
Nous allons saisir le code directement dans le code d'initialisation du projet. Ce code est le tout premier code exécuté lors du test du projet : nous pouvons ainsi réaliser des tests très simplement, sans interface.
Pour visualiser le résultat de nos manipulations, nous utiliserons notamment la fonction Trace, qui permet d'écrire l'information voulue aussi bien dans une fenêtre de trace que dans le volet du débogueur situé en bas de l'éditeur. Pour ce tuto, nous utiliserons le volet du débogueur.
Exemple de fenêtre de trace
Exemple de fenêtre de trace
Volet
Volet "Trace du débogueur"

Vous ne voyez pas ce volet, c'est normal. Le volet "Trace du débogueur" s'affichera automatiquement lors du test de notre exemple.


Première étape pour réaliser nos tests : afficher les événements WLangage liés au projet. Pour cela :
  1. Dans la barre des éléments ouverts, faites un clic droit sur le bouton "P". Le menu contextuel s'affiche.
    Menu contextuel du projet
  2. Sélectionnez l'option "Code de l'élément".
  3. L'éditeur de code affiche les différents événements WLangage associés au projet.
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.
Déclaration et initialisation d'une variable
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. Dans ce tuto, nous allons présenter quelques types de variable en détail.
  • une valeur : Information stockée dans la variable.
  • une portée : Limite d'utilisation de la variable dans le programme. La portée est définie principalement par l'endroit où la variable est déclarée. Pour plus de détails sur ce sujet, consultez Portée des variables.

Déclarer une variable

Avant d'utiliser une variable, il faut tout d'abord la déclarer (c'est-à-dire la créer).
Nous allons tout d'abord effectuer une déclaration simple :
  • Dans l'événement "Initialisation" du projet "WLangage", saisissez le code suivant :
    Prix est un monétaire
  • Dans ce code :
    • 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.
Il est également possible d'effectuer une déclaration multiple :
  • Dans l'événement "Initialisation" du projet "WLangage", saisissez le code suivant :
    Nom, Prénom sont des chaînes
  • Dans ce code :
    • 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.
Vous pouvez observer la coloration spécifique des différents éléments de la déclaration : une couleur spécifique est utilisée pour le nom de la variable et une autre pour son type. Ces couleurs permettent d'identifier rapidement les différents éléments de votre code.

Affectation et utilisation

Lorsque la variable est déclarée, il est possible de l'affecter (ou lui donner une valeur). L'opérateur = permet d'effectuer cette affectation.

Nous allons tout de suite tester cet opérateur. Dans l'événement "Initialisation" du projet "WLangage", ajoutez le code suivant :
// Affectation d'une variable de type monétaire
Prix = 1256.67
// Affichage du contenu de la variable
Trace(Prix)
// Affectation d'une variable de type chaîne
Nom = "Dupont"
// Affichage du contenu de la variable
Trace(Nom)

Dans ce code, les variables Prix et Nom sont affectées avec une valeur. Pour lire et manipuler le contenu de la variable, il suffit d'utiliser le nom donné à la variable pour y accéder. Dans cet exemple, le contenu des variables est affiché dans le volet "Trace du débogueur" grâce à la fonction Trace.
Testons notre code :
  1. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
  2. Le projet se lance en exécution et l'éditeur de code réapparaît.
  3. Affichez si nécessaire le volet "Trace du débogueur" pour voir le résultat : sous le volet "Accueil", dans le groupe "Environnement", déroulez "Volets", sélectionnez "Volets" puis "Trace du débogueur".
    Avertissement
    Ne confondez pas le volet "Débogueur" et le volet "Trace du débogueur".
  4. Le volet "Trace du débogueur" contient le contenu de nos variables :
    1256.67
    Dupont
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.
Au cours de ce tutoriel, nous allons utiliser la plupart de ces types de variables.
Pour aller plus loin :
  • Le WLangage propose également des variables de type "avancé" regroupant toutes les caractéristiques de l'élément manipulé en une seule variable. Ces types avancés permettent par exemple de manipuler les documents XML, les emails, les fichiers XLS, etc.
    Pour plus de détails, consultez l'aide concernant le type voulu (voir Les différents types de 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.
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.
Pour avoir un aperçu des opérations réalisables, nous allons faire un petit test :
  1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
  2. Saisissez le code suivant :
    // Déclaration de variables
    Compteur est un entier
    V1 est un entier
    Res est un numérique
    
    // Affectation
    Compteur = 10
    V1 = 3
    
    // Utilisation des opérateurs
    Compteur = Compteur + 3   // Compteur vaut 13
    Trace(Compteur)
    Compteur ++ // Compteur vaut 14
    Trace(Compteur)
    Compteur -= 8 // Compteur vaut 6
    Trace(Compteur)
    Compteur = Compteur * V1 // Compteur vaut 18
    Trace(Compteur)
    Res = Compteur / 5 // Res vaut 3.6
    Trace(Res)
    Ce code permet de faire diverses opérations et affiche à chaque fois le résultat dans la fenêtre de trace.
Testons notre code :
  1. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
  2. Le volet "Trace du débogueur" contient la valeur de la variable Compteur pour chaque opération réalisée :
    13
    14
    6
    18
    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 par exemple). 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, etc.
  • 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"
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.
  • 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.

Il est également possible d'utiliser un texte sur plusieurs lignes. Par exemple :
MaChaîne est une chaîne
MaChaîne = "
	Exemple de 
	chaîne multiligne
"
Est-il possible d'affecter dans une chaîne le contenu d'un champ ?
Oui. 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

Construction d'une chaîne

Comme nous l'avons vu précédemment, la déclaration et l'affectation d'une chaîne sont très simples. Par exemple :
MaChaîneConstruite est une chaîne
NomProduit est une chaîne = "WEBDEV"
Cependant, bien souvent, une chaîne peut être composée d'éléments variables, comme le nom d'un produit par exemple. Dans ce cas, plusieurs méthodes de construction des chaînes sont disponibles. Nous allons tester ces différentes méthodes, et voir leurs avantages et leurs inconvénients.

Reprenons notre exemple "WLangage" :
  1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
  2. Dans l'événement "Initialisation" du projet "WLangage", saisissez le code suivant :
    MaChaîneConstruite est une chaîne
    NomProduit est une chaîne = "WEBDEV"
    
    // Concaténation
    MaChaîneConstruite = "Mon outil de développement, c'est " + NomProduit + " !"
    Trace("Concaténation : " + MaChaîneConstruite)
    
    // Saisie directe de la variable (syntaxe [% %])
    MaChaîneConstruite = "Mon outil de développement, c'est [%NomProduit%] !"
    Trace("Saisie directe : " + MaChaîneConstruite)

    Dans ce code, la variable MaChaîneConstruite est construite en utilisant 2 méthodes différentes :
    • 1ère méthode : concaténation simple grâce à l'opérateur '+' . Les chaînes sont simplement mises les unes à la suite des autres. Cette méthode est la plus courante. Cependant, cette méthode atteint ses limites si le message doit être affiché à l'utilisateur dans une application multilingue. En effet, selon la syntaxe de la langue utilisée, il peut être nécessaire de déplacer la position de la variable, ce qui ne sera pas possible dans ce cas.
    • 2ème méthode : utilisation directe de la variable. Cette méthode regroupe tous les avantages : simplicité pour la traduction et compréhension directe du message. Il suffit de mettre directement le nom de la variable voulue dans la chaîne en l'encadrant par les balises [% et %].
    Pour chaque type de construction, la fonction Trace permet d'afficher le résultat dans le volet "Trace du débogueur".

Nous allons maintenant tester notre code :
  1. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
    Le projet se lance et l'éditeur de code réapparaît.
  2. Le volet "Trace du débogueur" contient nos exemples de concaténation :
    Concaténation : Mon outil de développement, c'est WEBDEV !
    Saisie directe : Mon outil de développement, c'est WEBDEV !
La méthode utilisée pour la concaténation de chaîne influe sur la simplification de la compréhension et de la traduction, mais aussi sur les performances. Ainsi, la première méthode prend environ deux fois plus de temps que la seconde.

Opérations sur une chaîne

Le WLangage propose de nombreux opérateurs et fonctions permettant de gérer les extractions et les manipulations de chaînes.

Pour avoir un aperçu de la puissance et de la simplicité du WLangage pour la manipulation des chaînes, faisons un petit test rapide afin de parcourir une chaîne et d'en extraire les sous-chaînes.
  1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
  2. Saisissez le code suivant :
    ListeProduits est une chaîne = "
    WINDEV
    WEBDEV
    WINDEV Mobile
    "
    POUR TOUTE CHAÎNE UnProduit DE ListeProduits SÉPARÉE PAR RC
    	Trace(UnProduit)
    FIN
    Produit est une chaîne = ListeProduits.ExtraitChaîne(2, RC)
    Trace(Produit)
  3. Ce code permet à la fois de parcourir la chaîne multiligne et d'en extraire un élément. Examinons ce code :
    • La chaîne ListeProduits est une chaîne multiligne.
    • L'instruction "POUR TOUTE CHAINE" nous permet de parcourir les différents éléments de la chaîne. Ces éléments sont séparés par un RC (Retour Chariot).
      En WLangage, il n'est pas nécessaire de se soucier des majuscules ou des minuscules lors de la saisie des instructions dans l'éditeur de code : la bonne casse sera automatiquement appliquée lors de la saisie.
    • La fonction <Chaîne>.ExtraitChaîne appliquée à la chaîne permet dans notre cas d'extraire le second élément de la chaîne (c'est-à-dire "WEBDEV").
  4. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
  5. Le volet "Trace du débogueur" contient les éléments suivants :
    WINDEV
    WEBDEV
    WINDEV Mobile
    WEBDEV
Il est également possible d'extraire des parties d'une chaîne en utilisant simplement les opérateurs [ et ]. Ces opérateurs permettent simplement d'extraire la partie du texte voulue, en spécifiant le numéro du caractère de départ et ou d'arrivée.
  1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
  2. Saisissez le code suivant :
    Texte est une chaîne = "San Francisco"
    // Affiche le cinquième caractère dans la trace "F"
    Trace(Texte[5])
    // Affiche les caractères de 5 à 10 dans la trace "Franci"
    Trace(Texte[5 À 10])
    // Affiche les caractères à partir du cinquième dans la trace "Francisco"
    Trace(Texte[5 À])
    // Affiche les 10 premiers caractères dans la trace "San Franci"
    Trace(Texte[À 10])
    // Affiche 3 caractères à partir du 10ème caractère dans la trace "isc"
    Trace(Texte[10 SUR 3])
  3. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
  4. Le volet "Trace du débogueur" contient les informations suivantes :
    F
    Franci
    Francisco
    San Franci
    isc
Le WLangage permet également de formater la chaîne de caractères grâce à la fonction <Chaîne>.Formate. Il est ainsi possible de demander à afficher une chaîne sans accent, en majuscules ou un minuscules, etc. Voici un petit exemple rapide :
  1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
  2. Saisissez le code suivant :
    TexteInitial est une chaîne = "Mon outil de développement, c'est WEBDEV !"
    
    // Formate la chaîne initiale sans accent et en minuscule
    TexteInitial = TexteInitial.Formate(ccSansAccent + ccMinuscule)
    Trace(TexteInitial)
    // Formate la chaîne obtenue sans espace et en majuscule
    TexteInitial = TexteInitial.Formate(ccMajuscule + ccSansEspaceIntérieur)
    Trace(TexteInitial)
  3. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
  4. Le volet "Trace du débogueur" contient les informations suivantes :
    mon outil de developpement, c'est webdev !
    MONOUTILDEDÉVELOPPEMENT,C'ESTWEBDEV!
Pour aller plus loin : N'hésitez pas à consulter les pages d'aide Manipuler les chaînes de caractères et Fonctions de gestion des chaînes de caractères.

Recherche d'une chaîne

Une manipulation courante sur les chaînes de caractères est la recherche. Qui n'a pas voulu savoir si un mot était présent dans une chaîne de caractères, quelle était sa position, etc. En WLangage, rien de plus simple.

Nous allons effectuer une recherche dans une chaîne de caractères :
  1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
  2. Saisissez le code WLangage suivant :
    ChaîneARechercher est une chaîne = "WEBDEV"
    
    TexteOriginal est une chaîne = "
    Outils de développement :
    - WINDEV
    - WEBDEV
    - WINDEV Mobile
    "
    
    Pos est un entier
    Pos = Position(TexteOriginal, ChaîneARechercher)
    SI Pos = 0 ALORS
    	Trace("La chaîne [%ChaîneARechercher%] n'a pas été trouvée dans le texte")
    SINON
    	Trace("La chaîne [%ChaîneARechercher%] a été trouvée à la position [%Pos%]")
    FIN

    Examinons ce code WLangage :
    • Plusieurs variables sont déclarées :
      • une variable de type Chaîne correspondant à la chaîne à rechercher.
      • une variable de type Chaîne correspondant au texte dans lequel la recherche doit être effectuée.
      • 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 ChaîneARechercher dans le contenu de la variable TexteOriginal.
    • 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 Trace indiquant si la chaîne a été trouvée et sa position.
  3. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
  4. Le volet "Trace du débogueur" contient les informations suivantes :
    La chaîne WEBDEV a été trouvée à la position 40

Comparer deux chaînes

Une autre opération courante sur les chaînes de caractères est la comparaison de chaînes : trouver si deux chaînes sont identiques.
Nous allons effectuer une comparaison de deux chaînes de caractères :
  1. Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
  2. Saisissez le code WLangage suivant :
    // Chaînes à comparer
    Chaîne1 est une chaîne = "DEVELOPPEMENT"
    Chaîne2 est une chaîne = "DEV"
    
    // Les 2 chaînes sont comparées avec l'opérateur ~= (égalité souple)
    SI Chaîne1 ~= Chaîne2 ALORS
    	Trace("Les 2 chaînes sont équivalentes")
    SINON
    	Trace("Les 2 chaînes sont différentes")
    FIN

    Examinons ce code WLangage :
    • Deux variables de type Chaîne sont déclarées. Elles contiennent les chaînes à comparer.
    • La comparaison est effectuée avec l'opérateur ~= (é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.
    • Le résultat de la comparaison est affiché.
  3. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
  4. Le volet "Trace du débogueur" contient les informations suivantes :
    Les 2 chaînes sont différentes
  5. Revenez dans le code et modifiez la ligne de code correspondant à la déclaration de Chaîne2 :
    Chaîne2 est une chaîne = "Développement"
  6. Lancez le test du projet en cliquant sur Tester le projet parmi les boutons d'accès rapide.
  7. Le volet "Trace du débogueur" contient les informations suivantes :
    Les 2 chaînes sont équivalentes
    En effet, même si les deux chaînes n'ont pas la même casse, elles sont identiques.
Pour aller plus loin : De nombreux opérateurs de comparaison sont disponibles. Pour plus de détails, consultez la page opérateurs de comparaison.
En résumé
Dans cette leçon, vous avez découvert ce qu'est une variable, comment la déclarer et l'utiliser. Nous avons approfondi la manipulation des variables de type Chaîne.
Dans la prochaine leçon, nous poursuivrons notre découverte des variables en manipulant les dates, les heures et les durées, les tableaux et les structures.
Leçon précédenteSommaireLeçon suivante
Version minimum requise
  • Version 2024
Commentaires
Cliquez sur [Ajouter] pour publier un commentaire

Dernière modification : 26/03/2024

Signaler une erreur ou faire une suggestion | Aide en ligne locale