Type assertion em Golang: x.(T), vírgula-ok e type switch

x.(T): tirando o valor de dentro de uma interface

Um valor de interface esconde o tipo concreto que guarda. Uma type assertion x.(T) pede esse tipo de volta.

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

Saída:

gopher 6
0 false
string of length 6

x precisa ter um tipo interface. Fazer assertion sobre um tipo concreto não compila: invalid operation: s (variable of type string) is not an interface.

A forma de um valor causa panic

Quando a assertion está errada, a forma de um único valor causa panic com uma mensagem que nomeia os dois tipos:

package main

import "fmt"

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

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

Saída:

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

Use a forma de um valor só quando um tipo diferente for um erro de programação no qual você quer que o programa caia. Em todos os outros casos, use vírgula-ok. Em caso de falha, a vírgula-ok devolve o valor zero de T e false.

Fazer assertion em uma interface nil também falha: var v any; v.(string) causa panic com interface conversion: interface {} is nil, not string, e a forma vírgula-ok devolve "", false.

Assertion para outra interface

T pode ser um tipo interface. Nesse caso a assertion dá certo se o valor dinâmico implementar T, e o resultado mantém o mesmo valor dinâmico. É assim que a biblioteca padrão verifica capacidades opcionais.

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

O io.Copy verifica se a origem implementa io.WriterTo e o usa quando implementa. O fmt verifica Stringer e error. O padrão permite que uma interface pequena continue pequena enquanto quem chama ainda se beneficia de implementações mais ricas.

Type switch

Quando um valor pode ser de um entre vários tipos, um type switch substitui uma cadeia de assertions. x.(type) só é válido dentro de um 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))
	}
}

Saída:

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

Regras que valem a pena conhecer:

• Em um case com um único tipo, x tem esse tipo. Em um case que lista vários tipos, e no default, x tem o tipo da interface original (any aqui).
• Os cases são verificados em ordem. Coloque interfaces mais específicas antes das mais amplas, já que um valor pode satisfazer várias.
• case nil só casa com uma interface nil, não com uma interface que guarda um ponteiro nil.
• Não existe fallthrough em um type switch.

errors.As: a assertion para erros empacotados

Erros são muitas vezes empacotados com contexto: fmt.Errorf("load config: %w", err). Uma type assertion direta só olha o erro mais externo e deixa passar o que está dentro. O errors.As percorre a cadeia.

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

Saída:

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

Use type assertion em erros só quando você sabe que o erro não está empacotado, o que na prática quer dizer quase nunca. A página de erros personalizados cobre errors.As, errors.Is e a definição dos seus próprios tipos de erro.

Assertions, conversões e generics

Código cheio de any e type switches costuma ser sinal de que generics ou uma interface adequada expressariam melhor a intenção e pegariam erros em tempo de compilação.

Erros comuns

• Usar a forma que causa panic em dados não confiáveis. JSON decodificado, valores de map do tipo any, entradas de plugins: sempre vírgula-ok.
• Fazer assertion para o tipo numérico errado. Números JSON são decodificados em any como float64, então v.(int) falha com eles.
• Fazer assertion de um tipo valor quando um ponteiro está guardado. Se a interface guarda *User, então v.(User) falha. Faça v.(*User).
• Type assertions em erros. Use errors.As.