19. Nested loops

A loop repeats a block. What if that block holds another loop? That is a nested loop: the inner one runs fully on every round of the outer one. Nested loops build grids, tables, and anything with rows and columns.

A loop inside a loop

Put one for inside another. The inner loop finishes before the outer one moves:

for outer := 1; outer <= 3; outer++ {
    for inner := 1; inner <= 2; inner++ {
        fmt.Println(outer, inner)
    }
}

Output:

1 1
1 2
2 1
2 2
3 1
3 2

Follow the order. While outer is 1, the inner loop runs (1, 2). Then outer becomes 2 and it runs again. That is 3 × 2 = 6 runs.

for i := 1; i <= 2; i++ {
    for i := 1; i <= 2; i++ {
        fmt.Println("inner", i)
    }
    fmt.Println("outer", i)
}

inner 1
inner 2
outer 1
inner 1
inner 2
outer 2

Building a row at a time

One value per line rarely suits a grid. The usual trick: the outer loop handles rows; the inner loop builds one string, printed when the row is done. += adds to the string, and strconv.Itoa from Chapter 14 turns each number into text:

for row := 1; row <= 3; row++ {
    line := ""
    for col := 1; col <= 3; col++ {
        line += strconv.Itoa(row*col) + "\t"
    }
    fmt.Println(line)
}

Output (a 3×3 multiplication grid):

1       2       3
2       4       6
3       6       9

Notice line := "" sits inside the outer loop but outside the inner one. It resets each row, fills up in the inner loop, then prints. The "\t" from Chapter 12 puts a tab after each number, which lines up the columns.

A triangle with a changing inner loop

The inner loop's condition can depend on the outer variable. Run it from 1 to row and you get a triangle:

for row := 1; row <= 4; row++ {
    line := ""
    for star := 1; star <= row; star++ {
        line += "*"
    }
    fmt.Println(line)
}

Output:

*
**
***
****

Row 1 runs the inner loop once; row 4 runs it four times. The shape comes from the maths.

How many times does the body run?

Multiply the counts. An outer loop of 10 around an inner loop of 10 runs the body 10 × 10 = 100 times. It grows fast: three loops of 100 each is a million runs. A computer handles a million simple runs quickly, but the count is worth working out before you add another level.

Homework

Homework starters are in exercises/19/homework/. Each one runs as it is and prints a placeholder line.

#####
#####
#####

Stuck or finished? Open the homework solutions page.