Stage 1 · Code

Variables, Types & Control Flow

for Loops

Go has only one loop keyword — for — but it covers every looping pattern you need: counted, condition-only, range, and infinite.

7 min readProgramming Foundations (Go)Code

The Counted for Loop

The classic three-part for has an initializer, a condition, and a post statement separated by semicolons. The initializer runs once, the condition is checked before every iteration, and the post statement runs after each body.

Gocounted-loop:-0-to-4.go

19 linesLn 1, Col 1Go

The variable declared in the init clause (`i`, `n`) is scoped to the loop. It disappears after the loop body ends.

Go has only one loop keyword

There is no while, do-while, or foreach in Go. The single for keyword handles all patterns. This keeps the language small and consistent — once you know for, you know every loop.

Condition-Only Loop

When you omit the init and post statements, for becomes a while-style loop that runs as long as the condition is true. Omit the condition entirely to write an infinite loop — pair it with break to exit.

Gowhile-style-and-infinite-loops.go

23 linesLn 1, Col 1Go

`for { }` (no condition) loops forever. This is the standard way to write servers, event loops, and background workers that keep running until explicitly stopped.

range Loops

range iterates over slices, arrays, maps, strings, and channels. It yields an index and a value on each iteration. You can discard either with the blank identifier _.

Gorange-over-slice-and-map.go

33 linesLn 1, Col 1Go

The blank identifier `_` explicitly says 'I know there is a value here, but I do not need it.' Using `_` is better style than leaving the name unused, which would be a compile error.

Gorange-over-a-string-gives-runes.go

17 linesLn 1, Col 1Go

Ranging over a string is the safe way to process Unicode text. It handles multi-byte characters correctly. `len(word)` would give the byte count, not the character count.

break and continue

break exits the innermost loop immediately. continue skips the rest of the current iteration and jumps to the next one. Both can be used with labels to target outer loops when you have nested loops.

Gobreak-and-continue.go

36 linesLn 1, Col 1Go

Labels are written before the `for` keyword. `break outer` exits the labeled loop entirely, not just the inner one. Use labels sparingly — they are sometimes the clearest solution for nested loops.

Nested Loops

You can place a loop inside another loop. The inner loop runs to completion for every single iteration of the outer loop. Nested loops are commonly used for grids, tables, and pair-wise comparisons.

Gomultiplication-table-with-nested-loops.go

16 linesLn 1, Col 1Go

The inner loop runs `size` times for each of the `size` outer iterations — `5 × 5 = 25` iterations total. `%4d` right-aligns each number in a field of 4 characters.

Watch out for O(n²) loops

Every nested loop multiplies the work. Two loops over 1,000 items each means 1,000,000 iterations. For most small programs this is fine, but as you advance you will learn to reach for maps or sort-based approaches instead of checking every possible pair.

for init; cond; post {} — counted loop with a control variable.
for cond {} — while-style; runs as long as the condition is true.
for {} — infinite loop; use break or return to exit.
for i, v := range slice {} — iterates with index and value.
for _, v := range slice {} — discards the index with _.
break exits the loop; continue jumps to the next iteration.
Labels allow break and continue to target an outer loop.

Mark this lesson complete to store local progress and unlock a cleaner resume path the next time you visit.