Go มีโครงสร้าง control-flow อะไรบ้าง?

Question

Accepted Answer

Go's control flow is deliberately **minimal** — there's only **one loop keyword (`for`)**, no parentheses around conditions, and mandatory braces. This simplicity is intentional, giving one clear way to do each thing. ## if — ไม่มีวงเล็บ พร้อมกับ 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 } ``` The `if init; condition` form (declaring a variable scoped to the if) is extremely common in Go — especially the `if err := ...; err != nil` error-check pattern. ## for — loop เดียวเท่านั้น ในรูปแบบต่างๆ ```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 has **no `while` or `do-while`** — `for` covers all looping needs. The `range` form is the idiomatic way to iterate collections. ## switch — สะอาดกว่า C (ไม่มี 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" } ``` Unlike C/Java, Go's `switch` **doesn't fall through** by default (no `break` needed) — eliminating that classic bug. Use the `fallthrough` keyword in the rare case you want it. ## defer — กำหนดเวลาการทำความสะอาด ```go func readFile() { f, _ := os.Open("file.txt") defer f.Close() // runs when the function RETURNS — guaranteed cleanup // ... use f ... } ``` `defer` schedules a call to run when the surrounding function returns — idiomatic for cleanup (closing files, unlocking mutexes). ## ทำไมจึงมีความสำคัญ Go's deliberately minimal control flow reflects its simplicity philosophy and has practical implications worth knowing. Having **only `for`** (covering classic, while-style, infinite, and range loops) means there's one consistent looping construct — `range` being the idiomatic way to iterate. The **no-parentheses, mandatory-braces** syntax and the **`if init; cond`** form (especially `if err := ...; err != nil`) shape idiomatic Go. `switch` **not falling through by default** eliminates a common C-family bug, and the condition-less `switch` is a clean if/else alternative. And `defer` is a distinctive, essential cleanup mechanism. Understanding these — and how they differ from other languages (one loop, no fall-through, defer) — is fundamental to reading and writing idiomatic Go.