Dans cette séquence, nous allons parler des boucles dans Pharo.
Les boucles sont des messages qu'on va envoyer à des objets.
En fait, il existe plein de types de boucles différents.
C'est des messages qu'on va envoyer soit à des nombres, à
des collections, voire même à des blocks et ça sera dans
certains cas des messages d'itération sur les éléments d'une
collection, par exemple.
Voilà un exemple, on envoie le message timesRepeat
à l'entier 4 et on va lui passer en paramètre un block.
Si vous vous rappelez, on a vu les blocks dans la séquence précédente.
On a un block qui commence ici et qui se termine ici.
Ce message va permettre de répéter l'évaluation de ce
block plusieurs fois, en l'occurrence quatre fois dans
cet exemple puisque le receveur du message, c'était 4.
Il existe d'autres types de messages pour effectuer des boucles.
Par exemple ici dans cet exemple, c'est le message to: do:.
Le message to:do est défini sur la classe number.
Et puis, on va lui passer également en paramètre un block
qui est le dernier argument du message et ce block va
être exécuté un certain nombre de fois avec un curseur de
boucle qui varie depuis le receveur jusqu'au premier
argument du message.
On a un exemple ici, si on reprend exactement le même
exemple, on va envoyer le message to:do à l'
entier 1. Dans le block, on va afficher le
paramètre du block, le paramètre i à chaque tour de boucle.
On voit que dans le Transcript, on a bien tous les
entiers qui ont été affichés entre 1 et 100.
Il existe d'autres messages pour effectuer des boucles.
Par exemple, on a le message to:by:do: pour faire des
incréments de plus que par 1.
On fait des incréments ici pour contrôler de combien on
fait l'incrément, on peut faire des incréments par 3 ici dans cet exemple.
À chaque tour de boucle, i va prendre des valeurs de 3 en 3.
On voit l'exemple ici, cette fois quand on a exécuté ce
morceau de code, on voit bien que i a bien varié de 1 à
100, mais avec un incrément de 3 à chaque fois.
Il existe maintenant aussi des itérateurs pour effectuer des boucles.
Les itérateurs sont des messages plutôt à envoyer à des
objets Collection. Il en existe de toutes sortes.
On a par exemple do: qui permet d'itérer sur chacun des
éléments d'une collection. Collect: qui permet à la fois
d'itérer sur les éléments d'une collection, mais
également de récupérer, de collecter les résultats pour
les mettre dans une nouvelle collection.
Select: qui permet de sélectionner un ensemble d'éléments
à l'intérieur d'une collection, donc de construire une
nouvelle collection uniquement avec ceux qu'on aurait sectionnés.
Reject: qui permet d'éliminer les éléments qu'on ne
voudrait pas dans une collection. Detect: qui permet de
savoir si un élément existe dans une collection donnée.
On va en voir quelques-uns dans la suite de ces slides.
Par exemple, do: qui est finalement le message le plus
courant qu'on utilise. On va envoyer le message do: à une
collection et on va lui passer un block.
À chaque tour de boucle, le block, le paramètre du block,
ici each: va recevoir d'abord le premier élément de la
collection, ensuite le second, jusqu'au dernier élément de la collection.
Voici un exemple, ici on a une collection qui est définie.
Je vous rappelle que la syntaxe, c'est dièse, parenthèse
et puis on termine par une parenthèse pour les collections littérales.
Cette collection contient quatre entiers: 15, 10, 19, 68.
On envoie le message do: à cette collection, on lui passe un block.
I, qui est le paramètre du block, va
prendre au premier tour de boucle la valeur 15 ensuite 10, 19 et 68.
Voici un autre message qui est whileTrue: qui permet
également d'effectuer des boucles.
whileTrue:, c'est un message qu'on va envoyer à un block,
donc c'est un message défini sur la classe block.
On a le block receveur qui est ici et puis on a un block
d'argument qui est ici.
Je vous donne un exemple concret issu de la classe Color.
On a ici un whileTrue:.
On a le block receveur.
Dans le block receveur, on a une condition: ce block va
s'évaluer à une condition, true ou false.
En fonction de l'évaluation de ce premier block, le
receveur, on va déclencher l'exécution ou pas du block
argument qui est le deuxième block, le paramètre de la méthode whileTrue:.
Il existe une variation de whileTrue
sans paramètres qui prend le block receveur, qui l'évalue
et si ce block s'évalue à vrai ou à faux, il est réévalué
une fois supplémentaire. En fait, on va réévaluer le
block tant qu'il s'évalue à vrai.
On a exactement les pendants de whileTrue: avec les
méthodes de whileFalse sans paramètres et avec paramètres.
Toutes les variations existent en fait dans les classes
sur les blocks.
En résumé, sur cette séquence, on a vu que les boucles en
Pharo sont exprimées comme des messages normaux envoyés à
des objets, que ce soit des entiers, des collections, des blocks.
Avec ça, on peut construire énormément de boucles
différentes et même en rajouter si on en a envie.