IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Cours complet Pharo par l'exemple


précédentsommaire

4. Chapitre 4 - Comprendre la syntaxe des messages

Bien que la syntaxe des messages Smalltalk soit extrêmement simple, elle n'est pas habituelle pour un développeur qui viendrait du monde C/Java. Un certain temps d'adaptation peut être nécessaire. L'objectif de ce chapitre est de donner quelques conseils pour vous aider à mieux appréhender la syntaxe particulière des envois de messages. Si vous vous sentez suffisamment en confiance avec la syntaxe, vous pouvez choisir de sauter ce chapitre ou bien d'y revenir un peu plus tard.

4-1. Identifier les messages

Avec Smalltalk, exception faite des éléments syntaxiques rencontrés dans le chapitre 3 (:= ↑ . ; # () {} [ : | ]), tout se passe par envoi de messages. Comme en C++, vous pouvez définir vos opérateurs comme + our vos propres classes, mais tous les opérateurs ont la même précédence. De plus, il n'est pas possible de changer l'arité d'une méthode : - est toujours un message binaire, et il n'est pas possible d'avoir une forme unaire avec une surcharge différente.

Avec Smalltalk, l'ordre dans lequel les messages sont envoyés est déterminé par le type de message. Il n'y a que trois formes de messages : les messages unaires, binaires et à mots-clefs. Les messages unaires sont toujours envoyés en premier, puis les messages binaires et enfin ceux à mots-clefs. Comme dans la plupart des langages, les parenthèses peuvent être utilisées pour changer l'ordre d'évaluation. Ces règles rendent le code Smalltalk aussi facile à lire que possible. La plupart du temps, il n'est pas nécessaire de réfléchir à ces règles.

Comme la plupart des calculs en Smalltalk sont effectués par des envois de messages, identifier correctement les messages est crucial. La terminologie suivante va nous être utile :

  • un message est composé d'un sélecteur et d'arguments optionnels ;
  • un message est envoyé au receveur ;
  • la combinaison d'un message et de son receveur est appelée un envoi de message comme il est montré dans la figure 4.1.

Image non disponible

Image non disponible
FIGURE 4.2 – aMorph color: Color yellow est composé de deux expressions : Color yellow et aMorph color: Color yellow.

Un message est toujours envoyé à un receveur qui peut être un simple littéral, une variable ou le résultat de l'évaluation d'une autre expression.

Nous vous proposons de vous faciliter la lecture au moyen d'une notation graphique : nous soulignerons le receveur afin de vous aider à l'identifier. Nous entourerons également chaque expression dans une ellipse et numéroterons les expressions à partir de la première à être évaluée afin de voir l'ordre d'envoi des messages.

La figure 4.2 représente deux envois de messages, Color yellow et aMorph color: Color yellow, de telle sorte qu'il y a deux ellipses. L'expression Color yellow est d'abord évaluée en premier, ainsi son ellipse est numérotée à 1. Il y a deux receveurs : aMorph qui reçoit le message color: ... et Color qui reçoit le message yellow (yellow correspond à la couleur jaune en anglais). Chacun des receveurs est souligné.

Un receveur peut être le premier élément d'un message, comme 100 dans l'expression 100 + 200 ou Color (la classe des couleurs) dans l'expression Color yellow. Un objet receveur peut également être le résultat de l'évaluation d'autres messages. Par exemple, dans le message Pen new go: 100, le receveur de ce message go: 100 (littéralement, aller à 100) est l'objet retourné par cette expression Pen new (soit une instance de Pen, la classe crayon). Dans tous les cas, le message est envoyé à un objet appelé le receveur qui a pu être créé par un autre envoi de message.

TABLE 4.1 – Exemples de messages

Expression

Type de messages

Résultat

Color yellow

unaire

Crée une couleur.

aPen go: 100

à mots-clefs

Le crayon receveur se déplace en avant de 100 pixels.

100 + 20

binaire

Le nombre 100 reçoit le message + avec le paramètre 20.

Browser open

unaire

Ouvre un nouveau navigateur de classes.

Pen new go: 100

unaire et à mots-clefs

Un crayon est créé puis déplacé de 100 pixels.

aPen go: 100 + 20

à mots-clefs et binaire

Le crayon receveur se déplace vers l'avant de 120 pixels.

La table 4.1 montre différents exemples de messages. Vous devez remarquer que tous les messages n'ont pas obligatoirement d'arguments. Un message unaire comme open (pour ouvrir) ne nécessite pas d'arguments. Les messages à mots-clefs simples ou les messages binaires comme go: 100 et + 20 ont chacun un argument. Il y a aussi des messages simples et des messages composés. Color yellow et 100 + 20 sont simples : un message est envoyé à un objet, tandis que l'expression aPen go: 100 + 20 est composée de deux messages : + 20 est envoyé à 100 et go:est envoyé à aPen avec pour argument le résultat du premier message. Un receveur peut être une expression qui peut retourner un objet. Dans Pen new go: 100, le message go: 100 est envoyé à l'objet qui résulte de l'évaluation de l'expression Pen new.

4-2. Trois sortes de messages

Smalltalk utilise quelques règles simples pour déterminer l'ordre dans lequel les messages sont envoyés. Ces règles sont basées sur la distinction établie entre les trois formes d'envoi de messages :

  • Les messages unaires sont des messages qui sont envoyés à un objet sans autre information. Par exemple dans 3 factorial, factorial (pour factorielle) est un message unaire.
  • Les messages binaires sont des messages formés avec des opérateurs (souvent arithmétiques). Ils sont binaires car ils ne concernent que deux objets : le receveur et l'objet argument. Par exemple, dans 10 + 20, + est un message binaire qui est envoyé au receveur 10 avec l'argument 20.
  • Les messages à mots-clefs sont des messages formés avec plusieurs mots-clefs, chacun d'entre eux se finissant par deux points (:) et prenant un paramètre. Par exemple, dans anArray at: 1 put: 10, le mot-clef at: prend un argument 1 et le mot-clef put: prend l'argument 10.

4-2-1. Messages unaires

Les messages unaires sont des messages qui ne nécessitent aucun argument. Ils suivent le modèle syntaxique suivant : receveur nomMessage. Le sélecteur est constitué d'une série de caractères ne contenant pas de deux points (:) (par ex., factorial, open, class).

 
Sélectionnez
89 sin       −→ 0.860069405812453
3 sqrt       −→ 1.732050807568877
Float pi     −→ 3.141592653589793
'blop' size  −→ 4
true not     −→ false
Object class −→ Object class "La classe de Object est Object class (!)"

Les messages unaires sont des messages qui ne nécessitent pas d'argument. Ils suivent le moule syntaxique : receveur sélecteur.

4-2-2. Messages binaires

Les messages binaires sont des messages qui nécessitent exactement un argument et dont le sélecteur consiste en une séquence d’un ou plusieurs caractères de l'ensemble : +, -, *, /, &, =, >, |, <, , et @. Notez que -- n'est pas autorisé.

 
Sélectionnez
100@100        −→ 100@100 "crée un objet Point"
3 + 4          −→ 7
10 - 1         −→ 9
4 <= 3         −→ false
(4/3) * 3 = 4  −→ true "l'égalité est juste un message binaire et les fractions sont exactes"
(3/4) == (3/4) −→ false "deux fractions égales ne sont pas le même objet"

Les messages binaires sont des messages qui nécessitent exactement un argument et dont le sélecteur consiste en une séquence d’un ou plusieurs caractères de l'ensemble : +, -, *, /, &, =, >, |, <, , et @. Notez que -- n'est pas autorisé.Ils suivent le moule syntaxique : receveur sélecteur argument.

4-2-3. Messages à mots-clefs

Les messages à mots-clefs sont des messages qui nécessitent un ou plusieurs arguments et dont le sélecteur consiste en un ou plusieurs mots-clefs se finissant par deux points :. Les messages à mots-clefs suivent le moule syntaxique : receveur motUnDuSelecteur: argumentUn motDeuxDuSelecteur: argumentDeux

Chaque mot-clef utilise un argument. Ainsi r:g:b: est une méthode avec 3 arguments, playFileNamed: et at: sont des méthodes avec un argument, et at:put: est une méthode avec deux arguments. Pour créer une instance de la classe Color on peut utiliser la méthode r:g:b: comme dans Color r: 1 g: 0 b: 0 créant ainsi la couleur rouge. Notez que les deux points ne font pas partie du sélecteur.

En Java ou C++, l'invocation de méthode Smalltalk Color r: 1 g: 0 b: 0 serait écrite Color.rgb(1,0,0).

 
Sélectionnez
1 to: 10              −→ (1 to: 10) "création d'un intervalle"
Color r: 1 g: 0 b: 0  −→ Color red  "création d'une nouvelle couleur (rouge)"
12 between: 8 and: 15 −→ true

nums := Array newFrom: (1 to: 5).
nums at: 1 put: 6.
nums −→ #(6 2 3 4 5)

Les messages basés sur les mots-clefs sont des messages qui nécessitent un ou plusieurs arguments. Leurs sélecteurs consistent en un ou plusieurs mots-clefs chacun se terminant par deux points (:). Ils suivent le moule syntaxique : receveur motUnDuSelecteur: argumentUn motDeuxDuSelecteur: argumentDeux

4-3. Composition de messages

Les trois formes d'envoi de messages ont chacune des priorités différentes, ce qui permet de les composer de manière élégante.

  1. Les messages unaires sont envoyés en premier, puis les messages binaires et enfin les messages à mots-clefs.
  2. Les messages entre parenthèses sont envoyés avant tout autre type de messages.
  3. Les messages de même type sont envoyés de gauche à droite.

Ces règles ont un ordre de lecture très naturel. Maintenant si vous voulez être sûr que vos messages sont envoyés dans l'ordre que vous souhaitez, vous pouvez toujours mettre des parenthèses supplémentaires comme dans la figure 4.3. Dans cet exemple, le message yellow est un message unaire et le message color: est un message à mots-clefs ; ainsi l'expression Color yellow est envoyée en premier. Néanmoins, comme les expressions entre parenthèses sont envoyées en premier, mettre des parenthèses (normalement inutiles) autour de Color yellow permet d'accentuer le fait qu'elle doit être envoyée en premier. Le reste de cette section illustre chacun de ces différents points.

Image non disponible
FIGURE 4.3 – Les messages unaires sont envoyés en premier ; donc ici le premier message est Color yellow. Il renvoie un objet de couleur jaune qui est passé comme argument du message aPen color:

4-3-1. Unaire > Binaire > Mots-clefs

Les messages unaires sont d'abord envoyés, puis les messages binaires et enfin les messages à mots-clefs. Nous pouvons également dire que les messages unaires ont une priorité plus importante que les autres types de messages.

Règle une. Les messages unaires sont envoyés en premier, puis les messages binaires et finalement les messages à mots-clefs.
Unaire > Binaire > Mots-clefs

Comme ces exemples suivants le montrent, les règles de syntaxe de Smalltalk permettent d'assurer une certaine lisibilité des expressions :

 
Sélectionnez
1000 factorial / 999 factorial −→ 1000
2 raisedTo: 1 + 3 factorial    −→ 128

Malheureusement, les règles sont un peu trop simplistes pour les expressions arithmétiques. Dès lors, des parenthèses doivent être introduites chaque fois que l'on veut imposer un ordre de priorité entre deux opérateurs binaires :

 
Sélectionnez
1 + 2 * 3   −→ 9
1 + (2 * 3) −→ 7

L'exemple suivant qui est un peu plus complexe ( !) est l'illustration que même des expressions Smalltalk compliquées peuvent être lues de manière assez naturelle :

 
Sélectionnez
[:aClass | aClass methodDict keys select: [:aMethod | (aClass>>aMethod) isAbstract ]]
     value: Boolean −→ an IdentitySet(#or: #| #and: #& #ifTrue: #ifTrue:ifFalse:
     #ifFalse: #not #ifFalse:ifTrue:)

Ici nous voulons savoir quelles méthodes de la classe Boolean (classe des booléens) sont abstraites. Nous interrogeons la classe argument aClass pour récupérer les clefs (grâce au message unaire keys) de son dictionnaire de méthodes (grâce au message unaire methodDict), puis nous en sélectionnons (grâce au message à mots-clefs select:) les méthodes de la classe qui sont abstraites. Ensuite nous lions (par value:) l'argument aClass à la valeur concrète Boolean. Nous avons besoin des parenthèses uniquement pour le message binaire >>, qui sélectionne une méthode d'une classe, avant d'envoyer le message unaire isAbstract à cette méthode. Le résultat (sous la forme d'un ensemble de classes IdentifySet) nous montre quelles méthodes doivent être implémentées par les sous-classes concrètes de Boolean : True et False.

Exemple. Dans le message aPen color: Color yellow, il y a un message unaire yellow envoyé à la classe Color et un message à mots-clefs color: envoyé à aPen. Les messages unaires sont d'abord envoyés, de telle sorte que l'expression Color yellow soit d'abord exécutée (1). Celle-ci retourne un objet couleur qui est passé en argument du message aPen color: aColor(2) comme indiqué dans l'exemple 4.1. La figure 4.3 montre graphiquement comment les messages sont envoyés.

Exemple 4.1 – Décomposition de l’évaluation de aPen color: Color yellow
Sélectionnez
    aPen color: Color yellow
(1)             Color yellow    "message unaire envoyé en premier"
                −→ aColor
(2) aPen color: aColor          "puis le message à mots-clefs"

Exemple. Dans le message aPen go: 100 + 20, il y a le message binaire + 20 et un message à mots-clefs go:. Les messages binaires sont d'abord envoyés avant les messages à mots-clefs, ainsi 100 + 20 est envoyé en premier (1) : le message + 20 est envoyé à l'objet 100 et renvoie le nombre 120. Ensuite le message aPen go: 120 est envoyé avec comme argument 120(2). L'exemple 4.2 nous montre comment l'expression est évaluée.

Exemple 4.2 – Décomposition de aPen go: 100 + 20
Sélectionnez
    aPen go: 100 + 20
(1)          100 + 20   "le message binaire en premier"
             −→ 120
(2) aPen go: 120        "puis le message à mots-clefs"

Image non disponible

Image non disponible

Exemple. Comme exercice, nous vous laissons décomposer l'évaluation du message Pen new go: 100 + 20 qui est composé d'un message unaire, d'un message à mots-clefs et d'un message binaire (voir la figure 4.5).

4-3-2. Les parenthèses en premier

Règle deux. Les messages encadrés de parenthèses sont envoyés avant tout autre message.
(Msg) > Unaire > Binaire > Mots-clefs

 
Sélectionnez
1.5 tan rounded asString = (((1.5 tan) rounded) asString) −→ true "les parenthèses sont nécessaires ici"
3 + 4 factorial −→ 27 "(et pas 5040)"
(3 + 4) factorial −→ 5040

Ici nous avons besoin des parenthèses pour forcer l'envoi de lowMajorScaleOn: avant play.

 
Sélectionnez
(FMSound lowMajorScaleOn: FMSound clarinet) play
"(1) envoie le message clarinet à la classe FMSound pour créer le son de clarinette.
 (2) envoie le son à FMSound comme argument du message à mots-clefs lowMajorScaleOn:.
 (3) joue le son résultant."

Exemple. Le message (65@325 extent: 134@100) center renvoie le centre du rectangle dont le point supérieur gauche est (65, 325) et dont la taille est 134×100. L'exemple 4.3 montre comment le message est décomposé et envoyé. Le message entre parenthèses est d'abord envoyé : il contient deux messages binaires 65@325 et 134@100 qui sont d'abord envoyés et qui renvoient des points et un message à mots-clefs extent: qui est ensuite envoyé et qui renvoie un rectangle. Finalement le message unaire center est envoyé au rectangle et le point central est renvoyé.

Évaluer ce message sans parenthèses déclencherait une erreur, car l'objet 100 ne comprend pas le message center.

 
Sélectionnez
    (65@325 extent: 134@100) center
(1) 65@325                              "binaire"
    −→ aPoint
(2)                  134@100            "binaire"
                     −→ anotherPoint
(3) aPoint extent: anotherPoint         "à mots-clefs"
     −→ aRectangle
(4) aRectangle center                   "unaire"
     −→ 132@375

4-3-3. De gauche à droite

Maintenant, nous savons comment les messages de différentes natures ou priorités sont traités. Il reste une question à aborder : comment les messages de même priorité sont-ils envoyés ? Ils sont envoyés de gauche à droite. Notez que vous avez déjà vu ce comportement dans l'exemple 4.3 dans lequel les deux messages de création de points (@) sont envoyés en premier.

Règle trois. Lorsque les messages sont de même nature, l'ordre d'évaluation est de gauche à droite.

Exemple. Dans l'expression Pen new down, tous les messages sont des messages unaires, donc celui qui est le plus à gauche Pen new est envoyé en premier. Il renvoie un nouveau crayon auquel le deuxième message down (pour poser la pointe du crayon et dessiner) est envoyé comme il est montré dans la figure 4.6.

Image non disponible
FIGURE 4.6 – Décomposition de Pen new down

4-3-4. Incohérences arithmétiques

Les règles de composition des messages sont simples, mais peuvent engendrer des incohérences dans l'évaluation des expressions arithmétiques qui sont exprimées sous forme de messages binaires (nous parlons aussi d'irrationalité arithmétique). Voici des situations habituelles où des parenthèses supplémentaires sont nécessaires.

 
Sélectionnez
3 + 4 * 5     −→ 35 "(pas 23) les messages binaires sont envoyés de gauche à droite"
3 + (4 * 5)   −→ 23
1 + 1/3       −→ (2/3) "et pas 4/3"
1 + (1/3)     −→ (4/3)
1/3 + 2/3     −→ (7/9) "et pas 1"
(1/3) + (2/3) −→ 1
Image non disponible
Image non disponible

Exemple. Dans l'expression 20 + 2 * 5, il y a seulement les messages binaires + et *. En Smalltalk, il n'y a pas de priorité spécifique pour les opérations + et *. Ce ne sont que des messages binaires, ainsi * n'a pas priorité sur +. Ici le message le plus à gauche + est envoyé en premier (1) et ensuite * est envoyé au résultat comme nous le voyons dans l'exemple 4.4.

Exemple 4.4 – Décomposer 20 + 2 * 5
Sélectionnez
"Comme il n'y a pas de priorité entre les messages binaires, le message le plus à
    gauche, + est évalué en premier même si d'après les règles de l'arithmétique le *
    devrait d'abord être envoyé."
    20 + 2 * 5
(1) 20 + 2 −→ 22
(2) 22 * 5 −→ 110

Comme il est montré dans l'exemple 4.4 le résultat de cette expression n'est pas 30, mais 110. Ce résultat est peut-être inattendu, mais résulte directement des règles utilisées pour envoyer des messages. Ceci est le prix à payer pour la simplicité du modèle de Smalltalk. Afin d'avoir un résultat correct, nous devons utiliser des parenthèses. Lorsque les messages sont entourés par des parenthèses, ils sont évalués en premier. Ainsi l'expression 20 + (2 * 5) restitue le résultat comme nous le voyons dans l'exemple 4.5.

Exemple 4.5 – Décomposition de 20 + (2 * 5)
Sélectionnez
"Les messages entourés de parenthèses sont évalués en premier, ainsi 
    * est envoyé avant + afin de produire le comportement souhaité."
    20 + (2 * 5)
(1)      (2 * 5) −→ 10
(2) 20 +    10   −→ 30
FIGURE 4.7 – Messages équivalents en utilisant des parenthèses.
Image non disponible
Image non disponible

En Smalltalk, les opérateurs arithmétiques comme + et * n'ont pas des priorités différentes. + et * ne sont que des messages binaires ; donc * n'a pas priorité sur +. Il faut donc utiliser des parenthèses pour obtenir le résultat désiré.

Notez que la première règle, disant que les messages unaires sont envoyés avant les messages binaires ou à mots-clefs, ne nous force pas à mettre explicitement des parenthèses autour d'eux. La table 4.8 montre des expressions écrites en respectant les règles et les expressions équivalentes si les règles n'existaient pas. Les deux versions engendrent le même effet et renvoient les mêmes valeurs.

FIGURE 4.8 – Des expressions et leurs versions équivalentes avec parenthèses

Priorité implicite

Équivalent explicite avec parenthèses

aPen color : Color yellow

aPen color : (Color yellow)

aPen go: 100 + 20

aPen go: (100 + 20)

aPen penSize: aPen penSize + 2

aPen penSize: ((aPen penSize) + 2)

2 factorial + 4

2 factorial) + 4

4-4. Quelques astuces pour identifier les messages à mots-clefs

Souvent, les débutants ont des problèmes pour comprendre quand ils doivent ajouter des parenthèses. Voyons comment les messages à mots-clefs sont reconnus par le compilateur.

4-4-1. Des parenthèses ou pas ?

Les caractères [, ], and (, ) délimitent des zones distinctes. Dans ces zones, un message à mots-clefs est la plus longue séquence de mots terminés par (:) qui n'est pas coupée par les caractères (.), ou (;). Lorsque les caractères [, ] et (, ) entourent des mots avec des deux-points, ces mots participent au message à mots-clefs local de la zone définie.

Dans cet exemple, il y a deux mots-clefs distincts : rotatedBy:magnify:smoothing: et at:put:.

 
Sélectionnez
aDict
  at: (rotatingForm
      rotateBy: angle
      magnify: 2
      smoothing: 1)
  put: 3

Les caractères [, ] et (, ) délimitent des zones distinctes. Dans ces zones, un message à mots-clefs est la plus longue séquence de mots qui se termine par (:) qui n'est pas coupé par les caractères (.) ou ;. Lorsque les caractères [, ] et (, ) entourent des mots avec des deux-points, ces mots participent au message à mots-clefs local de cette zone.

ASTUCE : si vous avez des problèmes avec ces règles de priorité, vous pouvez commencer simplement en entourant avec des parenthèses chaque fois que vous voulez distinguer deux messages avec la même priorité.

L'expression qui suit ne nécessite pas de parenthèses, car l'expression x isNil est unaire donc envoyée avant le message à mots-clefs ifTrue:.

 
Sélectionnez
(x isNil)
  ifTrue:[...]

L'expression qui suit nécessite des parenthèses, car les messages includes: et ifTrue: sont chacun des messages à mots-clefs.

 
Sélectionnez
ord := OrderedCollection new.
(ord includes: $a)
  ifTrue:[...]

Sans les parenthèses le message inconnu includes:ifTrue: serait envoyé à la collection !

4-4-2. Quand utiliser les [ ] ou les ( ) ?

Vous pouvez avoir des difficultés à comprendre quand utiliser des crochets plutôt que des parenthèses. Le principe de base est que vous devez utiliser des [ ] lorsque vous ne savez pas combien de fois une expression peut être évaluée (peut-être même jamais). [ expression] va créer une fermeture lexicale ou bloc (c.-à-d.. un objet) à partir de expression, qui peut être évaluée autant de fois qu'il le faut (voire jamais) en fonction du contexte.

Ainsi les clauses conditionnelles de ifTrue: ou ifTrue:ifFalse: nécessitent des blocs. Suivant le même principe, à la fois le receveur et l'argument du message whileTrue: nécessitent l'utilisation des crochets, car nous ne savons pas combien de fois le receveur ou l'argument seront exécutés.

Les parenthèses quant à elles n'affectent que l'ordre d'envoi des messages. Aucun objet n'est créé, ainsi dans (expression), expression sera toujours évalué exactement une fois (en supposant que le code englobant l'expression soit évalué une fois).

 
Sélectionnez
[ x isReady ] whileTrue: [ y doSomething ]  "à la fois le receveur et l'argument doivent être des blocs"
4 timesRepeat: [ Beeper beep ]              "l'argument est évalué plus d'une fois, donc doit être un bloc"
(x isReady) ifTrue: [ y doSomething ]       "le receveur n’est évalué qu'une fois, donc n'est pas un bloc"

4-5. Séquences d'expression

Les expressions (c.-à-d.. envois de message, affectations…) séparées par des points sont évaluées en séquence. Notez qu'il n'y a pas de point entre la définition d'une variable et l'expression qui suit. La valeur d'une séquence est la valeur de la dernière expression. Les valeurs renvoyées par toutes les expressions excepté la dernière sont ignorées. Notez que le point est un séparateur et non un terminateur d'expression. Le point final est donc optionnel.

 
Sélectionnez
| box |
box := 20@30 corner: 60@90.
box containsPoint: 40@50 −→ true

4-6. Cascades de messages

Smalltalk offre la possibilité d'envoyer plusieurs messages au même receveur en utilisant le point-virgule (;). Dans le jargon Smalltalk, nous parlons de cascade.

Expression Msg1 ; Msg2

 
Sélectionnez
Transcript show: 'Pharo est '.
Transcript show: 'extra '.
Transcript cr.

est équivalent à :

 
Sélectionnez
Transcript
  show: 'Pharo est';
  show: 'extra ';
  cr

Notez que l'objet qui reçoit la cascade de messages peut également être le résultat d'un envoi de message. En fait, le receveur de la cascade est le receveur du premier message de la cascade. Dans l'exemple qui suit, le premier message en cascade est setX:setY puisqu'il est suivi du point-virgule. Le receveur du message cascadé setX:setY: est le nouveau point résultant de l'évaluation de Point new et non pas Point. Le message qui suit isZero (pour tester s'il s'agit de zéro) est envoyé au même receveur.

 
Sélectionnez
Point new setX: 25 setY: 35; isZero −→ false

4-7. Résumé du chapitre

  • Un message est toujours envoyé à un objet nommé le receveur qui peut être le résultat d'autres envois de messages.
  • Les messages unaires sont des messages qui ne nécessitent pas d'arguments. Ils sont de la forme receveur sélecteur.
  • Les messages binaires sont des messages qui concernent deux objets, le receveur et un autre objet et dont le sélecteur est composé d’un ou deux caractères de la liste suivante : +, -, *, /, |, &, =, >, <, ~ et @. Ils sont de la forme : receveur sélecteur argument.
  • Les messages à mots-clefs sont des messages qui concernent plus d'un objet et qui contiennent au moins un caractère deux-points (:). Ils sont de la forme : receveur motUnDuSelecteur: argumentUn motDeuxDuSelecteur: argumentDeux.
  • Règle un. Les messages unaires sont d'abord envoyés, puis les messages binaires et finalement les messages à mots-clefs.
  • Règle deux. Les messages entre parenthèses sont envoyés avant tous les autres.
  • Règle trois. Lorsque les messages sont de même nature, l'ordre d'évaluation est de gauche à droite.
  • En Smalltalk, les opérateurs arithmétiques traditionnels comme + ou * ont la même priorité. + et * ne sont que des messages binaires ; donc * n'a aucune priorité sur +. Vous devez utiliser les parenthèses pour obtenir un résultat différent.

précédentsommaire

Licence Creative Commons
Le contenu de cet article est rédigé par Andrew Black et est mis à disposition selon les termes de la Licence Creative Commons Attribution 3.0 non transposé.
Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright © 2013 Developpez.com.