Control structures

for i := 1; i <= 3; i++ {
	fmt.Println(i)
}

n := 100
steps := 0
for n > 1 {
	n /= 2
	steps++
}

outer:
	for r := range grid {
		for c := range grid[r] {
			if grid[r][c] == target {
				fmt.Println("found at", r, c)
				break outer // leaves both loops
			}
		}
	}

if x > 0 {
	fmt.Println("positive")
} else if x < 0 {
	fmt.Println("negative")
} else {
	fmt.Println("zero")
}

if n, err := strconv.Atoi(s); err != nil {
	fmt.Println("not a number")
} else {
	fmt.Println(n * 2)
}

switch day {
case "sat", "sun":
	fmt.Println("weekend")
case "fri":
	fmt.Println("almost")
default:
	fmt.Println("workday")
}

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

package main
 
import (
	"fmt"
	"strings"
)
 
func main() {
	// Print 1 to 15; multiples of 3 say Fizz, of 5 say Buzz, of both say FizzBuzz.
	var out []string
	for i := 1; i <= 15; i++ {
		switch {
		case i%15 == 0:
			out = append(out, "FizzBuzz")
		case i%3 == 0:
			out = append(out, "Fizz")
		case i%5 == 0:
			out = append(out, "Buzz")
		default:
			out = append(out, fmt.Sprint(i))
		}
	}
	fmt.Println(strings.Join(out, " "))
 
	// The numbers from 1 to 100 that are divisible by 3, counted and summed.
	count, sum := 0, 0
	for i := 3; i <= 100; i += 3 { // step by 3 instead of testing every number
		count++
		sum += i
	}
	fmt.Println(count, "multiples of 3, sum", sum)
 
	// Even or odd for 1..10, the chapter's warm-up.
	for i := range 10 {
		n := i + 1
		parity := "odd"
		if n%2 == 0 {
			parity = "even"
		}
		fmt.Print(n, ":", parity, " ")
	}
	fmt.Println()
}

1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz
33 multiples of 3, sum 1683
1:odd 2:even 3:odd 4:even 5:odd 6:even 7:odd 8:even 9:odd 10:even

package main
 
import (
	"fmt"
	"time"
)
 
func describe(n int) string {
	switch {
	case n < 0:
		return "negative"
	case n == 0:
		return "zero"
	case n%2 == 0:
		return "positive even"
	default:
		return "positive odd"
	}
}
 
func main() {
	for _, n := range []int{-3, 0, 4, 7} {
		fmt.Printf("%d is %s\n", n, describe(n))
	}
 
	// Cases do not fall through by default. fallthrough opts in, unconditionally.
	switch level := 2; level {
	case 1:
		fmt.Println("level 1 setup")
		fallthrough
	case 2:
		fmt.Println("level 2 setup")
		fallthrough
	case 3:
		fmt.Println("level 3 setup")
	}
 
	switch d := time.Date(2026, 10, 17, 0, 0, 0, 0, time.UTC).Weekday(); d {
	case time.Saturday, time.Sunday:
		fmt.Println(d, "is a weekend")
	default:
		fmt.Println(d, "is a weekday")
	}
}

-3 is negative
0 is zero
4 is positive even
7 is positive odd
level 2 setup
level 3 setup
Saturday is a weekend

package main
 
import "fmt"
 
func main() {
	for i := range 3 {
		fmt.Print(i, " ")
	}
	fmt.Println()
 
	var funcs []func() int
	for i := 0; i < 3; i++ {
		funcs = append(funcs, func() int { return i }) // each closure gets its own i (Go 1.22+)
	}
	for _, f := range funcs {
		fmt.Print(f(), " ")
	}
	fmt.Println()
 
	// Ranging over a string yields runes and their byte offsets.
	for i, r := range "añb" {
		fmt.Printf("%d:%c ", i, r)
	}
	fmt.Println()
 
	// A labeled continue skips to the next iteration of the OUTER loop.
	rows := [][]int{{1, 2, -1, 4}, {5, 6, 7}, {-2, 9}}
outer:
	for r, row := range rows {
		for _, v := range row {
			if v < 0 {
				fmt.Printf("row %d has a negative, skipping the rest of it\n", r)
				continue outer
			}
		}
		fmt.Printf("row %d is all non-negative\n", r)
	}
}

0 1 2 
0 1 2 
0:a 1:ñ 3:b 
row 0 has a negative, skipping the rest of it
row 1 is all non-negative
row 2 has a negative, skipping the rest of it

package main
 
import (
	"fmt"
	"strconv"
)
 
func fizzBuzz(n int) []string {
	out := make([]string, 0, n)
	for i := 1; i <= n; i++ {
		switch {
		case i%15 == 0:
			out = append(out, "FizzBuzz")
		case i%3 == 0:
			out = append(out, "Fizz")
		case i%5 == 0:
			out = append(out, "Buzz")
		default:
			out = append(out, strconv.Itoa(i))
		}
	}
	return out
}
 
func classify(n int) string {
	if n < 0 {
		return "negative" // early return
	}
	if n%2 == 0 {
		return "even"
	}
	return "odd"
}
 
func main() {
	fmt.Println(fizzBuzz(15))
 
	n, steps := 100, 0
	for n > 1 {
		n /= 2
		steps++
	}
	fmt.Println("halvings:", steps)
 
	for i := range 3 {
		fmt.Print(classify(i-1), " ")
	}
	fmt.Println()
 
	grid := [][]int{{1, 2, 3}, {4, 5, 6}}
outer:
	for r, row := range grid {
		for c, v := range row {
			if v == 5 {
				fmt.Println("found 5 at", r, c)
				break outer
			}
		}
	}
}

[1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz]
halvings: 6
negative even odd 
found 5 at 1 1