Go's control flow is deliberately minimal — there's only one loop keyword (for), no parentheses around conditions, and mandatory braces. This simplicity is intentional, giving one clear way to do each thing.
x > {
fmt.Println()
} x > {
fmt.Println()
} {
fmt.Println()
}
err := doSomething(); err != {
err
}
The if init; condition form (declaring a variable scoped to the if) is extremely common in Go — especially the if err := ...; err != nil error-check pattern.
// 1. classic three-part for
for i := 0; i < 10; i++ { ... }
// 2. while-style (just a condition)
for x < 100 { x *= 2 }
// 3. infinite loop
for { ... break ... } // loop forever until break
// 4. range — iterate slices, maps, strings, channels
for index, value := range mySlice { ... }
for key, value := range myMap { ... }
for i, char := range "héllo" { ... } // i is byte index, char is a rune
for range channel { ... }
Go ba shi da while ko do-while — for ya rufe duk bukatun juyawa. The range form is the idiomatic way to iterate collections.
switch day {
case "Sat", "Sun": // multiple values per case
fmt.Println("weekend")
case "Mon":
fmt.Println("monday")
// NO break needed — Go does NOT fall through by default!
default:
fmt.Println("weekday")
}
// switch with no condition = clean if/else chain
switch {
case score >= 90: grade = "A"
case score >= 80: grade = "B"
default: grade = "F"
}
Unlike C/Java, Go's switch ba ya fallthrough ta hanyar tsakaninsu (ba break bukatu) — eliminating that classic bug. Use the fallthrough keyword in the rare case you want it.
func readFile() {
f, _ := os.Open("file.txt")
defer f.Close() // runs when the function RETURNS — guaranteed cleanup
// ... use f ...
}
defer schedules a call to run when the surrounding function returns — idiomatic for cleanup (closing files, unlocking mutexes).
Go's deliberately minimal control flow reflects its simplicity philosophy and has practical implications worth knowing.
Having only for (covering classic, while-style, infinite, and range loops) means there's one consistent looping construct — range being the idiomatic way to iterate.
The no-parentheses, mandatory-braces syntax and the if init; cond form (especially if err := ...; err != nil) shape idiomatic Go. switch not falling through by default eliminates a common C-family bug, and the condition-less switch is a clean if/else alternative.
And defer is a distinctive, essential cleanup mechanism.
Understanding these — and how they differ from other languages (one loop, no fall-through, defer) — is fundamental to reading and writing idiomatic Go.