Type assertions and type switches

Getting the concrete value back out of an interface, safely.

Topic 18 of 98 · 5 min to read · 45 min to build

After this topic you can

Write a comma-ok type assertion that never panics.
Write a type switch that handles several concrete types and a default.
Fix a type switch where a broad interface case hides a more specific one.

The problem

An interface value hides what is inside it. A variable of type any might hold an int, a string, or your own struct. Most of the time that is the point: you call the methods and do not care.

Sometimes you do care. A type assertion asks "is the value inside this interface of type T?", and if so gives it back to you as a T.

Type assertions, and the comma-ok form

assert.go

1package main
2
3import "fmt"
4
5func main() {
6	var v any = "hello"
7
8	s := v.(string) // "I am sure it is a string"
9	fmt.Println(s, len(s))
10
11	n, ok := v.(int) // "is it an int?" — no panic, just ok=false
12	fmt.Println(n, ok) // 0 false
13
14	if s, ok := v.(string); ok {
15		fmt.Println("it was a string:", s)
16	}
17
18	// v.(int) without the ok would panic:
19	// interface conversion: interface {} is string, not int
20}

Use the one-value form only when a wrong type is a bug that should crash. Everywhere else, use comma-ok.

Type switches

When there are several types to check, a type switch does all the assertions in one go. Inside each case, the variable already has that case’s type.

switch.go

1package main
2
3import "fmt"
4
5type Point struct{ X, Y int }
6
7func describe(v any) string {
8	switch x := v.(type) {
9	case nil:
10		return "nothing"
11	case int:
12		return fmt.Sprintf("an int, doubled is %d", x*2) // x is an int here
13	case string:
14		return fmt.Sprintf("a string of %d bytes", len(x)) // x is a string here
15	case Point:
16		return fmt.Sprintf("a point at %d,%d", x.X, x.Y)
17	case error:
18		return "an error: " + x.Error() // cases can be interfaces too
19	default:
20		return fmt.Sprintf("something else: %T", x)
21	}
22}
23
24func main() {
25	fmt.Println(describe(nil))
26	fmt.Println(describe(21))
27	fmt.Println(describe("héllo"))
28	fmt.Println(describe(Point{1, 2}))
29	fmt.Println(describe(fmt.Errorf("boom")))
30	fmt.Println(describe(3.5))
31}

`.(type)` only works inside a `switch`. Cases are checked top to bottom, so put specific types before broad interfaces.

Errors are often wrapped inside other errors, which a plain type assertion cannot see through. The tool for that is covered in Error values in depth.

Watch out: A long type switch over your own types is often a sign that a method is missing. If every case calls a different "area" formula, give the types an Area() method and an interface instead. Switch on types at the edges, where values arrive as any (JSON, config, errors).

The short version

v.(T) gets a T out of an interface, and panics if it is not one.
t, ok := v.(T) never panics. ok tells you whether it worked.
switch x := v.(type) checks many types at once; in each case x has that type.
Cases run top to bottom, so put specific types before broad interfaces.

Remember: Comma-ok unless a wrong type is a bug.

Build this before moving on

Write func sum(values []any) (float64, error) that adds up ints, float64s and numeric strings (use strconv.ParseFloat), and returns an error naming the first value of any other type.

Coding challenge · checked by tests

Write Describe(v any) string with a type switch. An int gives "int N", a string gives "string of N bytes", a bool gives "bool", and anything else gives "unknown". Examples: 21 → "int 21", "héllo" → "string of 6 bytes", true → "bool", 3.5 → "unknown".

Tab indents. Press Esc, then Tab, to leave the editor.

Then try these in your own editor

1Assert any(42).(string) without comma-ok and read the panic.
2In a type switch, put case error: above case *MyError: and see what happens.
3Write a case that lists two types, case int, int64:, and print %T of the variable inside it.

Official documentation

Check yourselfTake the Core language test