Aserción de tipo en Golang: x.(T), comma-ok y type switch

x.(T): sacar el valor de una interfaz

Un valor de interfaz oculta el tipo concreto que contiene. Una aserción de tipo x.(T) lo recupera.

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

Salida:

gopher 6
0 false
string of length 6

x tiene que tener un tipo interfaz. Hacer una aserción sobre un tipo concreto no compila: invalid operation: s (variable of type string) is not an interface.

La forma de un solo valor provoca un panic

Cuando la aserción es incorrecta, la forma de un solo valor provoca un panic con un mensaje que nombra los dos tipos:

package main

import "fmt"

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

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

Salida:

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

Usa la forma de un solo valor solo cuando otro tipo sería un error de programación ante el que quieres que el programa caiga. En todos los demás casos, usa comma-ok. Si falla, comma-ok da el valor cero de T y false.

Una aserción sobre una interfaz nil también falla: var v any; v.(string) provoca un panic con interface conversion: interface {} is nil, not string, y la forma comma-ok devuelve "", false.

Aserción a otra interfaz

T puede ser un tipo interfaz. La aserción tiene éxito entonces si el valor dinámico implementa T, y el resultado conserva el mismo valor dinámico. Así es como la librería estándar comprueba capacidades opcionales.

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 comprueba si su origen implementa io.WriterTo y lo usa cuando lo hace. fmt comprueba Stringer y error. El patrón permite que una interfaz pequeña siga siendo pequeña mientras quien la usa aprovecha implementaciones más ricas.

Type switch

Cuando un valor puede ser de varios tipos, un type switch sustituye a una cadena de aserciones. x.(type) solo es válido dentro de 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))
	}
}

Salida:

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

Reglas que conviene conocer:

• En un caso con un solo tipo, x tiene ese tipo. En un caso que enumera varios tipos, y en default, x tiene el tipo de la interfaz original (aquí any).
• Los casos se comprueban en orden. Pon las interfaces más específicas antes que las más amplias, porque un valor puede cumplir varias.
• case nil solo coincide con una interfaz nil, no con una interfaz que contiene un puntero nil.
• En un type switch no existe fallthrough.

errors.As: la aserción para errores envueltos

Los errores se suelen envolver con contexto: fmt.Errorf("load config: %w", err). Una aserción de tipo directa solo mira el error más exterior y no ve el de dentro. errors.As recorre la cadena.

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

Salida:

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

Usa una aserción de tipo sobre errores solo cuando sepas que el error no está envuelto, lo que en la práctica es casi nunca. La página de errores personalizados cubre errors.As, errors.Is y cómo definir tus propios tipos de error.

Aserciones frente a conversiones y genéricos

Un código lleno de any y type switches suele indicar que los genéricos o una interfaz bien pensada expresarían mejor la intención y detectarían los errores al compilar.

Errores comunes

• Usar la forma que provoca un panic con datos no fiables. JSON decodificado, valores de un map de tipo any, entradas de plugins: siempre comma-ok.
• Hacer la aserción al tipo numérico equivocado. Los números JSON se decodifican en any como float64, así que v.(int) falla con ellos.
• Hacer la aserción a un tipo valor cuando lo guardado es un puntero. Si la interfaz contiene *User, v.(User) falla. Haz la aserción v.(*User).
• Aserciones de tipo sobre errores. Usa errors.As.