if con Inicialización y Patrones de switch

Go refina el código condicional al permitir que if y switch ejecuten una sentencia de inicialización de un solo uso antes de la rama, y al ofrecer switches de valor y switches de tipo en interfaces.

Dominar estas formas mantiene el manejo de errores plano y reemplaza largas cadenas if/else con una discriminación más clara.

Resumen

Una sentencia de inicialización en if o switch declara variables temporales para el ámbito del bloque.

Los switches de expresión comparan un valor contra casos sin fallthrough implícito.

Los switches sin etiqueta encadenan casos booleanos como else if.

Los switches de tipo inspeccionan tipos dinámicos dentro de interfaces.

fallthrough es explícito y poco común.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

package main
 
import (
    "fmt"
    "os"
)
 
func main() {
    // Si ocurre un error al abrir el archivo, imprímelo y sal.
    // De lo contrario, cierra el archivo al final de la función.
    if f, err := os.Open("config.txt"); err != nil {
        fmt.Println(err)
        return
    } else {
        defer f.Close()
        fmt.Println("abierto", f.Name())
    }
 
    // Switch de valor para manejar diferentes códigos de estado.
    code := 404
    switch code {
    case 200:
        fmt.Println("ok")
    case 404:
        fmt.Println("no encontrado")
    default:
        fmt.Println("otro")
    }
}

Cuándo usar esto:

• Usa if err := ...; err != nil inmediatamente después de llamadas que devuelven errores.
• Usa switch de valor cuando compares una expresión con muchas constantes.
• Usa switch sin etiqueta con true (o condiciones desnudas) para casos booleanos ordenados.
• Usa switch de tipo cuando el comportamiento dependa del tipo concreto dentro de una interface{} o una restricción genérica.

Ejemplo Funcional

package main
 
import (
    "encoding/json"
    "fmt"
)
 
// Event representa un evento con un tipo y una carga útil.
type Event struct {
    Kind string
    Payload any
}
 
// handle procesa un evento basándose en el tipo de su carga útil.
func handle(e Event) error {
    // Type switch para determinar el tipo de Payload.
    switch p := e.Payload.(type) {
    case nil:
        // Maneja el caso de una carga útil nula.
        return fmt.Errorf("carga útil faltante para %s", e.Kind)
    case json.RawMessage:
        // Si la carga útil es un mensaje JSON crudo, imprime su longitud.
        fmt.Println("bytes json crudos", len(p))
    case map[string]any:
        // Si la carga útil es un mapa, imprime el número de claves.
        fmt.Println("claves de objeto", len(p))
    case string:
        // Si la carga útil es una cadena, imprímela.
        fmt.Println("cadena", p)
    default:
        // Maneja tipos de carga útil no soportados.
        return fmt.Errorf("carga útil no soportada %T", p)
    }
    return nil
}
 
// classify asigna una letra de calificación basada en una puntuación.
func classify(score int) string {
    // Tagless switch para encadenar condiciones booleanas.
    switch {
    case score >= 90:
        return "A"
    case score >= 80:
        return "B"
    default:
        return "C"
    }
}
 
func main() {
    events := []Event{
        {Kind: "text", Payload: "hola"},
        {Kind: "obj", Payload: map[string]any{"k": 1}},
    }
    // Itera sobre los eventos y maneja cada uno.
    for _, e := range events {
        // Usa if init para manejar errores inmediatamente.
        if err := handle(e); err != nil {
            fmt.Println(err)
        }
    }
    // Clasifica una puntuación y imprime el resultado.
    fmt.Println(classify(85))
}

Lo que esto demuestra:

• Type switch con p := e.Payload.(type) vincula una variable tipada por cada caso.
• default maneja tipos dinámicos inesperados con %T en los errores.
• Tagless switch sin expresión de etiqueta encadena comparaciones como if/else if.
• Las comprobaciones de errores permanecen en el sitio de la llamada con manejo temprano en el bucle.

Análisis Profundo

Cómo Funciona

• La inicialización se ejecuta una vez antes de la condición; las variables declaradas en la inicialización tienen el ámbito del bloque if/switch.
• Los switches de valor evalúan los casos de arriba a abajo; el primer caso verdadero se ejecuta y luego sale a menos que aparezca fallthrough.
• Los switches de tipo requieren que el operando sea una interfaz; cada caso debe cumplir las reglas de asignabilidad de la interfaz.
• Los switches sin etiqueta evalúan los casos como expresiones booleanas en orden - útil para rangos y condiciones compuestas.
• switch puede incluir una sentencia de inicialización: switch err := f(); err != nil { case ... } (poco común pero válido).

Formas de Switch de un Vistazo

Reglas de fallthrough

Notas de Go

// Comprobación de tipo con coma-ok en if - alternativa al type switch para un solo tipo
if s, ok := v.(string); ok {
    fmt.Println(s)
}
 
// Los switch en strings con casos duplicados son un error de compilación
// Coincidencia insensible a mayúsculas/minúsculas: normaliza antes del switch o usa un switch sin etiqueta

Trampas

• Fuga de variables de inicialización - Usar err después del bloque if cuando se declara en la inicialización. Solución: mantén el manejo dentro del bloque o declara err fuera intencionalmente.
• Asumir fallthrough en switch - La falta de break (errores de C) no aplica, pero un fallthrough accidental causa doble ejecución. Solución: elimina fallthrough a menos que sea deliberado.
• Type switch en no-interfaz - x.(type) solo funciona en operandos de interfaz. Solución: pasa any o un pequeño envoltorio de interfaz.
• Interfaz nula vs. nulo tipado - switch v := i.(type) { case *T: } puede coincidir con un puntero nulo tipado. Solución: comprueba v == nil dentro del caso.
• Expresiones de caso duplicadas - Error de compilación si dos casos se superponen en valores. Solución: combina con listas de comas case 1, 2:.
• El orden del switch sin etiqueta importa - El primer caso verdadero gana; pon las condiciones más específicas primero.

Alternativas

Preguntas Frecuentes

Relacionado

• Conceptos Básicos de Flujo de Control - primeros fragmentos de if y switch
• Flujo de Control en Go: Diseño Orientado a Expresiones - modelo mental orientado a expresiones
• defer, panic & recover - emparejar defer con aperturas exitosas de if
• Interfaz Nula vs. Puntero Nulo - nulo tipado en type switches
• Conceptos Básicos de Manejo de Errores - comprobaciones de errores junto a if estilo inicialización

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