|
- Ce que vous allez apprendre dans cette leçon
- Présentation
- Les variables de type Tableau
- Déclaration
- Remplissage d'un tableau et accès aux éléments
- Parcours d'un tableau
- Le tableau associatif
- Variables de type Date, Heure et Durée
- Le type Date
- Le type Heure
- Le type Durée
- Variables de type File et Pile
- Le type File
- Le type Pile
- Variables de type Enumération et Combinaison
- Les types Enumération et Combinaison
- Variables de type Structure
- Le type Structure
- Conclusion
Leçon 3.4. Tour d'horizon des variables disponibles Ce que vous allez apprendre dans cette leçon - Le type Tableau.
- Les types Date, Heure et Durée.
- Les types File et Pile.
- Les types Enumération et Combinaison.
- Le type Structure.
En dehors des types simples (booléen, entier, réel, ...), le WLangage propose plusieurs types de variables qui permettent de prendre en compte beaucoup de spécificités. Nous allons passer rapidement en revue ces différents types de variables avec pour chacun un petit exemple pratique. Nous vous conseillons de consulter l'aide en ligne du type proposé pour plus de détails. Les variables de type Tableau Les tableaux sont 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. 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 :
MonTabChaîne est un tableau de chaînes MonTabEntier 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 <Tableau>.Ajoute grâce à la syntaxe suivante :
<Nom du tableau>.Ajoute(<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. |
- Pour tester l'ajout d'éléments dans un tableau, nous allons tester un petit exemple de code :
- Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
- Saisissez le code suivant :
// Création d'un tableau de chaînes MonTableau est un tableau de chaînes // Ajout d'éléments MonTableau.Ajoute("WINDEV") MonTableau.Ajoute("WEBDEV") MonTableau.Ajoute("WINDEV Mobile") // Affichage du contenu du troisième élément Trace("Valeur de l'élément 3 : [%MonTableau[3]%]")
- Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - 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" et sélectionnez "Trace du débogueur".
- Le volet "Trace du débogueur" contient les informations suivantes :
Valeur de l'élément 3 : 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 TableauJour est un tableau de chaînes // Initialisation avec // les noms des jours de la semaine TableauJour = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"]
|
Parcours d'un tableau Pour parcourir les éléments d'un tableau, le WLangage propose deux méthodes : - Une boucle classique de type POUR .. A.
- Une boucle de type POUR TOUT.
- Dans le cas d'une boucle classique de type POUR .. A .., il est nécessaire de donner la valeur de l'indice de départ (1) et de l'indice d'arrivée.
- Par exemple, ajoutez le code suivant dans l'événement "Initialisation" du projet :
POUR Indice = 1 À MonTableau.Occurrence Trace("Valeur de l'élément [%Indice%] : [%MonTableau[Indice]%]") FIN
Dans ce code, l'indice de départ est 1, l'indice d'arrivée est donné par la propriété Occurrence du tableau. - Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" contient les informations suivantes :
Valeur de l'élément 1 : WINDEV Valeur de l'élément 2 : WEBDEV Valeur de l'élément 3 : WINDEV Mobile
- Le WLangage propose un type de boucle beaucoup plus simple et tout aussi performant : la boucle POUR TOUT. Nous l'avons déjà vue sur les chaînes. Ce type de boucle s'applique également sur les tableaux. Dans ce cas, pas besoin d'indiquer l'indice de départ ou d'arrivée.
- Par exemple, remplacez le code de la boucle POUR par le code suivant dans l'événement "Initialisation" du projet :
POUR TOUT ELÉMENT UneChaîne, Indice DE MonTableau Trace("Valeur de l'élément [%Indice%] : [%UneChaîne%]") FIN
Dans ce cas, il suffit d'indiquer le nom de la variable qui correspond à l'élément du tableau et celle qui correspond à l'indice. - Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" contient les informations suivantes :
Valeur de l'élément 1 : WINDEV Valeur de l'élément 2 : WEBDEV Valeur de l'élément 3 : WINDEV Mobile
Pour plus de détails sur les variables de type Tableau, consultez la page d'aide Tableau. Le tableau associatif Un tableau associatif est un type "avancé" de tableau : il permet de regrouper une série d'éléments du même type. Chaque élément du tableau est indexé sur n'importe quel type d'information (et non plus simplement sur un indice numérique, comme dans les autres types de tableau). Les Tableaux associatifs (avec ou sans doublons) sont manipulables en WLangage.
- Vous voulez tester ? Rien de plus simple.
- Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
- Saisissez le code suivant :
// Création d'un tableau associatif de dates MonTableau est un tableau associatif de Dates // Ajout d'éléments MonTableau["Marc"] = "19820201" MonTableau["Anne"] = "19840604" // Affichage du contenu de l'élément ayant pour clé "Marc" Trace("Valeur de l'élément ayant pour clé ""Marc"" : " + MonTableau["Marc"]) // Parcours du tableau POUR TOUT ELÉMENT Valeur, Clé, Indice DE MonTableau Trace("Valeur de l'élément [%Indice%] qui a pour clé [%Clé%] : [%Valeur%]") FIN
- Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" contient les informations suivantes :
Valeur de l'élément ayant pour clé "Marc" : 19820201 Valeur de l'élément 1 qui a pour clé Marc : 19820201 Valeur de l'élément 2 qui a pour clé Anne : 19840604
Pour plus de détails sur les variables de type Tableau associatif, consultez la page d'aide Tableau associatif. Variables de type Date, Heure et Durée En dehors des types simples (booléen, entier, réel, ...), le WLangage propose plusieurs types de variables qui permettent de prendre en compte beaucoup de spécificités. Nous allons passer rapidement en revue ces différents types de variables avec pour chacun un petit exemple pratique. Nous vous conseillons de consulter l'aide en ligne du type proposé pour plus de détails. Le type Date Le WLangage propose différents types de variables permettant de gérer les dates, les heures et les durées. Pour gérer les dates, le WLangage propose le type Date. De nombreuses fonctions et propriétés permettent de manipuler les dates. - Pour tester la manipulation des dates, nous allons tester un petit exemple de code :
- Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
- Saisissez le code suivant :
Cette ligne de code permet de déclarer une variable de type Date. Par défaut, la variable est initialisée avec la date du jour. - Maintenant, voyons comment affecter une date. Saisissez le code suivant :
MaDate = Hier() MaDate = "20210929"
L'initialisation peut être effectuée : - via une fonction WLangage. Dans cet exemple, la fonction Hier est utilisée. Le WLangage propose de nombreuses fonctions permettant de connaître le premier ou dernier jour du mois, de l'année, ...
- via une chaîne de caractères contenant la date au format "AAAAMMJJ".
- Les paramètres de la date peuvent également être modifiés à l'aide de propriétés WLangage. Saisissez le code suivant :
// Modification des paramètres de la date MaDate.Année = 1985 MaDate.Mois = 10 MaDate.Jour = 26
- La fonction <Date>.VersChaîne permet de choisir le format d'affichage d'une date. Par exemple, saisissez le code suivant :
Trace(MaDate.VersChaîne()) Trace(MaDate.VersChaîne("Jjjj JJ Mmmm AAAA")) Trace(MaDate.VersJourEnLettre())
- Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" contient :
26/10/1985 Samedi 26 Octobre 1985 samedi
- l'affichage en clair de la date.
- l'affichage en clair de la date selon un masque.
- la récupération du jour en lettres correspondant à la date.
- Il est également possible d'utiliser des opérateurs de comparaison entre des dates. Saisissez le code suivant :
SI MaDate < DateDuJour() ALORS Trace("La date mémorisée est antérieure à la date du jour") FIN
- Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" contient :
26/10/1985 Samedi 26 Octobre 1985 samedi La date mémorisée est antérieure à la date du jour
Le type Heure - De la même manière, il est possible de manipuler des heures grâce au type Heure.
- Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
- Saisissez le code suivant :
// Déclaration d'une heure MonHeure est une Heure // Par défaut, l'heure est initialisée avec l'heure actuelle // Affectation d'une heure // - via une fonction WLangage MonHeure = Maintenant() // - fixée dans le code (par exemple 15h25) MonHeure = "1525" // Modification des paramètres de l'heure MonHeure.Heure = 12 MonHeure.Minute = 0 MonHeure.Seconde = 0 // Affichage en clair de l'heure Trace(MonHeure.VersChaîne()) // Affichage en clair de l'heure selon un masque Trace(MonHeure.VersChaîne("HH:mm:SS")) // Comparaison de 2 heures SI MonHeure < Maintenant() ALORS Trace("L'heure mémorisée est antérieure à l'heure actuelle") SINON Trace("L'heure mémorisée est postérieure à l'heure actuelle") FIN
Ce code reprend toutes les possibilités que nous avons vu pour les dates, et les applique aux heures. - Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" affiche les différentes informations souhaitées.
12:00:00:00 12:00:00 L'heure mémorisée est antérieure à l'heure actuelle
- l'affichage en clair de l'heure.
- l'affichage en clair de l'heure selon un masque.
Le type Durée - Pour les durées, le même type de code peut être saisi.
- Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
- Saisissez le code suivant :
// Déclaration d'une durée MaDurée est une Durée // Affectation d'une durée // - avec une valeur "en clair" MaDurée = 2 min 8 s // ou MaDurée = 128 s // - en fournissant la durée en secondes, en minutes, ... MaDurée.EnSecondes = 128 // Affichage en clair de la durée Trace(MaDurée.VersChaîne("MM:SS"))
- Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" affiche les différentes informations souhaitées.
Pour plus de détails sur les variables de type Date, Heure et Durée, consultez les pages d'aide : Variables de type File et Pile Le type File Le WLangage propose les types File et Pile. Ces types de variables sont des types structurés permettant de regrouper des séries d'éléments. - Pour tester la manipulation des Files, nous allons tester un petit exemple de code :
- Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
- Saisissez le code suivant :
MaFile est une File de chaînes
Cette ligne de code permet de déclarer une variable de type File contenant des chaînes de caractères. - Maintenant, voyons comment ajouter des données. Saisissez le code suivant :
// Ajout de données // L'élément est ajouté à la fin de la file MaFile.Enfile("WINDEV") MaFile.Enfile("WEBDEV") MaFile.Enfile("WINDEV Mobile")
La fonction <Variable File>.Enfile permet d'ajouter les données dans la file. Les éléments sont ajoutés à la fin de la file. - Pour récupérer les données de la File, il suffit d'utiliser la fonction <Variable File>.Défile. Saisissez le code suivant :
// Récupération de la valeur en début de file Donnée est une chaîne MaFile.Défile(Donnée) Trace(Donnée)
- Les propriétés peuvent également s'appliquer aux variables de type File. Par exemple, la propriété Occurrence permet de connaître le nombre d'éléments de la File.
// Comptage Trace("La file comporte [%MaFile.Occurrence%] éléments")
- Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" affiche le texte suivant :
WINDEV La file comporte 2 éléments
Pour plus de détails sur les variables de type File, consultez la page d'aide File. Le type Pile - Le même type de code peut être saisi pour tester la manipulation des Piles :
- Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
- Saisissez le code suivant :
// Déclaration d'une pile MaPile est une Pile de chaînes // Ajout de données // L'élément est ajouté au sommet de la pile MaPile.Empile("WINDEV") MaPile.Empile("WEBDEV") MaPile.Empile("WINDEV Mobile") // Récupération de la valeur du sommet dans une variable Donnée est une chaîne MaPile.Dépile(Donnée) Trace(Donnée) // Comptage Trace("La pile comporte [%MaPile.Occurrence%] éléments")
Pour les piles, l'élément est ajouté au sommet de la pile. Dans ce code, ce sont les fonctions <Variable Pile>.Empile et <Variable Pile>.Dépile qui sont utilisées pour manipuler les éléments. - Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" affiche le texte suivant :
WINDEV Mobile La pile comporte 2 éléments
Pour plus de détails sur les variables de type Pile, consultez la page d'aide Pile. Variables de type Enumération et Combinaison Les types Enumération et Combinaison Les énumérations et les combinaisons sont des types de variables qui permettent de manipuler simplement un ensemble de valeurs. - Une variable de type Enumération peut être affectée uniquement avec une valeur de l'énumération.
- Une variable de type Combinaison peut être affectée avec une ou plusieurs valeurs de la combinaison.
Quelque soit le type de variable manipulé, il faut déclarer déclarer la variable, l'affecter avec une ou plusieurs valeurs pour pouvoir ensuite l'utiliser. - Pour tester la manipulation des Enumérations, nous allons tester un petit exemple de code :
- Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
- Saisissez le code suivant :
// Déclaration de l'énumération Couleur est une Enumération Vert Bleu Rouge Jaune FIN // Déclaration d'une variable de type énumération CouleurTrait est un Couleur // Affectation d'une valeur CouleurTrait = Bleu // Comparaison de valeur SI CouleurTrait = Jaune ALORS Trace("Le trait est jaune") SINON Trace("Le trait n'est pas jaune") FIN
- Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" affiche :
Pour plus de détails sur ce type de variable, consultez la page d'aide Enumération. - Pour tester la manipulation des Combinaisons, nous allons tester un petit exemple de code :
- Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
- Saisissez le code suivant :
// Déclaration de la combinaison Options est une Combinaison SiègeChauffant ToitOuvrant SellerieCuir BoiteAutomatique FIN // Déclaration d'une variable de type combinaison OptionsVéhicule est un Options // Affectation d'une valeur OptionsVéhicule = SiègeChauffant + SellerieCuir + BoiteAutomatique // Tester si une valeur est activée SI OptionsVéhicule[SiègeChauffant] = Vrai ALORS Trace("L'option siège chauffant est activée") FIN
- Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" affiche :
L'option siège chauffant est activée
Pour plus de détails sur ce type de variable, consultez la page d'aide Combinaison. Variables de type Structure Le type Structure Une structure est un type de données personnalisé. Une structure regroupe des variables de types différents. - Pour tester la manipulation des structures, nous allons tester un petit exemple de code :
- Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
- Saisissez le code suivant :
NomComplet est une Structure Nom est une chaîne Prénom est une chaîne FIN
Ce code permet de déclarer une structure composée de deux variables, Nom et Prénom. Les variables composant une structure sont appelées "Membre". Pour manipuler les membres, il faut déclarer une variable du type de la structure. - Nous allons maintenant :
- Déclarer une variable de type structure. Ajoutez le code WLangage suivant :
Contact est un NomComplet
- Affecter les membres de la structure. Ajoutez le code WLangage suivant :
Contact.Nom = "POLO" Contact.Prénom = "MARCO"
- Pour lire le contenu d'un membre, il suffit d'utiliser la syntaxe :
<Nom de la variable>.<Nom du membre>
Dans notre exemple, saisissez le code suivant :
LeNom est une chaîne LeNom = Contact.Nom Trace(LeNom)
- Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" affiche :
Comme pour les autres types de variables, il est également possible de manipuler des tableaux de structures. - Pour tester la manipulation des tableaux de structures, nous allons tester un petit exemple de code :
- Supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
- Saisissez le code suivant :
// Déclaration de la structure Adresse est une Structure NomSociété est une chaîne NomContact est une chaîne Adresse est une chaîne CodePostal est une chaîne Ville est une chaîne Pays est une chaîne FIN // Déclaration d'une variable de type structure UneAdresse est un Adresse // Remplissage d'une structure UneAdresse.NomSociété = "PC SOFT" UneAdresse.NomContact = "Paul Durant" UneAdresse.Adresse = "142 Avenue des Champs Élysées" UneAdresse.CodePostal = "75008" UneAdresse.Ville = "PARIS" UneAdresse.Pays = "FRANCE" // Déclaration d'un tableau de structures MesAdresses est un tableau de Adresse Ajoute(MesAdresses, UneAdresse) Trace(MesAdresses[1].NomSociété)
- Testons immédiatement ce code : cliquez sur
parmi les boutons d'accès rapide. - Le volet "Trace du débogueur" affiche :
Pour plus de détails sur les variables de type Structure et Tableau de structures, consultez Structure. Dans cette leçon, vous avez découvert une partie des différents types de variables que propose le WLangage : - le type Chaîne,
- le type Tableau,
- les types Date, Heure et Durée,
- les types File et Pile,
- les types Enumération et Combinaison,
- le type Structure.
Dans la prochaine leçon nous verrons comment manipuler certaines de ces variables grâce aux instructions conditionnelles disponibles en WLangage.
|
|
|
| |
| Cliquez sur [Ajouter] pour publier un commentaire |
|
| |
|
| |
| |
| |
| |
| |
| |
| | |
| |