Golang Type Assertion: x.(T), Comma-ok and Type Switch

x.(T): getting the value out of an interface

An interface value hides the concrete type it holds. A type assertion x.(T) asks for it back.

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 must have an interface type. Asserting on a concrete type fails to compile: invalid operation: s (variable of type string) is not an interface.

The one-value form panics

When the assertion is wrong, the single-value form panics with a message naming both types:

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

Use the one-value form only when a different type would be a programming error you want to crash on. Everywhere else, use comma-ok. On failure, comma-ok gives the zero value of T and false.

Asserting on a nil interface fails too: var v any; v.(string) panics with interface conversion: interface {} is nil, not string, and the comma-ok form returns "", false.

Asserting to another interface

T can be an interface type. The assertion then succeeds if the dynamic value implements T, and the result keeps the same dynamic value. This is how the standard library checks for optional capabilities.

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 checks whether its source implements io.WriterTo and uses it when it does. fmt checks for Stringer and error. The pattern lets a small interface stay small while callers still benefit from richer implementations.

Type switch

When a value could be one of several types, a type switch replaces a chain of assertions. x.(type) is only valid inside a 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

Rules worth knowing:

• In a case with one type, x has that type. In a case listing several types, and in default, x has the type of the original interface (any here).
• Cases are checked in order. Put more specific interfaces before broader ones, since a value can satisfy several.
• case nil matches only a nil interface, not an interface holding a nil pointer.
• There is no fallthrough in a type switch.

errors.As: the assertion for wrapped errors

Errors are often wrapped with context: fmt.Errorf("load config: %w", err). A direct type assertion looks only at the outermost error and misses the one inside. errors.As walks the chain.

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

Use a type assertion on errors only when you know the error is not wrapped, which in practice means almost never. The custom errors page covers errors.As, errors.Is and defining your own error types.

Assertions vs conversions vs generics

Code full of any and type switches is often a sign that generics or a proper interface would express the intent better and catch mistakes at compile time.

Common mistakes

• Using the panicking form on untrusted data. Decoded JSON, map values of type any, plugin inputs: always comma-ok.
• Asserting to the wrong numeric type. JSON numbers decode into any as float64, so v.(int) fails on them.
• Asserting a value type when a pointer is stored. If the interface holds *User, then v.(User) fails. Assert v.(*User).
• Type assertions on errors. Use errors.As.