Fundamentos del Flujo de Control

10 ejemplos para empezar con el Flujo de Control: 7 básicos y 3 intermedios.

Prerrequisitos

• Instala Go 1.26.x o posterior desde go.dev/dl.
• Crea un módulo: mkdir flow && cd flow && go mod init example.com/flow.
• Guarda cada fragmento como main.go y ejecútalo con go run ..

Ejemplos Básicos

1. if / else

Ramifica según una condición booleana.

package main
 
import "fmt"
 
func main() {
    n := 7
    if n%2 == 0 {
        fmt.Println("par")
    } else {
        fmt.Println("impar")
    }
}

• if no necesita paréntesis alrededor de la condición.
• Las llaves son obligatorias: Go fuerza la estructura de bloques en tiempo de compilación.
• La condición debe ser una expresión booleana, no un valor "truthy".

Relacionado: if con Inicialización y Patrones switch - cláusulas init y formas de switch

2. Bucle for estilo C

La cabecera clásica de tres partes: init, condición, post.

package main
 
import "fmt"
 
func main() {
    sum := 0
    for i := 0; i < 5; i++ {
        sum += i
    }
    fmt.Println(sum) // 10
}

• Go no tiene una palabra clave while separada; esta es la única palabra clave de bucle.
• La variable de inicialización i está delimitada al ámbito de la sentencia for.
• Omite init y post para otras formas de for mostradas en ejemplos posteriores.

Relacionado: Variantes de bucle for y Semántica de range - todas las formas de for

3. for range sobre un slice

Itera índice y valor juntos.

package main
 
import "fmt"
 
func main() {
    langs := []string{"Go", "Rust", "Zig"}
    for i, name := range langs {
        fmt.Println(i, name)
    }
}

• range funciona en slices, arrays, mapas, canales y strings.
• Usa _ para ignorar el índice o el valor: for _, name := range langs.
• Modificar elementos a través de la variable de valor de range no actualiza el slice (usa el índice).

Relacionado: Variantes de bucle for y Semántica de range - semántica por colección

4. switch de expresión

Compara un valor contra múltiples casos.

package main
 
import "fmt"
 
func main() {
    day := "Lun"
    switch day {
    case "Sab", "Dom":
        fmt.Println("fin de semana")
    default:
        fmt.Println("día laborable")
    }
}

• Los casos no se caen automáticamente (a diferencia de C).
• Múltiples valores pueden compartir un caso con comas.
• default se ejecuta cuando ningún caso coincide.

Relacionado: if con Inicialización y Patrones switch - switches sin etiqueta y de tipo

5. if con sentencia init

Vincula una variable temporal delimitada al bloque if.

package main
 
import (
    "fmt"
    "strconv"
)
 
func main() {
    if n, err := strconv.Atoi("42"); err != nil {
        fmt.Println("error de parseo:", err)
    } else {
        fmt.Println("parseado:", n)
    }
}

• La sentencia init se ejecuta una vez antes de la condición.
• Las variables de init solo son visibles en los bloques if y else.
• Este patrón es la comprobación de errores idiomática en Go.

Relacionado: Diseño Orientado a Expresiones del Flujo de Control en Go - por qué las cláusulas init importan

6. defer para limpieza

Programa una llamada para que se ejecute cuando la función retorne.

package main
 
import "fmt"
 
func main() {
    defer fmt.Println("limpieza")
    fmt.Println("trabajo")
}

• Las llamadas diferidas se ejecutan en orden de último en entrar, primero en salir (LIFO).
• defer se ejecuta al salir de la función, incluyendo la desenrollación de panic.
• Empareja defer f.Close() inmediatamente después de un Open() exitoso.

Relacionado: defer, panic y recover - pila de defer y recuperación

7. break y continue

Omite una iteración o sal del bucle anticipadamente.

package main
 
import "fmt"
 
func main() {
    for i := 0; i < 10; i++ {
        if i%2 == 0 {
            continue
        }
        if i > 5 {
            break
        }
        fmt.Println(i)
    }
}

• continue salta a la siguiente iteración.
• break sale del for, switch o select más interno.
• Las etiquetas extienden break/continue a bucles externos (ver ejemplo intermedio).

Relacionado: break, continue y Flujo de Control Etiquetado - salidas etiquetadas

Ejemplos Intermedios

8. Type switch sobre interface{}

Ramifica según el tipo dinámico dentro de un valor de interfaz.

package main
 
import "fmt"
 
func describe(v any) {
    switch x := v.(type) {
    case int:
        fmt.Println("int", x)
    case string:
        fmt.Println("string", x)
    default:
        fmt.Printf("otro %T\n", x)
    }
}
 
func main() {
    describe(42)
    describe("hola")
}

• v.(type) solo está permitido en una sentencia switch.
• La variable corta x contiene el valor tipado en cada caso.
• Prefiere funciones tipadas sobre any cuando el conjunto de tipos es conocido.

Relacionado: if con Inicialización y Patrones switch - patrones de type switch

9. break Etiquetado desde bucles anidados

Sale de un bucle externo sin una bandera auxiliar.

package main
 
import "fmt"
 
func main() {
outer:
    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            if i*j == 4 {
                break outer
            }
            fmt.Println(i, j)
        }
    }
}

• La etiqueta debe estar en una sentencia for, switch o select.
• continue outer salta a la siguiente iteración del bucle etiquetado.
• Extrae una función cuando las etiquetas dificultan el seguimiento del flujo.

Relacionado: break, continue y Flujo de Control Etiquetado - cuándo ayudan las etiquetas

10. panic y recover

recover detiene la desenrollación de panic dentro de una función diferida.

package main
 
import "fmt"
 
func mayPanic() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("recuperado:", r)
        }
    }()
    panic("boom")
}
 
func main() {
    mayPanic()
    fmt.Println("main continúa")
}

• recover retorna nil a menos que se llame desde una función diferida durante un panic.
• Los errores normales deben retornar error, no hacer panic.
• Los servidores HTTP usan este patrón en middleware para evitar que el proceso falle.

Relacionado: Flujo de Control en Middleware HTTP - manejadores seguros contra panic

Versiones de la pila: Esta página fue escrita para Go 1.26.x (Green Tea GC por defecto, go fix modernizers - verifica el parche en la compilación), chi (última - verifica en la compilación), gin (última - verifica en la compilación), echo (última - verifica en la compilación), google.golang.org/grpc (última - verifica en la compilación), sigs.k8s.io/controller-runtime (última - verifica en la compilación), kubebuilder (última - verifica en la compilación), tinygo (última - verifica los objetivos de placa en la compilación), wazero (última - verifica en la compilación) y golangci-lint (última - verifica el conjunto de linters en la compilación).