Type Assertion

Che cosa sono le Type Assertion?

In Go, una type assertion e un meccanismo che permette di estrarre il tipo concreto da un valore di tipo interfaccia. Quando lavoriamo con le interfacce, il tipo effettivo del valore sottostante e nascosto: le type assertion ci permettono di accedere a quel tipo.

La sintassi base e:

valore := interfaccia.(Tipo)

Dove interfaccia e un valore di tipo interfaccia e Tipo e il tipo concreto che ci aspettiamo.

Sintassi base: i.(T)

Vediamo un esempio pratico di type assertion:

package main

import "fmt"

func main() {
    var i interface{} = "ciao mondo"

    // Type assertion: estraiamo la stringa dall'interfaccia
    s := i.(string)
    fmt.Println(s) // Output: ciao mondo

    // Possiamo anche usare il valore direttamente
    fmt.Println(i.(string)) // Output: ciao mondo
}

In questo esempio, la variabile i e di tipo interface{} (o any in Go 1.18+) e contiene una stringa. Con i.(string) affermiamo che il valore contenuto e di tipo string.

Il pattern Comma-Ok

Quando non siamo sicuri del tipo contenuto nell’interfaccia, possiamo usare il comma-ok pattern per evitare il panic:

package main

import "fmt"

func main() {
    var i interface{} = 42

    // Pattern comma-ok: sicuro, non causa panic
    s, ok := i.(string)
    if ok {
        fmt.Println("E' una stringa:", s)
    } else {
        fmt.Println("Non e una stringa, ok =", ok) // ok = false
        fmt.Println("Valore zero:", s)              // stringa vuota ""
    }

    // Verificare il tipo corretto
    n, ok := i.(int)
    if ok {
        fmt.Println("E' un intero:", n) // Output: E' un intero: 42
    }
}

Con la forma valore, ok := i.(Tipo), la variabile ok sara true se l’asserzione ha successo e false altrimenti. In caso di fallimento, valore conterr il valore zero del tipo richiesto e non si verifichera un panic.

Panic su asserzione fallita

Se usiamo la forma senza il secondo valore di ritorno e il tipo non corrisponde, Go genera un panic:

package main

func main() {
    var i interface{} = 42

    // PANIC! Il valore e un int, non una string
    s := i.(string)
    _ = s
    // panic: interface conversion: interface {} is int, not string
}

Per questo motivo, e buona pratica usare sempre il pattern comma-ok a meno che non siate assolutamente certi del tipo contenuto.

Type Assertion con interfacce

Le type assertion non servono solo per estrarre tipi primitivi. Sono particolarmente utili quando si lavora con interfacce personalizzate:

package main

import "fmt"

type Parlante interface {
    Parla() string
}

type Scrivente interface {
    Scrivi(testo string)
}

type Persona struct {
    Nome string
}

func (p Persona) Parla() string {
    return fmt.Sprintf("Ciao, sono %s", p.Nome)
}

func (p Persona) Scrivi(testo string) {
    fmt.Printf("%s scrive: %s\n", p.Nome, testo)
}

func interagisci(p Parlante) {
    fmt.Println(p.Parla())

    // Verifichiamo se l'oggetto implementa anche Scrivente
    if scrittore, ok := p.(Scrivente); ok {
        scrittore.Scrivi("un messaggio importante")
    } else {
        fmt.Println("Questo Parlante non sa scrivere")
    }
}

func main() {
    mario := Persona{Nome: "Mario"}
    interagisci(mario)
}

In questo esempio, verifichiamo se un Parlante implementa anche l’interfaccia Scrivente. Questo pattern e molto comune nelle librerie Go.

Type Switch

Quando dobbiamo gestire piu tipi possibili, possiamo usare un type switch, che e una forma speciale di switch basata sulle type assertion:

package main

import "fmt"

func descrivi(i interface{}) string {
    switch v := i.(type) {
    case int:
        return fmt.Sprintf("Intero: %d", v)
    case string:
        return fmt.Sprintf("Stringa: %q", v)
    case bool:
        return fmt.Sprintf("Booleano: %t", v)
    case []int:
        return fmt.Sprintf("Slice di interi con %d elementi", len(v))
    default:
        return fmt.Sprintf("Tipo sconosciuto: %T", v)
    }
}

func main() {
    fmt.Println(descrivi(42))          // Intero: 42
    fmt.Println(descrivi("ciao"))      // Stringa: "ciao"
    fmt.Println(descrivi(true))        // Booleano: true
    fmt.Println(descrivi([]int{1, 2})) // Slice di interi con 2 elementi
    fmt.Println(descrivi(3.14))        // Tipo sconosciuto: float64
}

La variabile v assume automaticamente il tipo del caso corrispondente, permettendoci di usare i metodi specifici di quel tipo.

Esempio pratico: gestione di errori

Un uso molto comune delle type assertion e nella gestione degli errori personalizzati:

package main

import (
    "errors"
    "fmt"
    "net"
)

func gestisciErrore(err error) {
    // Verificare se e un errore di rete
    if netErr, ok := err.(net.Error); ok {
        if netErr.Timeout() {
            fmt.Println("Errore di timeout della rete")
            return
        }
        fmt.Println("Errore di rete generico")
        return
    }

    fmt.Println("Errore generico:", err)
}

func main() {
    err := errors.New("qualcosa e andato storto")
    gestisciErrore(err) // Output: Errore generico: qualcosa e andato storto
}

Best practice

• Usate sempre il pattern comma-ok quando non siete certi del tipo.
• Preferite il type switch quando dovete gestire piu tipi.
• Usate type assertion per verificare se un tipo implementa interfacce aggiuntive.
• Non abusate di interface{} (o any): se conoscete il tipo in anticipo, usate quel tipo direttamente.
• In Go 1.23+, con i generics disponibili, valutate se i generics possono sostituire l’uso di interface{} e type assertion.

Conclusione

Le type assertion sono uno strumento fondamentale in Go per lavorare con i tipi interfaccia. Permettono di estrarre il tipo concreto da un’interfaccia, verificare se un valore implementa interfacce aggiuntive e gestire diversi tipi in modo elegante. Ricordate sempre di usare il pattern comma-ok per evitare panic inaspettati e di preferire il type switch quando dovete gestire molteplici tipi possibili.