Asercja typu w Golang: x.(T), comma-ok i type switch

x.(T): wydobywanie wartości z interfejsu

Wartość interfejsu ukrywa konkretny typ, który przechowuje. Asercja typu x.(T) prosi o jego zwrot.

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

Wynik:

gopher 6
0 false
string of length 6

x musi mieć typ interfejsu. Asercja na typie konkretnym się nie kompiluje: invalid operation: s (variable of type string) is not an interface.

Forma z jedną wartością wywołuje panic

Gdy asercja jest błędna, forma z jedną wartością wywołuje panic z komunikatem, który podaje oba typy:

package main

import "fmt"

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

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

Wynik:

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

Używaj formy z jedną wartością tylko wtedy, gdy inny typ byłby błędem programistycznym, przy którym program ma się wysypać. Wszędzie indziej używaj comma-ok. Przy niepowodzeniu comma-ok daje wartość zerową T i false.

Asercja na interfejsie nil też się nie udaje: var v any; v.(string) wywołuje panic z komunikatem interface conversion: interface {} is nil, not string, a forma comma-ok zwraca "", false.

Asercja do innego interfejsu

T może być typem interfejsu. Asercja udaje się wtedy, jeśli dynamiczna wartość implementuje T, a wynik zachowuje tę samą dynamiczną wartość. Tak biblioteka standardowa sprawdza opcjonalne możliwości.

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 sprawdza, czy jego źródło implementuje io.WriterTo, i jeśli tak, używa go. fmt sprawdza Stringer i error. Ten wzorzec pozwala małemu interfejsowi pozostać małym, a wywołujący i tak korzystają z bogatszych implementacji.

Type switch

Gdy wartość może być jednym z kilku typów, type switch zastępuje łańcuch asercji. x.(type) jest poprawne tylko wewnątrz 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))
	}
}

Wynik:

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

Zasady, które warto znać:

• W przypadku z jednym typem x ma ten typ. W przypadku z kilkoma typami oraz w default x ma typ oryginalnego interfejsu (tutaj any).
• Przypadki są sprawdzane po kolei. Bardziej szczegółowe interfejsy umieszczaj przed ogólniejszymi, bo wartość może spełniać kilka z nich.
• case nil pasuje tylko do interfejsu nil, a nie do interfejsu przechowującego wskaźnik nil.
• W type switch nie ma fallthrough.

errors.As: asercja dla opakowanych błędów

Błędy często opakowuje się kontekstem: fmt.Errorf("load config: %w", err). Bezpośrednia asercja typu patrzy tylko na najbardziej zewnętrzny błąd i pomija ten w środku. errors.As przechodzi przez łańcuch.

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

Wynik:

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

Asercji typu na błędach używaj tylko wtedy, gdy wiesz, że błąd nie jest opakowany, czyli w praktyce prawie nigdy. Strona o własnych błędach omawia errors.As, errors.Is i definiowanie własnych typów błędów.

Asercje a konwersje a generyki

Kod pełen any i type switch często oznacza, że generyki albo porządny interfejs lepiej wyraziłyby intencję i wyłapały błędy podczas kompilacji.

Typowe błędy

• Używanie formy z panic na niezaufanych danych. Zdekodowany JSON, wartości mapy typu any, dane z wtyczek: zawsze comma-ok.
• Asercja do złego typu liczbowego. Liczby z JSON dekodują się do any jako float64, więc v.(int) na nich zawodzi.
• Asercja do typu wartości, gdy zapisany jest wskaźnik. Jeśli interfejs przechowuje *User, to v.(User) zawodzi. Zrób asercję v.(*User).
• Asercje typu na błędach. Użyj errors.As.