A for loop is a control flow statement for specifying iteration, which allows code to be executed repeatedly. A for loop has two parts: a header specifying the iteration, and a body which is executed once per iteration. The header often declares an explicit loop counter or loop variable, which allows the body to know which iteration is being executed. For loops are typically used when the number of iterations is known before entering the loop. For loops can be thought of as shorthands for while loops which increment and test a loop variable.
Introduction to Test Before Loops
There are two commonly used test before loops in the iteration (or repetition) category of control structures. They are: while and for. This module covers the: for.
Understanding Iteration in General – for
In many programming languages, the for loop is used exclusively for counting; that is to repeat a loop action as it either counts up or counts down. There is a starting value and a stopping value. The question that controls the loop is a test expression that compares the starting value to the stopping value. This expression is a Boolean expression and is usually using the relational operators of either less than (for counting up) or greater than (for counting down). The term loop comes from the circular looping motion that occurs when using flowcharting. The basic form of the for loop (counting up) is as follows:
for initialization of the starting value starting value is less than the stopping value some statements or action some statements or action some statements or action increment the starting value
It might be best to understand the for loop by understanding a while loop acting like a counting loop. Let’s consider;
initialization of the starting value while the starting value is less than the stopping value some statements or action some statements or action some statements or action increment the starting value
Within the for control structure, there are four attributes to a properly working loop. They are:
- Initializing the flag – done once
- Test expression
- Action or actions
- Update of the flag
The initialization of the flag is not technically part of the while control structure, but it is usually part of the for control structure. The English phrasing is, “For x is 1; x less than 3; do the following actions; increment x; loop back to the test expression”. This is doing the action on the true. When the test expression is false, you stop the loop and go on with the next item in the program. Notice, because this is a test before loop the action might not happen. It is called a test before loop because the test comes before the action. It is also sometimes called a pre-test loop, meaning the test is pre (or Latin for before) the action and update.
For counter = 0, counter < 5, counter += 1 Output "I love ice cream!"
The four attributes of a test before loop (remember the for loop is one example of a test before loop) are present.
- The initialization of the flag to a value of 0.
- The test is the less than relational comparison of the value in the flag variable to the constant value of 5.
- The action part consists of the 1 line of output.
- The update of the flag is done with the increment operator.
Using indentation with the alignment of the loop actions is the normal industry practice.
At this point, it is worth mentioning that good programming always provides for a method to ensure that the loop question will eventually be false so that the loop will stop executing and the program continues with the next line of code. However, if this does not happen, then the program is in an infinite loop. Infinite loops are a bad thing. Consider the following code:
For counter = 0, counter < 5 Output "I love ice cream!"
The programmer assigned a value to the flag during the initialization step which is correct. However, they forgot to update the flag (the update step is missing). Every time the test expression is asked it will always be true. Thus, an infinite loop because the programmer did not provide a way to exit the loop (he forgot to update the flag).
- A test before iteration control structure typically used for counting.