Hvilke kontrollflyt-konstruksjoner har Go?

Go's kontrollflyt er bevisst minimal — det er bare ett loop-nøkkelord (for), ingen parenteser rundt betingelser, og obligatoriske parenteser. Denne enkelheten er bevisst, og gir en klar måte å gjøre hver ting.

if — ingen parenteser, med valgfri init-setning

if x > 10 {                  // no parentheses around the condition; braces required
    fmt.Println("big")
} else if x > 5 {
    fmt.Println("medium")
} else {
    fmt.Println("small")
}

// if with an INIT statement — variable scoped to the if/else (very idiomatic)
if err := doSomething(); err != nil {
    return err            // `err` exists only within this if/else
}

if init; condition-formen (deklarering av en variabel som er begrenset til if-blokken) er ekstremt vanlig i Go — spesielt if err := ...; err != nil feilsjekk-mønsteret.

for — den ENESTE løkken, i flere former

// 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 har ingen while eller do-while — for dekker alle løkke-behov. range-formen er den idiomatiske måten å iterere over samlinger.

switch — renere enn C (ingen fall-through)

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"
}

I motsetning til C/Java, faller ikke Go's switch gjennom som standard (ingen break nødvendig) — som eliminerer den klassiske feilen. Bruk fallthrough-nøkkelordet i det sjeldne tilfellet du ønsker det.

defer — planlegg opprensingskode

func readFile() {
    f, _ := os.Open("file.txt")
    defer f.Close()        // runs when the function RETURNS — guaranteed cleanup
    // ... use f ...
}

defer planlegger et funksjonskall som kjøres når den omgivende funksjonen returnerer — idiomatisk for opprensking (lukking av filer, freing av mutexer).

Hvorfor det betyr noe

Go's bevisst minimal kontrollflyt reflekterer dens enkelhetsfilosofi og har praktiske konsekvenser som er verdt å kjenne.

Having bare for (dekker klassisk, while-stil, uendelig og range-løkker) betyr at det finnes ett konsistent løkke-konstrukt — range er den idiomatiske måten å iterere.

Den ingen-parenteser, obligatoriske-krøller syntaks og if init; cond-formen (spesielt if err := ...; err != nil) former idiomatisk Go. switch faller ikke gjennom som standard, som eliminerer en vanlig C-familie-feil, og den betingelsesløse switch er et rent if/else-alternativ.

Og defer er en distinktiv, essentiell opprensningsmekanisme.

Å forstå disse — og hvordan de skiller seg fra andre språk (en løkke, ingen fall-through, defer) — er grunnleggende for å lese og skrive idiomatisk Go.