Što su type assertions i 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
```

## Zašto je to važno

Type assertions i type switches su bitni alati za rad s interface vrijednostima — obnavljanje konkretne type informacije iz `interface{}`/`any` ili provjera zadovoljava li vrijednost određeni interface.

Potrebni su pri radu s podacima nepoznatog ili različitog tipa (parsiranje dinamičnog JSON-a, generička obrada, provjere opcionalno-interface-a kao "implementira li ovo io.Closer?").

Razumijevanje **panic-vs-safe razlike** je kritično: obična assertion `i.(T)` izaziva paniku pri nepodudaranju, dok **comma-ok forma** `v, ok := i.(T)` sigurno izvještava o neuspjehu — korištenje sigurne forme je ključna praksa za izbjegavanje runtime kraševa.

Type switch elegantno rukuje s više mogućih tipova.

Znanje tih alata (i da intenzivna upotreba često signalizira da bi trebali posegnuti za generics ili bolje-tipiziranim dizajnom) je važno za siguran, idiomatski Go i čest je intervju topic, jer su interfacei i empty interface toliko centralni jeziku.