¿Qué construcciones de control de flujo tiene Go?

Question

Accepted Answer

El flujo de control de Go es deliberadamente **mínimo** — hay solo **una palabra clave de bucle (`for`)**,sin paréntesis alrededor de condiciones y llaves obligatorias. Esta simplicidad es intencional, proporcionando una forma clara de hacer cada cosa. ## if — sin paréntesis, con una declaración 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 } ``` La forma `if init; condition` (declaración de una variable con alcance en if) es muy común en Go — especialmente el patrón de verificación de errores `if err := ...; err != nil`. ## for — el ÚNICO bucle, en varias 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 **no tiene `while` ni `do-while`** — `for` cubre todas las necesidades de bucles. La forma `range` es la forma idiomática de iterar colecciones. ## switch — más limpio que C (sin 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" } ``` A diferencia de C/Java, `switch` de Go **no cae por defecto** (no se necesita `break`) — eliminando ese error clásico. Use la palabra clave `fallthrough` en el raro caso de que la desee. ## defer — programar limpieza ```go func readFile() { f, _ := os.Open("file.txt") defer f.Close() // runs when the function RETURNS — guaranteed cleanup // ... use f ... } ``` `defer` programa una llamada para ejecutarse cuando la función circundante regresa — idiomática para limpieza (cerrar archivos, desbloquear mutexes). ## Por qué es importante El flujo de control deliberadamente mínimo de Go refleja su filosofía de simplicidad y tiene implicaciones prácticas que vale la pena conocer. Tener **solo `for`** (cubriendo bucles clásicos, al estilo while, infinitos y de rango) significa que hay una construcción de bucle consistente — `range` siendo la forma idiomática de iterar. La sintaxis **sin paréntesis, llaves obligatorias** y la forma **`if init; cond`** (especialmente `if err := ...; err != nil`) dan forma al Go idiomático. `switch` **sin fall-through por defecto** elimina un error común de la familia C, y la `switch` sin condición es una alternativa if/else limpia. Y `defer` es un mecanismo de limpieza distintivo y esencial. Comprender estos — y cómo difieren de otros idiomas (un bucle, sin fall-through, defer) — es fundamental para leer y escribir Go idiomático.