PC SOFT

DOCUMENTATION EN LIGNE
DE WINDEVWEBDEV ET WINDEV MOBILE

Nouveauté WINDEV Mobile 27 !
  • Ce que vous allez apprendre dans cette leçon
  • Présentation
  • Exemple pratique
  • L'instruction POUR
  • L'instruction BOUCLE
  • L'instruction TANTQUE
  • Conclusion
Leçon 3.6. Les boucles
Ce que vous allez apprendre dans cette leçon
  • L'instruction POUR.
  • L'instruction BOUCLE.
  • L'instruction TANTQUE.
Durée de la leçon

Durée estimée : 15 mn
Leçon précédenteSommaireLeçon suivante
Présentation
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 ...

Exemple pratique

Pour réaliser les manipulations de cette leçon, nous allons reprendre le projet "WLangage" que nous avons utilisé dans la leçon précédente. Le principe est toujours le même : le code exemple va être saisi directement dans l'événement "Initialisation" du projet.

  • Ouvrez si nécessaire le projet "WLangage" que vous avez créé dans la première leçon de cette partie (consultez le paragraphe Un projet pour découvrir le WLangage de la leçon 3.2).
  • Pour afficher les événements WLangage liés au projet :
    1. Dans la barre des éléments ouverts, faites un clic droit sur le bouton "P". Le menu contextuel s'affiche.
    2. Sélectionnez l'option "Code de l'élément".
    3. L'éditeur de code affiche les différents événements associés au projet.
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

  • Pour tester cette instruction, nous allons saisir un code WLangage permettant de remplir un tableau d'entiers avec les nombres pairs compris entre 1 et 10. Nous listerons ensuite le contenu du tableau. Nous allons écrire ce code en plusieurs étapes.
    1. Supprimez si nécessaire le code WLangage présent dans l'événement "Initialisation" du projet.
    2. Nous allons tout d'abord remplir un tableau d'entiers de 1 à 10. Copiez le code suivant :
      TableauNombres est un tableau d'entiers
       
      POUR Indice = 1 À 10
      // Affiche l'indice
      Trace("Tour de boucle | Valeur de l'indice : [%Indice%]")
      TableauNombres.Ajoute(Indice)
      Trace("Ajout du nombre [%Indice%] dans le tableau")
      FIN
      Ce code exécute 10 fois le traitement et à chaque passage, la valeur de l'indice est enregistrée dans un tableau grâce à la fonction <Tableau>.Ajoute.
    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 "Trace du débogueur".
    5. Le volet "Trace du débogueur" contiendra les messages du tour de boucle et de l'ajout dans le tableau pour les 10 indices.
      Tour de boucle | Valeur de l'indice : 1
      Ajout du nombre 1 dans le tableau
      Tour de boucle | Valeur de l'indice : 2
      Ajout du nombre 2 dans le tableau
      Tour de boucle | Valeur de l'indice : 3
      Ajout du nombre 3 dans le tableau
      Tour de boucle | Valeur de l'indice : 4
      Ajout du nombre 4 dans le tableau
      Tour de boucle | Valeur de l'indice : 5
      Ajout du nombre 5 dans le tableau
      Tour de boucle | Valeur de l'indice : 6
      Ajout du nombre 6 dans le tableau
      Tour de boucle | Valeur de l'indice : 7
      Ajout du nombre 7 dans le tableau
      Tour de boucle | Valeur de l'indice : 8
      Ajout du nombre 8 dans le tableau
      Tour de boucle | Valeur de l'indice : 9
      Ajout du nombre 9 dans le tableau
      Tour de boucle | Valeur de l'indice : 10
      Ajout du nombre 10 dans le tableau
  • Nous allons modifier ce code pour sortir de la boucle si l'indice vaut 5. Dans ce cas, nous allons tester la valeur de l'indice et si celle-ci vaut 5, il suffira d'utiliser le mot-clé SORTIR pour arrêter la boucle.
    1. Le code devient :

      TableauNombres est un tableau d'entiers
       
      POUR Indice = 1 À 10
      // Affiche l'indice
      Trace("Tour de boucle | Valeur de l'indice : [%Indice%]")
       
      SI Indice = 5 ALORS
      Trace("Condition de sortie atteinte")
      SORTIR
      FIN
      TableauNombres.Ajoute(Indice)
      Trace("Ajout du nombre [%Indice%] dans le tableau")
      FIN
    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" contiendra les messages du tour de boucle et de l'ajout dans le tableau pour les 5 premiers indices.
      Tour de boucle | Valeur de l'indice : 1
      Ajout du nombre 1 dans le tableau
      Tour de boucle | Valeur de l'indice : 2
      Ajout du nombre 2 dans le tableau
      Tour de boucle | Valeur de l'indice : 3
      Ajout du nombre 3 dans le tableau
      Tour de boucle | Valeur de l'indice : 4
      Ajout du nombre 4 dans le tableau
      Tour de boucle | Valeur de l'indice : 5
      Condition de sortie atteinte
  • Maintenant, nous allons modifier ce code afin d'ajouter dans le tableau uniquement les indices pairs. Pour cela, il est nécessaire si l'indice est impair de continuer la boucle sans exécuter la ligne d'ajout dans le tableau. Nous allons utiliser le mot-clé CONTINUER.
    1. Le code devient :
      TableauNombres est un tableau d'entiers
       
      POUR Indice = 1 À 10
       
      Trace("Tour de boucle | Valeur de l'indice : [%Indice%]")
       
      SI Indice = 5 ALORS
      Trace("Condition de sortie atteinte")
      SORTIR
      FIN
       
      SI EstImpair(Indice) = Vrai ALORS
      Trace("L'indice est impair : passe à l'itération suivante")
      CONTINUER
      FIN
      TableauNombres.Ajoute(Indice)
      Trace("Ajout du nombre [%Indice%] dans le tableau")
      FIN
    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" contiendra le message du tour de boucle pour les 5 premiers indices. Pour les nombres impairs, un message indique que le code d'ajout n'est pas exécuté. Le message d'ajout dans le tableau sera affiché uniquement pour les nombres pairs.
      Tour de boucle | Valeur de l'indice : 1
      L'indice est impair : passe à l'itération suivante
      Tour de boucle | Valeur de l'indice : 2
      Ajout du nombre 2 dans le tableau
      Tour de boucle | Valeur de l'indice : 3
      L'indice est impair : passe à l'itération suivante
      Tour de boucle | Valeur de l'indice : 4
      Ajout du nombre 4 dans le tableau
      Tour de boucle | Valeur de l'indice : 5
      Condition de sortie atteinte
  • Il nous reste à ajouter le code permettant de parcourir le tableau afin de lister les indices enregistrés. Nous allons encore utiliser une boucle de type POUR. Les extrémités du parcours seront :
    • le premier élément du tableau. Cet élément correspond à 1 (nous l'avons vu dans la leçon 2.3),
    • le dernier élément du tableau. Comme nous ne le connaissons pas, nous allons utiliser la propriété Occurrence. Cette propriété, utilisée sur un tableau, permet de connaître le nombre d'éléments du tableau (et donc l'indice du dernier élément).
    1. Ajoutez le code suivant :
      POUR Indice = 1 À TableauNombres.Occurrence
      // Affiche l'indice et la valeur correspondante dans le tableau
      Trace("Indice : " + Indice + " | Valeur : " + TableauNombres[Indice])
      FIN
    2. Ce code peut être optimisé. En effet, avec cette syntaxe, le nombre d'éléments du tableau est réévalué à chaque tour de boucle. Si le nombre d'éléments du tableau évolue (des éléments sont supprimés par exemple), la valeur finale de la variable de contrôle s'adaptera. Dans notre exemple, le tableau n'est pas modifié pendant le parcours : il est possible d'utiliser le mot-clé _A_ qui permet de ne pas recalculer le nombre d'occurrences à chaque tour. Le code devient :
      POUR Indice = 1 _À_ TableauNombres.Occurrence
      // Affiche l'indice et la valeur correspondante dans le tableau
      Trace("Indice : " + Indice + " | Valeur : " + TableauNombres[Indice])
      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" contiendra le message affiché pour les 5 premiers indices. Pour les nombres impairs, un message indique que le code d'ajout n'est pas exécuté. Le contenu du tableau est ensuite listé.
      Tour de boucle | Valeur de l'indice : 1
      L'indice est impair : passe à l'itération suivante
      Tour de boucle | Valeur de l'indice : 2
      Ajout du nombre 2 dans le tableau
      Tour de boucle | Valeur de l'indice : 3
      L'indice est impair : passe à l'itération suivante
      Tour de boucle | Valeur de l'indice : 4
      Ajout du nombre 4 dans le tableau
      Tour de boucle | Valeur de l'indice : 5
      Condition de sortie atteinte
      Indice : 1 | Valeur : 2
      Indice : 2 | Valeur : 4
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 2000 fois le traitement et la variable Indice diminue de 10 en 10 :
// Boucle POUR allant de 2000 à 1, en allant de 10 en 10
POUR Indice = 2000 À 1 PAS -10
// Affiche l'indice
Trace(Indice)
FIN
Pour plus de détails, consultez Instruction POUR.
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 sur une condition pour sortir de la boucle.
La syntaxe de l'instruction BOUCLE est la suivante :
BOUCLE
Traitement à exécuter
SI <Condition à vérifier> ALORS SORTIR
FIN


  • Nous allons écrire un petit code WLangage afin de tester cette instruction :
    1. Supprimez si nécessaire le code WLangage présent dans l'événement "Initialisation" du projet et copiez le code suivant.
      Ce code soustrait 1 à un entier jusqu'à ce que la valeur de l'entier soit nulle :
      Compteur est un entier
      Compteur = 10
      BOUCLE
      Trace("Tour de boucle | Valeur : [%Compteur%]")
      Compteur--
      SI Compteur = 0 ALORS SORTIR
      FIN
      Trace("Fin de boucle")
    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 le message affiché pour les 10 tours de boucle.
      Tour de boucle | Valeur : 10
      Tour de boucle | Valeur : 9
      Tour de boucle | Valeur : 8
      Tour de boucle | Valeur : 7
      Tour de boucle | Valeur : 6
      Tour de boucle | Valeur : 5
      Tour de boucle | Valeur : 4
      Tour de boucle | Valeur : 3
      Tour de boucle | Valeur : 2
      Tour de boucle | Valeur : 1
      Fin de boucle
  • Une autre possibilité de test dans les boucles est l'utilisation du mot-clé TANTQUE. Dans ce cas, la syntaxe de l'instruction BOUCLE est la suivante :
    Compteur est un entier
    Compteur = 10
    BOUCLE
    Trace("Tour de boucle | Valeur : [%Compteur%]")
    Compteur = Compteur - 1
    À FAIRE TANTQUE Compteur > 0
    Trace("Fin de boucle")

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
Dans notre exemple, le code peut ainsi devenir :
Compteur est un entier
Compteur = 10
BOUCLE(10)
Trace("Tour de boucle | Valeur : [%Compteur%]")
Compteur --
FIN
Trace("Fin de boucle")
Pour plus de détails, consultez Instruction BOUCLE.
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 à une valeur donnée. 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

  • Nous allons écrire un petit code WLangage afin de tester cette instruction :
    1. Supprimez si nécessaire le code WLangage présent dans l'événement "Initialisation" du projet et copiez le code suivant.
      Ce code additionne 1 à un entier tant que l'entier est inférieur à 10.
      Compteur est un entier = 1
      TANTQUE Compteur <= 10
      Trace("Tour de boucle | Valeur : [%Compteur%]")
      // Traitement à exécuter
      Compteur ++
      FIN
      Trace("Fin de boucle")
    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 le message affiché pour les 10 tours de boucle.
      Tour de boucle | Valeur : 1
      Tour de boucle | Valeur : 2
      Tour de boucle | Valeur : 3
      Tour de boucle | Valeur : 4
      Tour de boucle | Valeur : 5
      Tour de boucle | Valeur : 6
      Tour de boucle | Valeur : 7
      Tour de boucle | Valeur : 8
      Tour de boucle | Valeur : 9
      Tour de boucle | Valeur : 10
      Fin de boucle
Pour plus de détails, consultez Instruction TANTQUE.
Conclusion
Dans cette leçon, vous avez découvert une partie des différentes instructions conditionnelles que propose le WLangage :
  • L'instruction POUR.
  • L'instruction BOUCLE.
  • L'instruction TANTQUE.
Dans la prochaine leçon nous verrons comment créer et utiliser des procédures en WLangage.
Leçon précédenteSommaireLeçon suivante
Version minimum requise
  • Version 27
Commentaires
Cliquez sur [Ajouter] pour publier un commentaire