Type switch

Un cambio de tipo discrimina entre múltiples tipos posibles de un valor de la interfaz. Es la generalización de comma ok cuando hay más de un caso.

Sintaxis

func describe(i interface{}) string {
    switch v := i.(type) {
    case int:
        return fmt.Sprintf("int %d", v)
    case string:
        return fmt.Sprintf("string %q", v)
    case nil:
        return "nil"
    default:
        return fmt.Sprintf("altro tipo: %T", v)
    }
}

• i.(type) es una sintaxis especial, válida SÓLO dentro de switch.
• v := ... vincula el valor con el tipo de caso actual: dentro de case int, v tiene el tipo int.
• default captura todos los demás tipos; allí v tiene el tipo de interfaz original.
• case nil hace coincidir la interfaz con un tipo dinámico nulo.

Caso "sin nombre"

Si no necesita el valor escrito, puede omitir v:

switch i.(type) {
case int:
    // you know it's an int, but you don't have a variable of that type
case string:
    // ...
}

Un formulario utilizado cuando solo necesitas discriminar el tipo, no operar sobre el valor.

Varios tipos en el mismo caso

switch v := i.(type) {
case int, int64:
    // here v is still interface{}: the "common" type is just the interface
    fmt.Println("numero intero:", v)
case string:
    // here v is string
    fmt.Println("stringa:", v)
}

Caso de uso típico: impresión formateada

func print(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("%d\n", v)
    case string:
        fmt.Printf("%s\n", v)
    case fmt.Stringer:
        fmt.Println(v.String())
    default:
        fmt.Printf("%v\n", v)
    }
}

El propio fmt.Println utiliza un interruptor de tipo internamente para manejar el formatos estándar.

Tipo de cambio vs reflexión

Para algunos tipos conocidos → escriba switch (rápido, legible). Para inspección dinámica de tipos desconocidos → el paquete reflect (más potente pero más lento y más detallado).

Pruébalo

switch ??? {
  case int: ...
}

Resumen

• switch v := i.(type) { case T: ... }: discrimina por el tipo dinámico.
• Dentro de un caso de un solo tipo, v tiene el tipo de caso.
• case T1, T2: v mantiene el tipo de interfaz original.
• default para casos no tratados; case nil para la interfaz nula.
• No fallthrough en interruptores tipo.
• 1 tipo → tipo de afirmación; 2+ tipos → interruptor de tipo.