Welche Kontrollfluss-Konstrukte hat Go?

Question

Accepted Answer

Go's Kontrollfluss ist bewusst **minimal** — es gibt nur **ein Loop-Keyword (`for`)**,keine Klammern um Bedingungen und obligatorische Braces. Diese Einfachheit ist beabsichtigt und bietet eine klare Art, alles zu tun. ## if — ohne Klammern, mit optionalem init-Statement ```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 } ``` Die Form `if init; condition` (Deklaration einer auf das if beschränkten Variable) ist in Go äußerst verbreitet — besonders das Fehlerprüfmuster `if err := ...; err != nil`. ## for — die EINZIGE Schleife, in mehreren Formen ```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 hat **kein `while` oder `do-while`** — `for` deckt alle Schleifenbedürfnisse ab. Die `range`-Form ist die idiomatische Art, Sammlungen zu durchlaufen. ## switch — sauberer als C (kein 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" } ``` Im Gegensatz zu C/Java fällt Go's `switch` **standardmäßig nicht durch** (kein `break` erforderlich) — eliminiert diesen klassischen Fehler. Verwenden Sie das `fallthrough`-Keyword in dem seltenen Fall, dass Sie es wünschen. ## defer — Aufräumen einplanen ```go func readFile() { f, _ := os.Open("file.txt") defer f.Close() // runs when the function RETURNS — guaranteed cleanup // ... use f ... } ``` `defer` plant einen Aufruf ein, der ausgeführt wird, wenn die umgebende Funktion zurückkehrt — idiomatisch für Aufräumen (Dateien schließen, Mutexe freigeben). ## Warum es wichtig ist Go's bewusst minimaler Kontrollfluss spiegelt seine Philosophie der Einfachheit wider und hat praktische Auswirkungen, die es wert sind, bekannt zu sein. Das Vorhandensein von **nur `for`** (das klassische, while-artige, unendliche und range-Schleifen abdeckt) bedeutet, dass es ein einheitliches Schleifen-Konstrukt gibt — `range` ist die idiomatische Art zu iterieren. Die **keine Klammern, obligatorische Braces**-Syntax und die **`if init; cond`**-Form (besonders `if err := ...; err != nil`) prägen idiomatisches Go. `switch` **fällt standardmäßig nicht durch** eliminiert einen häufigen C-Familie-Fehler, und der bedingungslose `switch` ist eine saubere if/else-Alternative. Und `defer` ist ein charakteristischer, unverzichtbarer Aufräummechanismus. Das Verständnis dieser — und wie sie sich von anderen Sprachen unterscheiden (eine Schleife, kein fall-through, defer) — ist grundlegend für das Lesen und Schreiben von idiomatischem Go.