Asserzioni di tipo e switch sul tipo
Asserzioni di tipo sicure e modelli con switch
Asserzioni di tipo e switch sul tipo è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.
Asserzioni di tipo
Un'asserzione di tipo estrae il valore concreto da un'interfaccia. La sintassi è x.(T):
package main
import "fmt"
func main() {
var i interface{} = "hello"
s := i.(string) // panics if wrong type
fmt.Println(s, len(s)) // hello 5
}Asserzione sicura a due valori
Usi la forma comma-ok per evitare panic in caso di tipo errato:
package main
import "fmt"
func main() {
var i interface{} = 42
s, ok := i.(string)
fmt.Println(s, ok) // "" false
n, ok := i.(int)
fmt.Println(n, ok) // 42 true
}Type switch
Un type switch confronta il tipo dinamico di un valore di interfaccia con più tipi:
package main
import "fmt"
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 bool: return fmt.Sprintf("bool: %v", v)
default: return fmt.Sprintf("unknown: %T", v)
}
}
func main() {
fmt.Println(describe(42))
fmt.Println(describe("hi"))
fmt.Println(describe(3.14))
}Type switch sugli errori
I type switch sono particolarmente utili per classificare gli errori:
package main
import ("errors"; "fmt")
type NotFoundError struct{ Name string }
func (e *NotFoundError) Error() string { return e.Name + " not found" }
type PermError struct{}
func (e *PermError) Error() string { return "permission denied" }
func handle(err error) {
switch e := err.(type) {
case *NotFoundError: fmt.Println("missing:", e.Name)
case *PermError: fmt.Println("perm error")
default: fmt.Println("other:", e)
}
}
func main() {
handle(&NotFoundError{"user"})
handle(errors.New("generic"))
}Asserzione a un'interfaccia
È possibile eseguire un'asserzione verso un altro tipo di interfaccia, non solo verso tipi concreti. È utile per verificare se un oggetto supporta un comportamento opzionale:
package main
import "fmt"
type Flusher interface{ Flush() }
type Writer interface{ Write(string) }
type BufferedWriter struct{ buf string }
func (b *BufferedWriter) Write(s string) { b.buf += s }
func (b *BufferedWriter) Flush() { fmt.Println(b.buf); b.buf = "" }
func maybeFlush(w Writer) {
if f, ok := w.(Flusher); ok { f.Flush() }
}
func main() {
bw := &BufferedWriter{}
bw.Write("hello")
maybeFlush(bw)
}Asserzione su un'interfaccia nil
Eseguire un'asserzione su un'interfaccia nil provoca un panic. Si assicuri sempre che l'interfaccia non sia nil prima di eseguire l'asserzione:
package main
import "fmt"
func safePrint(i interface{}) {
if i == nil {
fmt.Println("nil")
return
}
fmt.Printf("%T: %v\n", i, i)
}
func main() {
safePrint(nil)
safePrint(42)
}Alternativa a reflect.TypeOf
Per stampare il tipo senza eseguire un'asserzione, usi fmt.Sprintf("%T", v) o reflect.TypeOf(v):
package main
import ("fmt"; "reflect")
func main() {
v := []int{1, 2, 3}
fmt.Printf("%T\n", v) // []int
fmt.Println(reflect.TypeOf(v)) // []int
}Asserzione di tipo e conversione di tipo
Asserzione di tipo: estrae il tipo concreto da un'interfaccia. Conversione di tipo: converte un tipo concreto in un altro tipo compatibile. Sono operazioni diverse:
package main
import "fmt"
func main() {
var i interface{} = int32(5)
n := i.(int32) // assertion — OK
big := int64(n) // conversion — OK
fmt.Println(n, big)
}Comma-ok in select
Il pattern comma-ok funziona anche sulle ricezioni da un canale per rilevare se il canale è stato chiuso. In Go si utilizza lo stesso idioma conciso in modo coerente.
Quando usare i type switch
Casi d'uso comuni:
- Deserializzazione JSON con campi
interface{} - Categorizzazione degli errori
- Instradamento dei messaggi di protocollo
- Controllo opzionale delle interfacce (Flusher, Closer ecc.)
Verifica rapida
Qual è il risultato di un'asserzione di tipo non sicura che fallisce?
Riepilogo
Punti chiave:
x.(T)provoca un panic se il tipo è errato;x, ok := x.(T)è sicura- I type switch gestiscono in modo chiaro più tipi
- Esegua asserzioni verso le interfacce per verificare funzionalità opzionali
- Non esegua mai un'asserzione su un'interfaccia nil
Esercizio
Scriva una funzione sum(values []any) float64 che utilizzi un type switch per gestire valori di tipo int, float64 e string (analizzando la stringa) e ignori gli altri.
Domande Frequenti
La lezione «Asserzioni di tipo e switch sul tipo» è gratuita?
Sì — il testo completo di «Asserzioni di tipo e switch sul tipo» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.
Cosa imparerò in «Asserzioni di tipo e switch sul tipo»?
Asserzioni di tipo sicure e modelli con switch Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Go Academy?
Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Asserzioni di tipo e switch sul tipo»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Go Academy?
Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Definire e implementare le interfacce
- Interfacce fondamentali della libreria standard
- Asserzioni di tipo e switch sul tipo
- Composizione delle interfacce e buone pratiche