Assertion de type en Golang : x.(T), comma-ok et type switch

x.(T) : récupérer la valeur d'une interface

Une valeur interface cache le type concret qu'elle contient. Une assertion de type x.(T) le redemande.

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))
	}
}

Sortie :

gopher 6
0 false
string of length 6

x doit avoir un type interface. Une assertion sur un type concret ne compile pas : invalid operation: s (variable of type string) is not an interface.

La forme à une valeur provoque un panic

Quand l'assertion est fausse, la forme à une seule valeur provoque un panic avec un message qui nomme les deux types :

package main

import "fmt"

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

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

Sortie :

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

N'utilisez la forme à une valeur que lorsqu'un type différent serait une erreur de programmation sur laquelle vous voulez planter. Partout ailleurs, utilisez comma-ok. En cas d'échec, comma-ok donne la valeur zéro de T et false.

Une assertion sur une interface nil échoue aussi : var v any; v.(string) provoque le panic interface conversion: interface {} is nil, not string, et la forme comma-ok renvoie "", false.

Assertion vers une autre interface

T peut être un type interface. L'assertion réussit alors si la valeur dynamique implémente T, et le résultat garde la même valeur dynamique. C'est ainsi que la bibliothèque standard teste des capacités facultatives.

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 vérifie si sa source implémente io.WriterTo et l'utilise si c'est le cas. fmt vérifie Stringer et error. Ce motif permet à une petite interface de rester petite tout en laissant les appelants profiter d'implémentations plus riches.

Type switch

Quand une valeur peut être de plusieurs types, un type switch remplace une chaîne d'assertions. x.(type) n'est valide qu'à l'intérieur d'un 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))
	}
}

Sortie :

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

Règles à connaître :

• Dans un cas avec un seul type, x a ce type. Dans un cas qui liste plusieurs types, et dans default, x a le type de l'interface d'origine (any ici).
• Les cas sont testés dans l'ordre. Placez les interfaces plus spécifiques avant les plus larges, puisqu'une valeur peut en satisfaire plusieurs.
• case nil ne correspond qu'à une interface nil, pas à une interface contenant un pointeur nil.
• Il n'y a pas de fallthrough dans un type switch.

errors.As : l'assertion pour les erreurs enveloppées

Les erreurs sont souvent enveloppées avec du contexte : fmt.Errorf("load config: %w", err). Une assertion de type directe ne regarde que l'erreur la plus extérieure et rate celle qui est à l'intérieur. errors.As parcourt la chaîne.

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)
	}
}

Sortie :

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

N'utilisez une assertion de type sur des erreurs que si vous savez que l'erreur n'est pas enveloppée, ce qui en pratique n'arrive presque jamais. La page sur les erreurs personnalisées couvre errors.As, errors.Is et la définition de vos propres types d'erreur.

Assertions, conversions ou génériques

Du code rempli de any et de type switches est souvent le signe que les génériques ou une vraie interface exprimeraient mieux l'intention et détecteraient les erreurs à la compilation.

Erreurs courantes

• Utiliser la forme qui panique sur des données non fiables. JSON décodé, valeurs de map de type any, entrées de plugins : toujours comma-ok.
• Faire une assertion vers le mauvais type numérique. Les nombres JSON se décodent dans un any en float64, donc v.(int) échoue sur eux.
• Faire une assertion vers un type valeur quand un pointeur est stocké. Si l'interface contient un *User, v.(User) échoue. Faites l'assertion v.(*User).
• Des assertions de type sur des erreurs. Utilisez errors.As.