Type assertion in Golang: x.(T), comma-ok e type switch

x.(T): estrarre il valore da un'interfaccia

Un valore interfaccia nasconde il tipo concreto che contiene. Una type assertion x.(T) te lo restituisce.

package main

import "fmt"

func main() {
	var v any = "gopher"

	s := v.(string) // v holds a string: ok
	fmt.Println(s, len(s))

	n, ok := v.(int) // comma-ok: no panic on mismatch
	fmt.Println(n, ok)

	if str, ok := v.(string); ok {
		fmt.Println("string of length", len(str))
	}
}

Output:

gopher 6
0 false
string of length 6

x deve avere un tipo interfaccia. Un'asserzione su un tipo concreto non compila: invalid operation: s (variable of type string) is not an interface.

La forma a un valore va in panic

Quando l'asserzione è sbagliata, la forma a un solo valore va in panic con un messaggio che indica entrambi i tipi:

package main

import "fmt"

func main() {
	defer func() {
		fmt.Println("recovered:", recover())
	}()

	var v any = 42
	s := v.(string)
	fmt.Println(s)
}

Output:

recovered: interface conversion: interface {} is int, not string

Usa la forma a un valore solo quando un tipo diverso sarebbe un errore di programmazione per cui vuoi che il programma si fermi. In tutti gli altri casi usa comma-ok. Se fallisce, comma-ok restituisce il valore zero di T e false.

Anche un'asserzione su un'interfaccia nil fallisce: var v any; v.(string) va in panic con interface conversion: interface {} is nil, not string, e la forma comma-ok restituisce "", false.

Asserzione verso un'altra interfaccia

T può essere un tipo interfaccia. L'asserzione riesce allora se il valore dinamico implementa T, e il risultato mantiene lo stesso valore dinamico. È così che la libreria standard verifica le funzionalità opzionali.

package main

import (
	"fmt"
	"strings"
)

type Temp float64

func (t Temp) String() string { return fmt.Sprintf("%.1f degrees", float64(t)) }

func describe(v any) string {
	if s, ok := v.(fmt.Stringer); ok {
		return "Stringer: " + s.String()
	}
	return fmt.Sprintf("plain value: %v", v)
}

func main() {
	fmt.Println(describe(Temp(21.5)))
	fmt.Println(describe(42))

	// io.Copy uses the same trick to check for WriterTo / ReaderFrom.
	var r any = strings.NewReader("x")
	_, hasLen := r.(interface{ Len() int })
	fmt.Println("has Len:", hasLen)
}

io.Copy verifica se la sua sorgente implementa io.WriterTo e, se sì, la usa. fmt verifica Stringer ed error. Questo schema permette a un'interfaccia piccola di restare piccola, mentre i chiamanti sfruttano comunque implementazioni più ricche.

Type switch

Quando un valore può essere di diversi tipi, un type switch sostituisce una catena di asserzioni. x.(type) è valido solo dentro uno switch.

package main

import (
	"fmt"
	"strconv"
)

func toString(v any) string {
	switch x := v.(type) {
	case nil:
		return "nil"
	case string:
		return x // x is a string here
	case int, int64:
		return fmt.Sprintf("integer %v", x) // x is any: two types in one case
	case float64:
		return strconv.FormatFloat(x, 'f', 2, 64)
	case fmt.Stringer:
		return x.String()
	case error:
		return "error: " + x.Error()
	default:
		return fmt.Sprintf("unhandled %T", x)
	}
}

func main() {
	values := []any{"hi", 7, int64(8), 3.14159, nil, fmt.Errorf("boom"), []int{1}}
	for _, v := range values {
		fmt.Println(toString(v))
	}
}

Output:

hi
integer 7
integer 8
3.14
nil
error: boom
unhandled []int

Regole utili da conoscere:

• In un caso con un solo tipo, x ha quel tipo. In un caso che elenca più tipi, e in default, x ha il tipo dell'interfaccia originale (qui any).
• I casi vengono controllati in ordine. Metti le interfacce più specifiche prima di quelle più ampie, perché un valore può soddisfarne diverse.
• case nil corrisponde solo a un'interfaccia nil, non a un'interfaccia che contiene un puntatore nil.
• In un type switch non esiste fallthrough.

errors.As: l'asserzione per gli errori incapsulati

Gli errori vengono spesso incapsulati aggiungendo contesto: fmt.Errorf("load config: %w", err). Una type assertion diretta guarda solo l'errore più esterno e non vede quello interno. errors.As percorre la catena.

package main

import (
	"errors"
	"fmt"
	"io/fs"
	"os"
)

func load() error {
	_, err := os.Open("/no/such/file")
	if err != nil {
		return fmt.Errorf("load config: %w", err)
	}
	return nil
}

func main() {
	err := load()

	_, ok := err.(*fs.PathError)
	fmt.Println("type assertion finds it:", ok)

	var pe *fs.PathError
	if errors.As(err, &pe) {
		fmt.Println("errors.As finds it:", pe.Op, pe.Path)
	}
}

Output:

type assertion finds it: false
errors.As finds it: open /no/such/file

Usa una type assertion sugli errori solo quando sai che l'errore non è incapsulato, cioè in pratica quasi mai. La pagina sugli errori personalizzati tratta errors.As, errors.Is e la definizione dei tuoi tipi di errore.

Asserzioni, conversioni e generics

Un codice pieno di any e type switch è spesso il segnale che i generics o un'interfaccia ben fatta esprimerebbero meglio l'intenzione e troverebbero gli errori in fase di compilazione.

Errori comuni

• Usare la forma che va in panic su dati non affidabili. JSON decodificato, valori di mappa di tipo any, input di plugin: sempre comma-ok.
• Asserire il tipo numerico sbagliato. I numeri JSON vengono decodificati in any come float64, quindi v.(int) fallisce su di essi.
• Asserire un tipo valore quando è memorizzato un puntatore. Se l'interfaccia contiene *User, allora v.(User) fallisce. Asserisci v.(*User).
• Type assertion sugli errori. Usa errors.As.