<< Retour au sommaire

 

La boucle WHILE

 

 

 

Table des matières

  1. Présentation ;
  2. Un exemple

2.1  Introduction ;

2.2  Le code minimal ;

2.3  Amélioration du script, Rendons-le conforme ;

2.4  Qu’est-ce qu’un compteur ?

2.4.1        Présentation du compteur ;

2.4.2        Le compteur pour la sécurité ;

2.4.3        Le compteur pour la gestion des itérations.

  1. L’indentation.

 

Présentation

 

Il est possible de répéter en boucle un traitement tant qu’une condition est vraie.

La structure qui permet ce type d’exécution est appelée une »boucle », ou une « répétitive ».

Pour mieux comprendre le sens de la boucle, en français, on le remplacerait par « Tant que ».

 

Voici donc un exemple en français :

Tant que Condition-Vrai

  Exécute traitement

Fin de la répétitive tant que.

 

L’exemple que je vous propose ci-après recherche la chaîne de caractères « Tarzan » à l’intérieure d’une ligne.

Dans Word, écrivez la ligne suivante :

Je m’appelle Tarzan et je vis dans la jungle.

 

Script ChercheTarzan ()

; Positionne le curseur en haut du document

PerformScript TopOfFile ()

; Vérifie si le mot courant est différent de « Tarzan »

While (GetWord () != "Tarzan")

  ; la condition est vraie, lecture du mot suivant.

  NextWord ()

EndWhile

; La boucle est terminée, nous sommes positionnés sur Tarzan, lecture du mot courant.

SayWord ()

EndScript

 

En résumé, une répétitive tourne en boucle tant que la condition passée en paramètre à « While » est vraie.

Une exécution à l’intérieure d’une boucle est appelée une itération.

Dans le cas de l’exemple précédent, 2 itérations ont été nécessaires avant que le curseur se place sur le mot « Tarzan ».

Quant au traitement contenu dans la boucle, il est dit le « corps » de la boucle.

Lorsque l’exécution du programme arrive au niveau du « While », il vérifie si la condition est vraie.

Si tel est le cas, le traitement situé entre « While » et « EndWhile », donc le corps de la boucle, est exécuté.

(Il y a donc une première itération…)

Ensuite, après avoir butée sur le « EndWhile », l’exécution du programme remonte au « While » et vérifie à nouveau si la condition est toujours vraie.

Si tel est le cas, le corps de la boucle est exécuté une seconde fois, c’est la seconde itération, et ainsi de suite bien sûr…

En revanche, dès lors que la condition devient fausse, le traitement n’est plus exécuté. L’exécution du programme est orientée juste après le « EndWhile », et le programme continue, la boucle est finie.

 

C’est ainsi que la boucle s’achève naturellement !

Toutefois, dans le corps de la boucle, il est possible d’employer la fonction « Return » afin de forcer l’arrêt de la boucle.

 


Un exemple

 

Introduction :

 

Dans ce chapitre, dans le bloc notes, on va demander à la boucle de rechercher la commande du menu déroulant :

ALT, « Fichier », « Mise en page ».

 

Le script qui devra ouvrir cette boîte de dialogue s’intitulera « « MiseEnPage » et on va lui assigner le raccourci clavier CTRL +M.

 

En se concentrant uniquement sur le code minimal pour que le script fonctionne, voici ce que ça donne…

 

Le code minimal :

 

Script MiseEnPage ()

 

{ALT+F}

While (GetWord () != "Mise en page...")

 NextLine ()

EndWhile

{ENTER}

 

EndScript

 

Le résumé de ce script est :

1. Activer l’option de menu « Fichier » ;

2. « Tant que le mot courant est différent de « Mise en page », on passe à la ligne suivante » ; 

3. Puis, comme la boucle est finie, pressons la touche « entrée ».

 


Amélioration du script, rendons-le conforme :

 

Bon, maintenant, améliorons notre script…

On va lui ajouter :

1. des fonctions « pause » afin que l’exécution du script et que les évènements à l’écran soient synchrones.

2. La désactivation de la parole de JAWS durant l’exécution du script.

3. Des commentaires pour habiller un peu notre script afin de le rendre lisible.

 

Script MiseEnPage ()

 

; Coupe la parole de JAWS

SpeechOff ()

; Ouverture du menu "fichier"

{ALT+F}

; Marque une pause le temps de l'exécution

Pause ()

; Boucle tant que le mot courant n'est pas la mise en page

While (GetWord () != "Mise en page...")

 ; Il faut atteindre la ligne suivante

 NextLine ()

EndWhile

; Marque une pause

Pause ()

; Valide la commande du menu de la mise en page

{ENTER}

; Redonne la parole à JAWS

SpeechOn ()

 

EndScript

 


Qu’est-ce qu’un compteur ?

 

Présentation du compteur :

 

Un « compteur » est un traitement appliqué sur une variable qui va nous permettre d’envisager des boucles bien plus évoluées, ou plus sécurisées.

En résumé, on crée une variable de type « Int » afin de compter le nombre d’itérations réalisées dans la boucle.

Selon le résultat à atteindre, le rôle du compteur peut varier.

 

  1. Le compteur peut contrôler que le nombre d’itérations réalisées n’est pas insensé, dans quel cas on peut en déduire que la condition du « While » restera toujours vraie et que la boucle est éternelle…
  2. Le compteur peut tout simplement permettre de déterminer à l’avance le nombre d’itérations à réaliser.

 

Le premier rôle du compteur peut donc être une sorte de traitement de fin de boucle en cas d’erreur.

Vous l’avez bien sûr déjà compris, si vous créez une boucle dont la condition reste toujours vraie, la boucle devient éternelle et, malheureusement, la conséquence est sans pitié, c’est probablement le plantage de la machine…

En tout cas, si cela vous arrive, arrêtez JAWS avec Insère +F4 et redémarrez-le !

 

Il faut donc inévitablement que, à un moment donné, le traitement contenu dans la boucle influence la condition du « While ».


Le compteur pour la sécurité :

 

En reprenant notre exemple, nous allons déclarer une variable locale intitulée « compteur » et de type « Int », donc de type « Entier ».

Cette variable locale, dans le corps de la boucle, devra compter le nombre d’exécution, autant dire plutôt, le nombre d’itérations.

A chaque itération, on ajoutera la valeur 1 à la variable « compteur ».

Cette opération est dite « incrémentation ». Le contraire, c’est-à-dire retirer 1 à une variable, est une « décrémentation ». Bref, ici, c’est l’incrémentation qui nous intéresse…

 

Dans le cas où le nombre d’itérations vient d’atteindre 10, hop, on arrête la boucle !

En fait, comme l’exécution de la boucle est désormais liée à 2 conditions, nous allons devoir unir ces 2 conditions dans le paramètre du « While », et ce, grâce à l’opérateur logique « et » qui s’écrit « double et commercial ».

Lorsque 2 expressions sont unies par un « et logique », il suffit que l’une des expressions devienne fausse pour que l’union des 2 expressions renvoie la valeur fausse.

 

 

Mais pour quoi bon sang arrêter la boucle à partir de 10 itérations ?

Eh bien tout simplement parce que le menu « fichier » n’est pas si long que cela !

-         Par conséquent, si la commande du menu « Mise en page » n’est pas atteinte au bout de 10 « NextLine », c’est qu’il y a un big problème…

Mais pourquoi donc ?

Probablement avons-nous mal choisi la chaîne de caractères qui est comparée dans la condition du « While », ou bien le corps de la boucle ne contient aucune instruction qui fait évoluer les choses…

Alors, du coup, en rajoutant le compteur, il faut maintenant envisager un nouveau cas de figure !

En effet, désormais il ne faudra plus activer la touche « Entrée » dès lors que la boucle est terminée…

A la suite de la boucle, avant de valider la commande du menu que l’on est sensé avoir atteinte, il faut absolument vérifier si nous sommes bien positionner sur la bonne commande.

Pour ce faire, on vérifie tout simplement que le compteur n’a pas subit 10 itérations.

Si le compteur est inférieur à 10, on valide, sinon, on affiche un message d’échec pour signaler au programmeur que sa boucle est nulle !

 

Voici le code :

 

Script MiseEnPage ()

 

; Déclaration du compteur

Var Int compteur

; Initialisation du compteur à 0

Let compteur = 0

; Coupe la parole de JAWS

SpeechOff ()

; Ouverture du menu "fichier"

{ALT+F}

; Marque une pause le temps de l'exécution

Pause ()

; Boucle tant que le mot courant n'est pas la mise en page

; et que compteur n'a pas atteint 10 itérations

While ((GetWord () !="Mise en page...")&&(compteur<10))

 ; Il faut atteindre la ligne suivante

 NextLine ()

 ; Incrémentation du compteur

 Let compteur = compteur +1

EndWhile

; Marque une pause

Pause ()

; Vérifie si la commande a été atteinte

If compteur<10 Then

 ; Valide la commande du menu de la mise en page

 {ENTER}

 ; Redonne la parole à JAWS

 SpeechOn ()

else

 ; Pas de chance, la boucle est éternelle, c'est le moment de lui dire ses 4 vérités

 ; D'abord fermons le menu déroulant

 {ALT}

 ; Marquons une pause durant la fermeture du menu

 Pause ()

 ; Redonne la parole à JAWS

 SpeechOn ()

 MessageBox ("Eh toi le programmeur ! Ha ha ha ha... échec...")

EndIf

 

EndScript

 


Le compteur pour la gestion des itérations :

 

Eh oui, un compteur peut être employé pour déterminer à l’avance le nombre d’itérations à réaliser.

 

Bien entendu, l’erreur à éviter dans ce cas de figure est l’oubli de l’incrémentation du compteur dans le corps de la boucle !

Sinon, vous aurez droit à une sympathique boucle infinie…

 

Dans l’exemple suivant, nous allons créer une fonction qui exécute un nombre déterminé de « NextLine ».

Afin d’éviter au programmeur d’écrire plein de fois « NextLine » pour descendre le curseur courant, il aura désormais accès à une fonction intitulée « LigneSuivante ».

Lors de l’appel de la fonction, le programmeur devra bien sûr passer en paramètre le nombre de lignes à descendre.

Par exemple, pour réaliser 14 « NextLine » par le biais de la fonction, ça donne :

LignesSuivantes (14)

 

Du coup, au moment de l’écriture de la fonction, il faudra récupérer le paramètre dans une variable de passage, ce sera la variable NBLignes.

Cette fonction ne retournera aucune donnée…

Par contre, il faudra créer un compteur afin que dans le corps de la boucle, le nombre de « NextLine » soit comptabilisé.

Ainsi, lorsque le compteur aura atteint NBLigne, la boucle pourra s’interrompre…

 

Voici le code :

 

Void Function LignesSuivantes (int NBLignes)

; à partir de cet instant, la variable de passage "NBLignes" contient le nombre de lignes suivantes à réaliser

; Déclaration de la variable compteur

Var Int Compteur

; Initialisation du compteur

Let compteur = 0

; Démarrage de la boucle

; Tant que le compteur n'a pas atteint NBLignes

While (compteur<NBLignes)

 ; Atteindre la ligne suivante

 NextLine ()

 ; Incrémentation du compteur

 Let compteur = compteur +1

EndWhile

; Lecture de la ligne atteinte après le déplacement demandé

SayLine ()

 

EndFunction

 


L’indentation :

 

Afin d’améliorer la lisibilité du programme, il convient de prendre en compte la notion « d’appartenance » d’un traitement par rapport à une structure.

Ici, le corps de la boucle appartient clairement à la boucle !

C’est la raison pour laquelle nous devons impérativement afficher cette notion d’appartenance dans l’écriture du code par le biais de l’imbrication.

 

Les mots clés « While » et « EndWhile » font partie de la même structure, ils doivent avoir le même alignement par rapport à la marge de gauche.

En revanche, comme le corps de la boucle appartient à cette structure, il convient alors de décaler toutes les lignes de code de ce bloc d’au moins un espace vers la droite, ce retrait est dit « indentation ».

 

While (condition)

 Traitement ligne 1;

 Traitement ligne 2;

 Traitement ligne 3;

EndWhile

 

Philippe BOULANGER