Control flow

The Fundamentals track covers control flow as the skeleton of any program: decisions, repetition, and early exits. Go's take is deliberately minimal. There is no while keyword, no do/while, no repeat/until. Everything that involves repetition uses the single keyword for. This might sound limiting, but it means you have fewer things to remember — and once you see the three forms, you'll have everything you need.

if / else

Go's if statement looks familiar:

score := 85

if score >= 90 {
    fmt.Println("A")
} else if score >= 80 {
    fmt.Println("B")
} else {
    fmt.Println("C or below")
}

Two things differ from C or Java:

1. No parentheses around the condition. The Go formatter (go fmt) removes them if you write them.
2. Braces are required — you cannot write a single-line if without braces.

The init statement

Go's if has an optional init statement separated from the condition by a semicolon. The init statement runs first, and any variable it declares is scoped to the if/else block:

if err := doSomething(); err != nil {
    fmt.Println("failed:", err)
    return
}
// err is not in scope here

This pattern appears constantly in Go — call a function, capture the error, and handle it, all in one line. The variable err disappears after the block ends, which keeps the namespace clean.

for — Go's only loop

Go has one loop keyword: for. It handles every looping pattern.

Form 1: traditional (init; condition; post)

for i := 0; i < 5; i++ {
    fmt.Println(i)   // 0 1 2 3 4
}

Identical to a C for loop. The init statement, condition, and post statement are all optional.

Form 2: condition only (while equivalent)

Omit the init and post to get a while loop:

n := 1
for n < 100 {
    n *= 2
}
fmt.Println(n)   // 128

Form 3: infinite loop

Omit the condition entirely to loop forever. Use break to exit:

for {
    input := readInput()
    if input == "quit" {
        break
    }
    process(input)
}

continue skips the rest of the loop body and moves to the next iteration. Both break and continue work the same in all three forms.

range — iterating over collections

The most common loop in real Go programs uses range to iterate over a slice, string, or map:

fruits := []string{"apple", "banana", "cherry"}
for i, fruit := range fruits {
    fmt.Printf("%d: %s\n", i, fruit)
}

range returns two values: the index and the element. If you only need the element, discard the index with _:

for _, fruit := range fruits {
    fmt.Println(fruit)
}

If you only need the index (for example, to modify elements in place), just omit the second variable:

for i := range fruits {
    fruits[i] = strings.ToUpper(fruits[i])
}

Ranging over a map gives you key-value pairs (in random order — Go map iteration is deliberately non-deterministic):

ages := map[string]int{"Alice": 30, "Bob": 25}
for name, age := range ages {
    fmt.Printf("%s is %d\n", name, age)
}

switch

switch dispatches on a value and matches the first case that equals it:

day := "Tuesday"
switch day {
case "Monday", "Tuesday", "Wednesday", "Thursday", "Friday":
    fmt.Println("Weekday")
case "Saturday", "Sunday":
    fmt.Println("Weekend")
default:
    fmt.Println("Unknown day")
}

Key differences from C/Java switch:

• No fallthrough by default. Each case ends automatically — no break needed. If you genuinely want fallthrough to the next case, write fallthrough explicitly (rare).
• Multiple values per case separated by commas.
• No condition needed — a switch with no expression acts like a chain of if/else if:

x := 42
switch {
case x < 0:
    fmt.Println("negative")
case x == 0:
    fmt.Println("zero")
default:
    fmt.Println("positive")
}

Check your understanding

Do it yourself

Write a program that:

1. Uses a for loop with range to iterate over []int{3, 7, 2, 9, 1, 5}.
2. Tracks the running maximum.
3. Prints the maximum after the loop.

Then rewrite the same logic using a traditional for i := 0; ... loop and confirm you get the same answer.

go run main.go
go fmt ./...
go vet ./...

Where to go next

You can make decisions, loop in all the ways you need, and dispatch on values cleanly. Next: arrays, slices, and maps — Go's built-in collection types and the operations that make them useful.