All you need to know about real money blackjack: https://onlineblackjack.money
 
DelphiBasics
  Home  |  Repeating sets of commands
 Documents
 Tutorials

 Writing your first program
 Writing your second program
 Amending this program
 
 Delphi data types
   Numbers
   Text
   Sets and enumerations
   Arrays
   Records
 
 Programming logic
   Looping
   SubRoutines
   Exception handling
 
 Dates and times
 
 Files
 
 Pointers
 
 Printing text and graphics
 
 Object Orientation basics
   Memory leaks!
   Inheritance
   Abstraction
   Interfaces
   An example class
 
 References

 Standard components
 
 Articles

 Learn to program in Pascal - online education course

 Castalia for Delphi
 A brief history of Delphi
 
 Usability : file handling
 Usability : reference books
 
 Author links

Buy Website Traffic at
 Buywebsitetrafficexperts.com

Buy Proxies at
 Buyproxies.io
 
  Repeating sets of commands
Why loops are used in programming
One of the main reasons for using computers is to save the tedium of many repetitive tasks. One of the main uses of loops in programs is to carrry out such repetitive tasks. A loop will execute one or more lines of code (statements) as many times as you want.
 
Your choice of loop type depends on how you want to control and terminate the looping.
 

The For loop
This is the most common loop type. For loops are executed a fixed number of times, determined by a count. They terminate when the count is exhausted. The count (loop) is held in a variable that can be used in the loop. The count can proceed upwards or downwards, but always does so by a value of 1 unit. This count variable can be a number or even an enumeration.
 
Counting up
Here is a simple example counting up using numeric values:
 
 var
   count : Integer;
 begin
   For count := 1 to 5 do
     ShowMessageFmt('Count is now %d',[count]);
 end;

 Count is now 1
 Count is now 2
 Count is now 3
 Count is now 4
 Count is now 5

The ShowMessageFmt routine is useful for displaying information - click on it to read more.
 
Counting up using an enumeration
Enumerations (see Enumeration and sets to explore) are very readable ways of assigning values to variables by name. They can also be used to control For loops:
 
 type
   TWeekDay = (Monday=1, Tuesday, Wednesday, Thursday, Friday);
 var
   weekday : TWeekDay;
   hours   : array[TWeekDay] of byte;
 begin
   // Set up the hours every day to zero
   for weekDay := Monday to Friday do
     hours[weekDay] := 0;
 
   // Add an hour of overtime to the working hours on Tuesday to Thursday
   for weekDay := Tuesday to Thursday do
     Inc(hours[weekDay]);
 end;

 hours[Monday]    = 0
 hours[Tuesday]   = 1
 hours[Wednesday] = 1
 hours[Thursday]  = 1
 hours[Friday]    = 0

Note the use of the Inc routine to increment the hours.
 
Counting down, using characters
We can also use single letters as the count type, because they are also ordinal types:
 
 var
   letter : Char;
 begin
   for letter := 'G' downto 'A' do
     ShowMessage('Letter = '+letter)
 end;

 Letter = G
 Letter = F
 Letter = E
 Letter = D
 Letter = C
 Letter = B
 Letter = A

The For statements in the examples above have all executed one statement. If you want to execute more than one, you must enclose these in a Begin and End pair.
 

The Repeat loop
The Repeat loop type is used for loops where we do not know in advance how many times we will execute. For example, when we keep asking a user for a value until one is provided, or the user aborts. Here, we are more concerned with the loop termination condition.
 
Repeat loops always execute at least once. At the end, the Until condition is checked, and the loop aborts of condition works out as true.
 
A simple example
 var
   exit : Boolean;          // Our exit condition flag
   i : Integer;
 begin
   i := 1;
   exit := False;           // do not exit until we are ready
   repeat
     Inc(i);                // Increment a count
     if Sqr(i) > 99
     then exit := true;     // Exit if the square of our number exceeds 99
   until exit;              // Shorthand for 'until exit := true'
 end;

 Upon exit, i will be 10 (since Sqr(10) > 99)

Here we exit the repeat loop when a Boolean variable is true. Notice that we use a shorthand - just specifying the variable as the condition is sufficient since the variable value is either true or false.
 
Using a compound condition
 var
   i : Integer;
 begin
   i := 1;
   repeat
     Inc(i);                // Increment a count
   until (Sqr(i) > 99) or (Sqrt(i) > 2.5);
 end;

 Upon exit, i will be 7 (since Sqrt(7) > 2.5)

Notice that compound statements require separating brackets. Notice also that Repeat statements can accomodate multiple statements without the need for a begin/end pair. The repeat and until clauses form a natural pairing.
 

While loops
While loops are very similar to Repeat loops except that they have the exit condition at the start. This means that we use them when we wish to avoid loop execution altogether if the condition for exit is satisfied at the start.
 
 var
   i : Integer;
 begin
   i := 1;
   while (Sqr(i) <= 99) and (Sqrt(i) <= 2.5) do
     Inc(i);                // Increment a count
 end;

 Upon exit, i will be 7 (since Sqrt(7) > 2.5)

Notice that our original Repeat Until condition used Or as the compound condition joiner - we continued until either condition was met. With our While condition, we use And as the joiner - we continue whilst neither condition is met. Have a closer look to see why we do this. The difference is that we repeat an action until something or something else happens. Whereas we keep doing an action while neither something nor something else have happened.
 
 
 

Delphi Basics Neil Moffatt 2002 - 2016. All rights reserved.  |  Home Page