DOCUMENTATION EN LIGNE
DE WINDEVWEBDEV ET WINDEV MOBILE

Nouveauté WINDEV 2024 !
Aide / Tuto WINDEV / Tuto - Les bases du WLangage
  • Leçon 3 - Dates, tableaux et structures
  • Présentation
  • Variables de type Date, Heure et Durée
  • Le type Date
  • Le type Heure
  • Le type Durée
  • 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 Structure
  • Le type Structure
  • En résumé

Tuto - Les bases du WLangage

Leçon 3 - Dates, tableaux et structures
Ce que vous allez apprendre :
  • Les types Date, Heure et Durée.
  • Le type Tableau.
  • Le type Structure.
Durée de la leçon 20 mn
Présentation
En dehors des types simples (booléen, entier, réel, etc.), 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.
Ouvrez si nécessaire le projet "WLangage" que vous avez créé dans la première leçon de ce tuto (consultez le paragraphe Un projet pour découvrir le WLangage de la leçon 1).
Variables de type Date, Heure et Durée
Le WLangage propose différents types de variables permettant de gérer les dates, les heures et les durées.

Le type Date

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 :
  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 :
    MaDate est une Date
    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.
  3. Maintenant, voyons comment affecter une date.
    MaDate = Hier()
    MaDate = "20210929"
    Ce code présente les différentes manières d'initialiser une variable de type Date. 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".
  4. 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
  5. 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())
  6. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  7. 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.
  8. 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
  9. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  10. 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.
  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 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.
  3. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  4. 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.
  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 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 = 2 min 8 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"))
  3. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  4. Le volet "Trace du débogueur" affiche les différentes informations souhaitées.
    02:08
Pour plus de détails sur les variables de type Date, Heure et Durée, consultez Variable de type Date, Variable de type Heure, Variable de type Durée.
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>]
Avertissement
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 :
  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 :
    // 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]%]")
  3. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  4. 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 "Volets" puis "Trace du débogueur".
  5. Le volet "Trace du débogueur" contient les informations suivantes :
    Valeur de l'élément 3 : WINDEV Mobile

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.
Boucle classique de type POUR .. A
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.
  1. 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.
  2. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  3. 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

Boucle de type POUR TOUT
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.
  1. Par exemple, remplacez le code de la boucle POUR par le code suivant dans l'événement "Initialisation" du projet :
    POUR TOUT ÉLÉ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.
  2. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  3. 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.
  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 :
    // Création d'un tableau associatif de dates
    MonTableau est tableau associatif de Date

    // 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 ÉLÉMENT Valeur, Clé, Indice DE MonTableau
    Trace("Valeur de l'élément [%Indice%] qui a pour clé [%Clé%] : [%Valeur%]")
    FIN
  3. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  4. 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 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 :
  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 :
    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.
  3. 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"
  4. 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
    // Affiche le contenu de la variable LeNom
    Trace(LeNom)
    // Affiche directement Contact.Nom (sans passer par une variable)
    Trace(Contact.Nom)
  5. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  6. Le volet "Trace du débogueur" affiche :
    POLO
    POLO
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 compléter note exemple :
  1. A la suite du code déjà saisi, saisissez le code suivant :
    // Déclaration d'un tableau de structures
    MesContacts est un tableau de NomComplet
    Ajoute(MesContacts, Contact)
    Trace(MesContacts[1].Nom, MesContacts[1].Prénom)
    Dans ce code, nous créons un tableau contenant la structure NomComplet, nous lui ajoutons le contact que nous avons créé précédemment puis nous affichons le nom et le prénom de ce contact.
  2. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  3. Le volet "Trace du débogueur" affiche maintenant :
    POLO
    POLO
    POLO MARCO
Pour plus de détails sur les variables de type Structure et Tableau de structures, consultez Structure.
En résumé
Dans cette leçon, vous avez découvert une partie des différents types de variables que propose le WLangage :
  • les types Date, Heure et Durée,
  • le type Tableau,
  • le type Structure.
Dans la prochaine leçon nous verrons comment manipuler certaines de ces variables grâce aux instructions conditionnelles disponibles en WLangage.
Leçon précédenteSommaireLeçon suivante
Version minimum requise
  • Version 2024
Commentaires
Cliquez sur [Ajouter] pour publier un commentaire

Dernière modification : 16/11/2023

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