Smalltalk and Object Orientation: an Introduction - Free

The brackets round the 1 to: 10 are required, because we create an interval object with the range 1 to
10 which is sent the message do: with a block as its parameter. However, it has exactly the same effect
as the C version presented above.
It should be noted that what is happening here is that the block object passed as the parameter to the
do: message actually takes a parameter itself. In fact it is passed the values 1 through 10 in turn. Each
value is the n bound to the block variable n. This is achieved by sending the message value: with a
different element of the interval to the block within the do: message.
In situations where you merely require a piece of code to execute a given number of times, witho ut
the requirement to reference any loop variable, it is possible to use a very simple control structure. This
structure is the timesRepeat: message. This message is sent to an integer and causes the associated
block to be executed n times, where n is the integer the message is sent to. For example:
10 timesRepeat: [Transcript show: 'Hello'; cr.].
this will cause Hello to be printed ten times in the Transcript window.
Blocks with arguments are also used to implement functions to be applied to all element
structure. For example (using an array):
s of a data
sum : = 0.
#(3 5 8 4 6) do:
[:item | total := total + ( item * item )]
The variable item takes the value of each element in the array. The result of these expressions is the
sum of the squares of the values in the array. This is a very useful construct.
9.4.3 While loops
The while loop exists in almost all programming languages. In most cases it has a basic form such as:
while (expression)
statement
Because in Smalltalk a while loop is achieved by sending a message to an expression the format is
slightly different. In Smalltalk the basic format is:
[condition] whileMessage:
[statements]
where condition is the control expression in the form of a Block Context. Statements are the controlled
set of Smalltalk code also in a block context. The control of this statement is determined by the
whileMessage that can actually take a number of forms which will be discussed below.
The basic while messages are the whileTrue: and whileFalse: messages. For the
whileTrue: message, if the value of the control expression in the receiving block is true, then the
controlled statements are executed. After this the control expression is evaluated again and so on. T his
is actually achieved in Smalltalk by sending the receiver block the message value; if the response is
true, then the argument block is sent the message value. This repeats until the receiver block answers
false.
For example:
C Version
Smalltalk Version
n = 1; n := 1.
while (n