Dans cette séquence, nous allons voir les booléens et les
conditions en Pharo. Donc en fait, il existe deux objets
booléens, true et false sauf que true, en fait c'est l'unique
instance de la case true et false, c'est l'unique
instance de la classe false. Et on va envoyer des
messages à ces objets pour mettre en place ces opérations
booléennes, mouvoir des structures alternatives telles
que ifFalse, ifTrue, etc., donc on va voir ça dans cette séquence.
Donc, par exemple, dans le premier exemple sur ce slide,
on envoie le message &, donc qui est un opérateur binaire
à l'objet false et puis on lui passe un paramètre, donc
le paramètre c'est tout ça, qui est une expression ici
entre parenthèses, donc c'est 1 error:'crazy', donc cette
expression va déclencher une erreur et on voit que l'évaluation
totale de toute cette expression déclenche bien une erreur.
Pourquoi? Parce que l'opérande a été aussi évalué dans
cette expression booléenne.
Donc l'opérande a bien été évalué, ce qui produit l'erreur.
Donc si on voulait en fait la version paresseuse des
opérateurs booléens, il faut utiliser la méthode and: de
la classe booléen, et cette méthode and: prend en
paramètre un block, donc je vous rappelle, les blocks
commencent par un crochet ouvrant et se terminent par un
crochet fermant, contiennent des expressions, mais la
définition d'un block ne déclenche pas l'exécution des
expressions qu'il contient, donc pour l'instant, les
expressions qu'il contient ne sont pas évaluées et c'est
seulement si le premier opérande est vrai ou faux que le
block passé en paramètre sera évalué ou non.
Donc on a bien, dans ce deuxième exemple, false and: un
block qui retourne false sans avoir évalué le contenu du
block passé en paramètre, donc un opérateur paresseux
classique, mais construit cette fois avec des blocks.
Donc en Pharo, les conditionnels, donc les if, les false, les why, etc.
sont toujours des messages envoyés à des booléens ou à des blocks.
Donc, on va prendre un autre exemple, donc le message
ifTrue:if:False qui est la structure alternative
classique dans tous les langages de programmation, donc
sauf qu'en Pharo, c'est vraiment un message et je peux
envoyer le message ifTrue:ifFalse ici à un objet booléen
donc ça c'est une expression qui va retourner un booléen.
Et on va passer en paramètre de ce message ifTrue:ifFalse
deux blocks, un premier block qui serait évalué si le
booléen receveur était vrai et un deuxième block qui
serait évalué si le receveur était faux.
Donc attention, ce message ifTrue:ifFalse:, il est
extrêmement utilisé au cœur de Pharo, il est au cœur du
système, il est tellement important qu'il a été optimisé
de façon assez avancée pour pouvoir être efficace et ne
pas ralentir tout le système bien évidemment.
Donc, si on revient sur l'implantation des booléens en
Pharo, en fait elle est extrêmement élégante, comme je le
disais, les deux objets true et false sont tous deux
respectivement instance de la classe true et de la classe
false qui elle-même hérite de la casse booléen.
Et puis chacune de ces classes va définir un ensemble de
méthodes de façon à avoir le comportement attendu.
Donc, vous aurez plus d'informations sur cette
implantation des booléens qui est élégante dans une prochaine séquence.
Donc, revenons sur le message ifTrue:ifFalse,
donc il existe différentes versions de ces messages, donc
on a la version où on a juste le message ifTrue avec un
block en paramètre quand on veut faire juste la première
part de l'alternative ou le message complet
ifTrue:ifFalse qui compte bien deux blocks qui permet de
faire l'alternative avec le cas où le booléen est vrai ou faux.
Donc vous avez un exemple, vous avez même plusieurs
exemples ici, donc l'exemple où on n'envoie que le
message ifTrue, on a juste un block à exécuter si l'expression
booléenne est vraie ou un exemple ici où on a un block à
exécuter donc celui-là, si le booléen receveur était vrai
et celui-là, si le booléen receveur était faux.
Donc c'est bien deux messages différents, là on a le
pendant pour ifFalse sur les classes booléen, les classes
true et les classes false.
Donc on a d'autres types de messages pour exprimer les
alternatives, en fait, les conditions, donc on a le
message par exemple, ifEmpty:ifNotEmpty: que je peux
envoyer à une collection. Donc ifEmpty:, je passe un block.
Et puis le block sera évalué seulement si la collection
receveur est vide ou pas. Et puis ifNotEmpty:, c'est
la condition inverse donc si la collection n'est pas
vide, alors il faut exécuter ce block.
Sauf qu'on a une subtilité supplémentaire, ce block prend un argument.
L'argument en paramètres, c'est la collection elle-même
qui n'était pas vide puisque la collection, on a
peut-être le résultat d'un calcul complexe et donc on ne
va pas redemander la collection dans le block, donc la
collection, si elle n'était pas vide, elle est passée en
paramètres du block et elle peut être utilisée dans les
expressions du block ici.
Donc en résumé, dans cette séquence, on a vu que les
booléens sont des objets comme les autres en Pharo, sont
instances des classes true et false qui héritent de
booléens, et puis qu'on peut leur envoyer des messages et
que ces messages en fait définissent toutes les
constructions d'alternatives ou de conditions possibles
dans Pharo alors que dans d'autres langages, ce seraient
plutôt des structures câblées dans le compilateur.