Hva er type assertions og type switches?

Question

Accepted Answer

En **type assertion** trekker ut den konkrete typen fra en interfaceverdi, og en **type switch** forgrener seg basert på interfacets underliggende type. De er måten du gjenoppretter spesifikk typeinformasjon fra et interface (spesielt det tomme interfacet / `any`).

## Type assertion — trekk ut 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)` hevder at interface `i` holder en verdi av `Type` og trekker den ut. Men en feil assertion **panikkerer** — så vanligvis bruker du den sikre comma-ok-formen.

## Den sikre comma-ok-formen

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

To-verdiformatet returnerer verdien pluss en boolsk verdi — `ok` er false (i stedet for å panikere) hvis assertion mislykkes. **Foretrekk alltid denne** med mindre du er sikker på typen.

## Type switch — forgrein deg 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)` sjekker den underliggende typen og binder `v` (korrekt typet i hver case). Det er den rene måten å håndtere et interface som kan inneholde flere typer.

## Asserting 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 trenger 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 er viktig

Type assertions og type switches er essensielle verktøy for å arbeide med interfaceverdier — gjenoppretting av konkret typeinformasjon fra `interface{}`/`any` eller kontroll av om en verdi oppfyller et bestemt interface.

De er nødvendige når du håndterer data av ukjent eller variert type (parsing av dynamisk JSON, generisk prosessering, valgfritt-interface-kontroller som "implementerer dette io.Closer?").

Forståelsen av **panic-vs-sikker-distinksjonen** er kritisk: en ordinær assertion `i.(T)` panikkerer ved mismatch, mens **comma-ok-formen** `v, ok := i.(T)` rapporterer feil på en sikker måte — bruk av den sikre formen er en nøkkelpraksis for å unngå runtime-krasj.

Type switchen håndterer elegant flere mulige typer.

Kunnskapen om disse (og at tung bruk ofte signaliserer at du i stedet bør gripe til generics eller bedre typede design) er viktig for sikker, idiomatisk Go og er et vanlig intervjuspørsmål, siden interfaces og det tomme interfacet er så sentrale for språket.