Go, End to End

Control Flow

Go keeps control flow deliberately small: one conditional form, one switch form, and exactly one loop keyword that covers every looping pattern other languages split across for/while/do-while.

if / else

No parentheses around the condition, and the braces are mandatory even for a single statement. An if can also include a short initialization statement before the condition, scoped to the if/else chain, which is the idiomatic way to check an error right where it's produced.

go · live, editable, runnable

package main import ( "fmt" "strconv" ) func main() { if n, err := strconv.Atoi("42"); err == nil { fmt.Println("parsed:", n) } else { fmt.Println("failed:", err) } }

switch

Go's switch doesn't fall through by default, each case implicitly breaks after its body. That's the opposite of C/C++/Java, and it removes an entire category of forgotten-break bugs. If you genuinely want fallthrough behavior, the fallthrough keyword asks for it explicitly on a per-case basis.

go · live, editable, runnable

package main import "fmt" func main() { n := 2 switch n { case 1: fmt.Println("one") case 2: fmt.Println("two") fallthrough case 3: fmt.Println("three (via fallthrough or n == 3)") default: fmt.Println("something else") } }

A switch with no expression at all works as a cleaner alternative to a long if/else if chain, each case is just a boolean condition.

go · live, editable, runnable

package main import "fmt" func classify(n int) string { switch { case n < 0: return "negative" case n == 0: return "zero" default: return "positive" } } func main() { fmt.Println(classify(-5), classify(0), classify(5)) }

for: Go's only loop

There's no while and no do-while. for covers all of it, in four shapes.

go · live, editable, runnable

package main import "fmt" func main() { // classic three-clause for i := 0; i < 3; i++ { fmt.Println("classic", i) } // condition-only (this is Go's "while") n := 0 for n < 3 { fmt.Println("while-style", n) n++ } // infinite, exited with break count := 0 for { if count >= 3 { break } fmt.Println("infinite", count) count++ } // range-based, over a slice for i, v := range []string{"a", "b", "c"} { fmt.Println("range", i, v) } }

Labeled break and continue

Nested loops sometimes need to break or continue an outer loop specifically, not just the innermost one. Go supports this with labels, which look unusual at first but solve a real problem cleanly (the alternative in languages without labels is usually a boolean flag variable checked in every nested loop, which is worse).

go · live, editable, runnable

Try it yourself: change continue outer to break outer in the example above and predict the output before running it.