DOCUMENTATION EN LIGNE
DE WINDEV, WEBDEV ET WINDEV MOBILE

Version :

Accueil | Connexion | Français

Aide / Tuto WINDEV Mobile / Tuto - Les bases du WLangage

Leçon 5 - Les boucles
Présentation
Exemple pratique
L'instruction POUR
L'instruction BOUCLE
L'instruction TANTQUE
En résumé

Tuto - Les bases du WLangage

Leçon 5 - Les boucles

Ce que vous allez apprendre :

L'instruction POUR.
L'instruction BOUCLE.
L'instruction TANTQUE.

15 mn

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 ce tuto (consultez le paragraphe Un projet pour découvrir le WLangage de la leçon 1).

Pour afficher les événements WLangage liés au projet :

Dans la barre des éléments ouverts, faites un clic droit sur le bouton "P". Le menu contextuel s'affiche.
Sélectionnez l'option "Code de l'élément".
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.

Supprimez si nécessaire le code WLangage présent dans l'événement "Initialisation" du projet.

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.

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 "Volets" puis "Trace du débogueur".
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.

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

Testons immédiatement ce code : cliquez sur parmi les boutons d'accès rapide.
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.

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

Testons immédiatement ce code : cliquez sur parmi les boutons d'accès rapide.
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 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).

Pour parcourir le tableau :

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

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
Testons immédiatement ce code : cliquez sur parmi les boutons d'accès rapide.
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 :

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")
Testons immédiatement ce code : cliquez sur parmi les boutons d'accès rapide.
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")

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 :

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")

Testons immédiatement ce code : cliquez sur parmi les boutons d'accès rapide.
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.

En résumé

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édente

Sommaire

Leç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