Cosa sono le asserzioni di tipo e gli switch di tipo?

Question

Accepted Answer

Un'**asserzione di tipo** estrae il tipo concreto da un valore interfaccia, e uno **switch di tipo** esegue un branch sul tipo sottostante di un'interfaccia. Sono il modo per recuperare informazioni di tipo specifiche da un'interfaccia (specialmente l'interfaccia vuota / `any`).

## Asserzione di tipo — estrai un tipo concreto

```go
var i interface{} = "hello"     // an interface holding a string

s := i.(string)                  // assert it's a string → s = "hello"
fmt.Println(s)

n := i.(int)                     // ❌ PANIC — i is not an int (wrong assertion)
```

La sintassi `i.(Type)` asserisce che l'interfaccia `i` contiene un valore di tipo `Type` ed lo estrae. Ma un'asserzione sbagliata **genera panico** — quindi di solito usi la forma sicura comma-ok.

## La forma sicura comma-ok

```go
s, ok := i.(string)
if ok {
    fmt.Println("it's a string:", s)   // ok = true, s = the value
} else {
    fmt.Println("not a string")         // ok = false, s = zero value, NO panic
}
```

La forma a due valori restituisce il valore più un booleano — `ok` è false (invece di generare panico) se l'asserzione fallisce. **Preferisci sempre questa** a meno che tu non sia sicuro del tipo.

## Switch di tipo — esegui il branch su più tipi possibili

```go
func describe(i interface{}) string {
    switch v := i.(type) {           // the special .(type) form, only in a switch
    case int:
        return fmt.Sprintf("int: %d (doubled: %d)", v, v*2)
    case string:
        return fmt.Sprintf("string of length %d", len(v))
    case bool:
        return fmt.Sprintf("bool: %t", v)
    case nil:
        return "nil value"
    default:
        return fmt.Sprintf("unknown type: %T", v)
    }
}

describe(42)        // "int: 42 (doubled: 84)"
describe("hi")      // "string of length 2"
```

La forma `switch v := i.(type)` controlla il tipo sottostante e associa `v` (tipizzato appropriatamente in ogni case). È il modo pulito per gestire un'interfaccia che potrebbe contenere diversi tipi.

## Asserire anche tipi interfaccia

```go
// assert that a value implements a specific interface
if w, ok := i.(io.Writer); ok {
    w.Write([]byte("data"))    // use it as an io.Writer if it satisfies that interface
}
```

## Quando ne hai bisogno

```text
✓ Processing values of unknown type (interface{}/any) — JSON, generic handlers
✓ Checking if a value implements an optional interface (e.g. io.Closer)
✓ Handling heterogeneous data
⚠️ Often a sign you could use generics or better-typed interfaces instead — don't overuse
```

## Perché è importante

Le asserzioni di tipo e gli switch di tipo sono strumenti essenziali per lavorare con valori interfaccia — recuperando informazioni di tipo concreto da `interface{}`/`any` o controllando se un valore soddisfa una particolare interfaccia.

Sono necessari quando si gestiscono dati di tipo sconosciuto o variato (parsing di JSON dinamico, elaborazione generica, controlli di interfaccia facoltativa come "questo implementa io.Closer?").

Comprendere la **distinzione panic-vs-sicuro** è critico: un'asserzione semplice `i.(T)` genera panico in caso di mancata corrispondenza, mentre la **forma comma-ok** `v, ok := i.(T)` segnala in sicurezza il fallimento — usare la forma sicura è una pratica chiave per evitare crash a runtime.

Lo switch di tipo gestisce elegantemente più tipi possibili.

Conoscere questi (e che un uso pesante spesso segnala che dovresti invece ricorrere ai generici o a design meglio tipizzati) è importante per Go sicuro e idiomatico ed è un argomento comune nei colloqui, poiché le interfacce e l'interfaccia vuota sono così centrali nel linguaggio.