Quali costrutti di controllo di flusso ha Go?

Question

Accepted Answer

Il controllo di flusso di Go è volutamente **minimalista** — esiste solo **una parola chiave per i cicli (`for`)**, nessuna parentesi intorno alle condizioni, e parentesi graffe obbligatorie. Questa semplicità è intenzionale, fornendo un modo unico e chiaro per fare ogni cosa. ## Perché è importante Il controllo di flusso volutamente minimalista di Go riflette la sua filosofia di semplicità ed ha implicazioni pratiche che vale la pena conoscere. Avere **solo `for`** (coprendo cicli classici, in stile while, infiniti, e range) significa che c'è un unico costrutto di ciclo coerente — `range` essendo il modo idiomatico per iterare. La **sintassi senza parentesi, con parentesi graffe obbligatorie** e la **forma `if init; cond`** (specialmente `if err := ...; err != nil`) modellano l'idioma Go. `switch` **non prosegue per default** elimina un bug comune della famiglia C, e lo `switch` senza condizione è un'alternativa pulita a if/else. E `defer` è un meccanismo di cleanup distintivo e essenziale. Comprendere questi — e come differiscono da altri linguaggi (un loop, nessuna prosecuzione, defer) — è fondamentale per leggere e scrivere Go idiomatico. ## if — senza parentesi, con statement di init opzionale ```go 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 } ``` La forma `if init; condition` (dichiarando una variabile scoped all'if) è estremamente comune in Go — specialmente il pattern di controllo errori `if err := ...; err != nil`. ## for — L'UNICO ciclo, in diverse forme ```go // 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 **non ha `while` o `do-while`** — `for` copre tutte le esigenze di ciclo. La forma `range` è il modo idiomatico per iterare collezioni. ## switch — più pulito di C (nessuna prosecuzione) ```go 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" } ``` A differenza di C/Java, `switch` di Go **non prosegue per default** (nessun `break` necessario) — eliminando quel bug classico. Usa la parola chiave `fallthrough` nel raro caso in cui lo desideri. ## defer — pianifica cleanup ```go func readFile() { f, _ := os.Open("file.txt") defer f.Close() // runs when the function RETURNS — guaranteed cleanup // ... use f ... } ``` `defer` pianifica una chiamata da eseguire quando la funzione circostante ritorna — idiomatico per cleanup (chiudere file, sbloccare mutex).