What are type assertions and type switches?

Question

Accepted Answer

A **type assertion** extracts the concrete type from an interface value, and a **type switch** branches on an interface's underlying type. They're how you recover specific type information from an interface (especially the empty interface / `any`).

## Type assertion — extract a concrete type

```go
var i interface{} = "hello"     // an interface holding a string

s := i.(string)                  // assert it's a string → s = "hello"
fmt.Println(s)

n := i.(int)                     // ❌ PANIC — i is not an int (wrong assertion)
```

The `i.(Type)` syntax asserts that interface `i` holds a value of `Type` and extracts it. But a wrong assertion **panics** — so usually you use the safe comma-ok form.

## The safe comma-ok form

```go
s, ok := i.(string)
if ok {
    fmt.Println("it's a string:", s)   // ok = true, s = the value
} else {
    fmt.Println("not a string")         // ok = false, s = zero value, NO panic
}
```

The two-value form returns the value plus a boolean — `ok` is false (instead of panicking) if the assertion fails. **Always prefer this** unless you're certain of the type.

## Type switch — branch on multiple possible types

```go
func describe(i interface{}) string {
    switch v := i.(type) {           // the special .(type) form, only in a switch
    case int:
        return fmt.Sprintf("int: %d (doubled: %d)", v, v*2)
    case string:
        return fmt.Sprintf("string of length %d", len(v))
    case bool:
        return fmt.Sprintf("bool: %t", v)
    case nil:
        return "nil value"
    default:
        return fmt.Sprintf("unknown type: %T", v)
    }
}

describe(42)        // "int: 42 (doubled: 84)"
describe("hi")      // "string of length 2"
```

The `switch v := i.(type)` form checks the underlying type and binds `v` (typed appropriately in each case). It's the clean way to handle an interface that could hold several types.

## Asserting interface types too

```go
// assert that a value implements a specific interface
if w, ok := i.(io.Writer); ok {
    w.Write([]byte("data"))    // use it as an io.Writer if it satisfies that interface
}
```

## When you need these

```text
✓ Processing values of unknown type (interface{}/any) — JSON, generic handlers
✓ Checking if a value implements an optional interface (e.g. io.Closer)
✓ Handling heterogeneous data
⚠️ Often a sign you could use generics or better-typed interfaces instead — don't overuse
```

## Why it matters

Type assertions and type switches are essential tools for working with interface values — recovering concrete type information from `interface{}`/`any` or checking whether a value satisfies a particular interface.

They're needed when handling data of unknown or varied types (parsing dynamic JSON, generic processing, optional-interface checks like "does this implement io.Closer?").

Understanding the **panic-vs-safe distinction** is critical: a plain assertion `i.(T)` panics on mismatch, while the **comma-ok form** `v, ok := i.(T)` safely reports failure — using the safe form is a key practice to avoid runtime crashes.

The type switch elegantly handles multiple possible types.

Knowing these (and that heavy use often signals you should reach for generics or better-typed designs instead) is important for safe, idiomatic Go and a common interview topic, since interfaces and the empty interface are so central to the language.