Repetition

Computers are good at doing the same thing a million times without getting bored. A loop repeats a block of code; each run through the block is an iteration. Almost every useful program has one, whether it is summing a column, reading lines from a file or waiting for a button press.

Two kinds of loop

A conditional loop repeats while a condition is true. You may not know in advance how many times that will be: keep asking until the password is right, keep halving until the number is small.

A counted loop repeats a known number of times, or once for every item in some collection: do this ten times, do this for each name in the list.

Every language has the conditional kind (while). Counted loops are usually a separate for, and its spelling is where the languages differ most. Python and modern JavaScript loop over a range or a collection directly. C, Java and older JavaScript use the three-part form for (start; test; step).

A conditional loop is the more general tool: any counted loop can be written as a while with a counter variable. The for form exists because it puts the start, the stopping test and the step in one place where you can check them at a glance.

A first loop

This program uses both kinds. The for adds the numbers 1 to 5; the while counts down from 3.

total = 0
for n in range(1, 6):
    total += n
print("sum 1..5 =", total)

count = 3
while count > 0:
    print("countdown", count)
    count -= 1
print("liftoff")

let total = 0;
for (let n = 1; n <= 5; n++) {
  total += n;
}
console.log("sum 1..5 =", total);

let count = 3;
while (count > 0) {
  console.log("countdown", count);
  count -= 1;
}
console.log("liftoff");

public class LoopsSum {
    public static void main(String[] args) {
        int total = 0;
        for (int n = 1; n <= 5; n++) {
            total += n;
        }
        System.out.println("sum 1..5 = " + total);

        int count = 3;
        while (count > 0) {
            System.out.println("countdown " + count);
            count -= 1;
        }
        System.out.println("liftoff");
    }
}

#include <stdio.h>

int main(void) {
    int total = 0;
    for (int n = 1; n <= 5; n++) {
        total += n;
    }
    printf("sum 1..5 = %d\n", total);

    int count = 3;
    while (count > 0) {
        printf("countdown %d\n", count);
        count -= 1;
    }
    printf("liftoff\n");
    return 0;
}

Each prints:

sum 1..5 = 15
countdown 3
countdown 2
countdown 1
liftoff

In the three-part for, int n = 1 runs once at the start, n <= 5 is tested before every iteration, and n++ (add one to n) runs after each. Python’s range(1, 6) produces 1, 2, 3, 4, 5 and does all of that bookkeeping for you.

The while loop has a pattern worth memorising. Three things must be true for it to behave: the counter starts at a sensible value (count = 3), the condition tests it (count > 0), and the body changes it (count -= 1). Leave out the last one and you have an infinite loop.

Controlling a loop from inside

Two keywords change the flow within the body. continue abandons the current iteration and jumps to the next. break ends the loop altogether.

This loop skips even numbers with continue and quits early with break:

for n in range(1, 10):
    if n % 2 == 0:
        continue
    if n > 7:
        break
    print("odd and at most 7:", n)

for (let n = 1; n < 10; n++) {
  if (n % 2 === 0) {
    continue;
  }
  if (n > 7) {
    break;
  }
  console.log("odd and at most 7:", n);
}

public class LoopControl {
    public static void main(String[] args) {
        for (int n = 1; n < 10; n++) {
            if (n % 2 == 0) {
                continue;
            }
            if (n > 7) {
                break;
            }
            System.out.println("odd and at most 7: " + n);
        }
    }
}

#include <stdio.h>

int main(void) {
    for (int n = 1; n < 10; n++) {
        if (n % 2 == 0) {
            continue;
        }
        if (n > 7) {
            break;
        }
        printf("odd and at most 7: %d\n", n);
    }
    return 0;
}

All four print:

odd and at most 7: 1
odd and at most 7: 3
odd and at most 7: 5
odd and at most 7: 7

Even values hit continue and never reach the print. At n = 9 the break ends the loop. Notice the stop value: range(1, 10) and n < 10 both stop before 10.

A conditional loop is the right tool when the number of passes is not known in advance. How many times can you halve 100 before reaching 1?

number = 100
steps = 0
while number > 1:
    number = number // 2
    steps += 1
print("halvings until 1:", steps)

let number = 100;
let steps = 0;
while (number > 1) {
  number = Math.floor(number / 2);
  steps += 1;
}
console.log("halvings until 1:", steps);

public class Halvings {
    public static void main(String[] args) {
        int number = 100;
        int steps = 0;
        while (number > 1) {
            number = number / 2;
            steps += 1;
        }
        System.out.println("halvings until 1: " + steps);
    }
}

#include <stdio.h>

int main(void) {
    int number = 100;
    int steps = 0;
    while (number > 1) {
        number = number / 2;
        steps += 1;
    }
    printf("halvings until 1: %d\n", steps);
    return 0;
}

All four print halvings until 1: 6 (100, 50, 25, 12, 6, 3, 1). The last loop shape is while true with a break: loop until a condition inside the body says stop.

guess = 1
while True:
    if guess * guess > 50:
        break
    guess += 1
print("first number whose square exceeds 50:", guess)

let guess = 1;
while (true) {
  if (guess * guess > 50) {
    break;
  }
  guess += 1;
}
console.log("first number whose square exceeds 50:", guess);

public class SquareSearch {
    public static void main(String[] args) {
        int guess = 1;
        while (true) {
            if (guess * guess > 50) {
                break;
            }
            guess += 1;
        }
        System.out.println("first number whose square exceeds 50: " + guess);
    }
}

#include <stdio.h>

int main(void) {
    int guess = 1;
    while (1) {
        if (guess * guess > 50) {
            break;
        }
        guess += 1;
    }
    printf("first number whose square exceeds 50: %d\n", guess);
    return 0;
}

All four print first number whose square exceeds 50: 8.

Use break and continue for exceptional cases, not as the main structure. If a loop has three breaks scattered through it, a clearer condition at the top is usually better. The while true loop is the honest exception: when the natural place to decide is the middle of the body, an explicit exit is easier to read than contorting the condition.

Off-by-one errors and invariants

The most common loop bug has a name: the off-by-one error. You loop one time too many or too few. In the continue example above, n < 10 stopped before 10, because in most languages’ ranges the start is included and the stop is excluded. Python’s range(1, 5) gives 1 to 4. Writing n <= 5 versus n < 5 in the three-part form is the same decision.

A habit that prevents these: state the loop’s invariant, a sentence that is true before the loop starts and after every iteration. In the for loop that sums 1 to 5, the invariant is “total is the sum of the numbers handled so far”. Before the loop it holds trivially (nothing handled, total 0). Each iteration keeps it true. When the loop ends, “handled so far” means “all of them”, so the invariant becomes the answer. If you cannot state an invariant, you probably do not yet know what the loop is for.

A second habit: test the smallest cases. What does the loop do for zero iterations? For exactly one?

Infinite loops

If the condition never becomes false, the program never ends. Sometimes this is intended (a server waits for requests forever). Usually it is a bug: the counter was never updated, or it moves away from the stopping value. If a program is stuck in the terminal you met in tools of the trade, press Ctrl+C to interrupt it.

Common pitfalls

• Off by one. Is the stop value included? Check against the smallest case.
• Forgetting to update the loop variable in a while, which never ends.
• Changing a collection while looping over it. Adding or removing items mid-loop skips elements or loops forever. Build a new collection instead.
• Using a floating-point counter. A step of 0.1 accumulates rounding error, so x == 1.0 may never be true. Count with integers and divide.
• Declaring the accumulator inside the loop. total = 0 inside the body resets it every time, and you are left with only the last value.
• Reaching for break too early, when a better loop condition would say the same thing in one line.

number = 4821
total = 0
while number > 0:
    total += number % 10   # the last digit
    number = number // 10  # drop the last digit
print(total)

let number = 4821;
let total = 0;
while (number > 0) {
  total += number % 10;              // the last digit
  number = Math.floor(number / 10);  // drop the last digit
}
console.log(total);

public class DigitSum {
    public static void main(String[] args) {
        int number = 4821;
        int total = 0;
        while (number > 0) {
            total += number % 10;   // the last digit
            number = number / 10;   // drop the last digit
        }
        System.out.println(total);
    }
}

#include <stdio.h>

int main(void) {
    int number = 4821;
    int total = 0;
    while (number > 0) {
        total += number % 10;   /* the last digit */
        number = number / 10;   /* drop the last digit */
    }
    printf("%d\n", total);
    return 0;
}

15

*
**
***
****

rows = 4
for row in range(1, rows + 1):
    print("*" * row)

const rows = 4;
for (let row = 1; row <= rows; row++) {
  let line = "";
  for (let star = 0; star < row; star++) {
    line += "*";
  }
  console.log(line);
}

public class Triangle {
    public static void main(String[] args) {
        int rows = 4;
        for (int row = 1; row <= rows; row++) {
            for (int star = 0; star < row; star++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

#include <stdio.h>

int main(void) {
    int rows = 4;
    for (int row = 1; row <= rows; row++) {
        for (int star = 0; star < row; star++) {
            printf("*");
        }
        printf("\n");
    }
    return 0;
}

for n in range(1, 10):
    print(n)

for (let n = 1; n < 10; n++) {
  console.log(n);
}

for (int n = 1; n < 10; n++) {
    System.out.println(n);
}

for (int n = 1; n < 10; n++) {
    printf("%d\n", n);
}

for n in range(1, 11):
    print(n)

for (let n = 1; n <= 10; n++) {
  console.log(n);
}

public class CountToTen {
    public static void main(String[] args) {
        for (int n = 1; n <= 10; n++) {
            System.out.println(n);
        }
    }
}

#include <stdio.h>

int main(void) {
    for (int n = 1; n <= 10; n++) {
        printf("%d\n", n);
    }
    return 0;
}

Summary

• A loop repeats a block; each run is an iteration.
• Use a counted loop when you know the number of passes or have a collection to walk through, and a conditional loop when you do not.
• A while loop needs a sensible start, a test and a change that moves towards stopping.
• break leaves a loop and continue skips to the next iteration; use them sparingly.
• Stating the loop invariant and testing zero and one iterations catches most off-by-one errors.

Next: Functions, where you give a block of code a name and reuse it.