Type assertion in Go allows safely extracting the concrete value from an interface by checking its underlying type, using either the two-value form to avoid panics or direct assertion when the type is certain. 1. Use the safe two-value form: value, ok := interfaceVariable.(Type), where ok is true if the assertion succeeds. 2. Avoid the single-value form: value := interfaceVariable.(Type), as it panics if the type is incorrect. 3. Apply type assertions with custom interfaces to access methods beyond the interface definition, such as asserting a concrete type like Dog from a Speaker interface to call Fetch(). 4. Prefer type switches when handling multiple types, using switch val := v.(type) to cleanly branch on string, int, bool, or default cases. Always favor safety, use type assertions judiciously, and consider interfaces or generics for better design.

Type assertion in Go is a way to check the underlying type of an interface value or to extract the concrete value stored inside an interface. It's commonly used when you're working with interface{} (empty interface) or interface types and need to access the actual data or call methods that aren't part of the interface definition.

How Type Assertion Works

In Go, interfaces store both a concrete type and a value. Type assertion allows you to "assert" that the stored type is what you expect and retrieve its value.

The basic syntax is:

value, ok := interfaceVariable.(Type)

Or, if you're confident about the type:

value := interfaceVariable.(Type) // panic if wrong type

Let’s break this down.

1. Safe Type Assertion (with two-value form)

This is the safe way — it checks whether the interface holds the specified type.

var i interface{} = "hello"

s, ok := i.(string)
if ok {
    fmt.Println("It's a string:", s)
} else {
    fmt.Println("It's not a string")
}

• s will hold the value if the assertion succeeds.
• ok is a boolean indicating whether the type was actually string.

This pattern is widely used because it prevents panics.

2. Direct Type Assertion (can panic)

If you skip the ok check and the type is wrong, your program will panic:

var i interface{} = 42
s := i.(string) // PANIC: interface holds int, not string

So always use the two-value form unless you're certain of the type.

3. Using Type Assertion with Custom Interfaces

Suppose you have an interface with limited methods, but you know the underlying type has more functionality:

type Speaker interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string { return "Woof" }
func (d Dog) Fetch() string { return "Fetching!" }

var s Speaker = Dog{}

// Assert that s is actually a Dog
if dog, ok := s.(Dog); ok {
    fmt.Println(dog.Fetch()) // Now we can call Fetch()
}

Here, Speaker doesn't have Fetch, but by asserting the concrete type, we gain access to it.

4. Type Switch – A Cleaner Alternative for Multiple Types

When checking multiple possible types, a type switch is often cleaner:

func do(v interface{}) {
    switch val := v.(type) {
    case string:
        fmt.Println("String:", val)
    case int:
        fmt.Println("Int:", val)
    case bool:
        fmt.Println("Boolean:", val)
    default:
        fmt.Println("Unknown type")
    }
}

The v.(type) syntax only works inside switch statements and lets you handle each case safely.

Key Points to Remember

• Type assertion only works on interface types.
• Always prefer the two-value form (value, ok) in production code.
• Avoid direct assertions unless you control the input.
• Use type switches when dealing with multiple possible types.
• A failed assertion in single-value form causes a runtime panic.

Type assertion is powerful but should be used carefully. Overuse might indicate a design that could benefit from better structuring with interfaces or generics (available since Go 1.18).

Basically, it’s Go’s way of saying: “I know this interface holds a specific type — let me get it out safely.”

The above is the detailed content of What is type assertion and how does it work in Go?. For more information, please follow other related articles on the PHP Chinese website!