Hvad er type assertions og type switches?

Question

Accepted Answer

En **type assertion** ekstraherer den konkrete type fra en interface-værdi, og en **type switch** forgrener sig baseret på en interfaces underliggende type. De er hvordan du genvinder specifik typeinformation fra en interface (især den tomme interface / `any`).

## Type assertion — ekstrahér en konkret 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)
```

Syntaksen `i.(Type)` asserterer, at interface `i` indeholder en værdi af `Type` og ekstraherer den. Men en forkert assertion **panikker** — så normalt bruger du den sikre comma-ok form.

## Den sikre 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
}
```

Toværdi-formen returnerer værdien plus en boolean — `ok` er false (i stedet for at panikke) hvis assertionen fejler. **Foretrække altid denne** medmindre du er sikker på typen.

## Type switch — forgren dig baseret på flere mulige typer

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

Formen `switch v := i.(type)` kontrollerer den underliggende type og binder `v` (korrekt typet i hver case). Det er den rene måde at håndtere en interface, der kunne indeholde flere typer.

## Assertering af interface-typer også

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

## Når du har brug for disse

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

## Hvorfor det betyder noget

Type assertions og type switches er vigtige værktøjer til at arbejde med interface-værdier — genvinde konkret typeinformation fra `interface{}`/`any` eller kontrollere, om en værdi opfylder en bestemt interface.

De er nødvendige ved håndtering af data af ukendt eller varieret type (parsing dynamisk JSON, generisk behandling, optionelle-interface-checks som "implementerer dette io.Closer?").

At forstå **panic-vs-sikker skelnen** er kritisk: en simpel assertion `i.(T)` panikker ved mismatch, mens **comma-ok formen** `v, ok := i.(T)` sikkert rapporterer fejl — at bruge den sikre form er en nøglepraksis for at undgå runtime-nedbrud.

Type switch håndterer elegant flere mulige typer.

At kende disse (og at kraftig brug ofte signalerer, at du bør nå til generics eller bedre-typede designs i stedet) er vigtig for sikker, idiomatisk Go og et almindeligt interviewemne, da interfaces og den tomme interface er så centrale for sproget.