Wat zijn type assertions en type switches?

Question

Accepted Answer

Een **type assertion** extraheert het concrete type uit een interfacewaarde, en een **type switch** vertakt op het onderliggende type van een interface. Dit zijn de manier waarop je specifieke typeinformatie uit een interface kunt terugwinnen (vooral de lege interface / `any`).

## Type assertion — een concrete type extraheren

```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)
```

De `i.(Type)` syntaxis stelt dat interface `i` een waarde van `Type` bevat en extraheert deze. Maar een foutieve assertion veroorzaakt **panic** — dus meestal gebruik je de veilige comma-ok vorm.

## De veilige comma-ok vorm

```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
}
```

De twee-waarde vorm retourneert de waarde plus een boolean — `ok` is false (in plaats van paniek) als de assertion mislukt. **Gebruik dit altijd** tenzij je zeker bent van het type.

## Type switch — vertakken op meerdere mogelijke typen

```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"
```

De `switch v := i.(type)` vorm controleert het onderliggende type en bindt `v` (op de juiste manier getypeerd in elk geval). Dit is de schone manier om met een interface om te gaan die meerdere typen kan bevatten.

## Interfacetypen ook asserteren

```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
}
```

## Wanneer je dit nodig hebt

```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
```

## Waarom het belangrijk is

Type assertions en type switches zijn essentiële gereedschappen voor het werken met interfacewaarden — het terugwinnen van concrete typeinformatie uit `interface{}`/`any` of controleren of een waarde een bepaalde interface implementeert.

Ze zijn nodig bij het verwerken van gegevens van onbekend of gevarieerd type (dynamische JSON parseren, generieke verwerking, optionele-interface controles zoals "implementeert dit io.Closer?").

Het begrijpen van het **panic-vs-safe onderscheid** is kritiek: een gewone assertion `i.(T)` paniceert bij mismatch, terwijl de **comma-ok vorm** `v, ok := i.(T)` veilig meldt dat het mislukt is — het gebruik van de veilige vorm is een sleutel praktijk om runtime crashes te voorkomen.

De type switch behandelt elegant meerdere mogelijke typen.

Het kennen van deze (en het feit dat intensief gebruik vaak aangeeft dat je in plaats daarvan generics of beter getypeerde ontwerpen zou moeten gebruiken) is belangrijk voor veilig, idiomatic Go en een veelgesteld onderwerp in interviews, aangezien interfaces en de lege interface zo centraal voor de taal zijn.