Quais construções de fluxo de controle o Go possui?

Question

Accepted Answer

O fluxo de controle do Go é deliberadamente **mínimo** — há apenas **uma palavra-chave de loop (`for`)**, sem parênteses ao redor das condições e chaves obrigatórias. Essa simplicidade é intencional, oferecendo uma forma clara de fazer cada coisa. ## if — sem parênteses, com uma instrução init opcional ```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 } ``` A forma `if init; condition` (declarando uma variável com escopo dentro do if) é extremamente comum em Go — especialmente o padrão de verificação de erro `if err := ...; err != nil`. ## for — o ÚNICO loop, em várias formas ```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 **não possui `while` ou `do-while`** — `for` cobre todas as necessidades de looping. A forma `range` é a forma idiomática de iterar sobre coleções. ## switch — mais limpo que C (sem fall-through) ```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" } ``` Ao contrário de C/Java, o `switch` do Go **não passa adiante por padrão** (sem necessidade de `break`) — eliminando esse bug clássico. Use a palavra-chave `fallthrough` no raro caso em que você a queira. ## defer — agende limpeza ```go func readFile() { f, _ := os.Open("file.txt") defer f.Close() // runs when the function RETURNS — guaranteed cleanup // ... use f ... } ``` `defer` agenda uma chamada para ser executada quando a função envolvente retorna — idiomático para limpeza (fechamento de arquivos, desbloqueio de mutexes). ## Por que isso importa O fluxo de controle deliberadamente mínimo do Go reflete sua filosofia de simplicidade e tem implicações práticas que valem a pena conhecer. Ter **apenas `for`** (cobrindo loops clássicos, estilo while, infinitos e range) significa que existe um único construto de looping consistente — `range` sendo a forma idiomática de iterar. A sintaxe **sem-parênteses, chaves-obrigatórias** e a forma **`if init; cond`** (especialmente `if err := ...; err != nil`) moldam o Go idiomático. `switch` **não passa adiante por padrão**, eliminando um bug comum da família C, e o `switch` sem condição é uma alternativa limpa de if/else. E `defer` é um mecanismo de limpeza distintivo e essencial. Compreender esses — e como eles diferem de outras linguagens (um loop, sem fall-through, defer) — é fundamental para ler e escrever Go idiomático.