Control Flow

if statements (with a twist)

Standard if/else if/else works exactly as you expect - just drop the parentheses around the condition and add braces:

if x > 10:
    print("big")
elif x > 0:
    print("small")
else:
    print("zero or negative")

if x > 10 {
    fmt.Println("big")
} else if x > 0 {
    fmt.Println("small")
} else {
    fmt.Println("zero or negative")
}

The if-with-init form

Go adds a syntax Python has no equivalent for. You can run a short statement before the condition, and the variable it declares is scoped to the entire if/else block:

// Standard form - val declared before, lives in outer scope
val, err := getValue()
if err != nil {
    log.Fatal(err)
}

// if-with-init - val and err scoped to this block only
if val, err := getValue(); err != nil {
    log.Fatal(err)
} else {
    fmt.Println("got:", val)
}
// val and err are gone here - out of scope

You see this constantly in Go code. It keeps error-handling variables from polluting the surrounding scope. The pattern is:

if <init statement>; <condition> {
    // body
}

for: the ONLY loop

Go deleted while, do-while, and until. There is only for. But for has four distinct forms that cover all those cases:

# C-style (no direct equiv - use range)
for i in range(10):
    print(i)

# while loop
while x < 100:
    x *= 2

# infinite loop
while True:
    break

# for-each
for item in items:
    print(item)

// C-style
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

// while-style
for x < 100 {
    x *= 2
}

// infinite loop
for {
    break
}

// range (for-each)
for _, item := range items {
    fmt.Println(item)
}

range: iterating over things

range is not a function - it is a language keyword that iterates over slices, maps, strings, and channels. It always returns up to two values. You choose which ones you want:

xs := []string{"a", "b", "c"}

// index AND value
for i, v := range xs {
    fmt.Println(i, v) // 0 a, 1 b, 2 c
}

// just the index (ignore value)
for i := range xs {
    fmt.Println(i) // 0, 1, 2
}

// just the value (blank identifier discards index)
for _, v := range xs {
    fmt.Println(v) // a, b, c
}

// maps: key + value
m := map[string]int{"x": 1, "y": 2}
for k, v := range m {
    fmt.Printf("%s=%d\n", k, v)
}

items = ["a", "b", "c"]

# index + value
for i, v in enumerate(items):
    print(i, v)

# just values
for v in items:
    print(v)

# dict key + value
for k, v in d.items():
    print(k, v)

items := []string{"a", "b", "c"}

// index + value
for i, v := range items {
    fmt.Println(i, v)
}

// just values
for _, v := range items {
    fmt.Println(v)
}

// map key + value
for k, v := range m {
    fmt.Printf("%s=%v\n", k, v)
}

switch: smarter than C

Go's switch looks like C's but behaves much better. The key difference: no fallthrough by default. Each case breaks automatically. This is the opposite of C and Java.

Standard switch

switch day {
case "Monday":
    fmt.Println("start of the week")
case "Friday":
    fmt.Println("almost there")
case "Saturday", "Sunday":    // multiple values per case
    fmt.Println("weekend")
default:
    fmt.Println("midweek")
}

Tagless switch (like if/else if)

Leave out the expression after switch and each case becomes an arbitrary boolean condition - a clean replacement for long if/else chains:

switch {
case score >= 90:
    grade = "A"
case score >= 80:
    grade = "B"
case score >= 70:
    grade = "C"
default:
    grade = "F"
}

Type switch

Switch on the concrete type of an interface value - this is how Go does dynamic dispatch cleanly:

func describe(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("int: %d\n", v)
    case string:
        fmt.Printf("string: %q\n", v)
    case bool:
        fmt.Printf("bool: %v\n", v)
    default:
        fmt.Printf("unknown: %T\n", v)
    }
}

match status:
    case 200:
        result = "ok"
    case 404:
        result = "not found"
    case 500:
        result = "error"
    case _:
        result = "other"

switch status {
case 200:
    result = "ok"
case 404:
    result = "not found"
case 500:
    result = "error"
default:
    result = "other"
}

defer: the LIFO superpower

defer schedules a function call to run when the enclosing function returns - no matter how it returns (normal return, error, panic). It is the most Go-specific concept in this lesson.

func readFile(name string) error {
    f, err := os.Open(name)
    if err != nil {
        return err
    }
    defer f.Close() // runs when readFile returns, always

    // ... do stuff with f ...
    // Close() is called automatically here
    return nil
}

You put the cleanup code right next to the thing being opened. No need to remember to close at every return point. No finally block required.

Multiple defers: LIFO order

When you defer multiple calls, they execute in last in, first out order - like popping a stack. The last thing you deferred runs first:

Common use cases

// 1. Close a file
f, _ := os.Open("data.txt")
defer f.Close()

// 2. Unlock a mutex
mu.Lock()
defer mu.Unlock()

// 3. Log how long a function took
start := time.Now()
defer func() {
    fmt.Println("elapsed:", time.Since(start))
}()

// 4. Recover from a panic (advanced)
defer func() {
    if r := recover(); r != nil {
        fmt.Println("recovered:", r)
    }
}()

# Python's with block
with open("data.txt") as f:
    data = f.read()
# f is closed here automatically

# Can't defer arbitrary cleanup
# outside a with block

// Go's defer
f, _ := os.Open("data.txt")
defer f.Close() // any cleanup, anywhere
data, _ := io.ReadAll(f)
// f.Close() runs when function returns

// Works for any function call,
// not just resource managers

Real-world examples

The control flow you just learned, applied to three real contexts:

func itemHandler(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case http.MethodGet:
        // list or fetch item
        id := r.URL.Query().Get("id")
        if item, err := store.Get(id); err != nil {
            http.Error(w, err.Error(), http.StatusNotFound)
        } else {
            json.NewEncoder(w).Encode(item)
        }
    case http.MethodPost:
        // create item
        var item Item
        if err := json.NewDecoder(r.Body).Decode(&item); err != nil {
            http.Error(w, "bad request", http.StatusBadRequest)
            return
        }
        store.Put(item)
        w.WriteHeader(http.StatusCreated)
    case http.MethodDelete:
        id := r.URL.Query().Get("id")
        store.Delete(id)
    default:
        http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
    }
}

func processFiles(paths []string) error {
    for _, path := range paths {
        if err := processOne(path); err != nil {
            fmt.Fprintf(os.Stderr, "error processing %s: %v\n", path, err)
            continue // skip bad files, process the rest
        }
    }
    return nil
}

func processOne(path string) error {
    f, err := os.Open(path)
    if err != nil {
        return err
    }
    defer f.Close() // guaranteed cleanup, even on error return below

    scanner := bufio.NewScanner(f)
    for scanner.Scan() {
        line := scanner.Text()
        // process each line ...
        fmt.Println(line)
    }
    return scanner.Err()
}

func (c *Controller) Run(stopCh <-chan struct{}) {
    defer c.queue.ShutDown() // clean up queue on exit

    for {
        // select lets you wait on multiple channels at once
        // (covered in the concurrency lesson)
        item, quit := c.queue.Get()
        if quit {
            return // stopCh was closed - exit the loop
        }
        if err := c.reconcile(item.(string)); err != nil {
            c.queue.AddRateLimited(item) // retry on error
        }
        c.queue.Done(item)
    }
}

Gotchas (read twice)

Glossary

Origins, gotchas, and a quick check

Backstory and pitfalls that make this chapter stick.

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        defer fmt.Println(i)
    }
    fmt.Println("done")
}

done
4
3
2
1
0

for i := 0; i < 5; i++ {
    func() {
        defer fmt.Println(i)
        // work...
    }()
}

var fns []func()
for _, v := range items {
    fns = append(fns, func() { fmt.Println(v) })
}
for _, fn := range fns { fn() }

Quick check