Co jsou aserce typů a přepínače typů?

Question

Accepted Answer

**Aserce typu** extrahuje konkrétní typ z hodnoty rozhraní a **přepínač typu** rozděluje kód na základě podkladového typu rozhraní. Jedná se o způsob, jak obnovit specifické informace o typu z rozhraní (zejména prázdného rozhraní / `any`).

## Aserce typu — extrahování konkrétního typu

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

Syntaxe `i.(Type)` tvrdí, že rozhraní `i` obsahuje hodnotu typu `Type` a extrahuje ji. Nicméně nesprávná aserce **vyvolá paniku** — takže obvykle používáte bezpečnou formu s čárkou a ok.

## Bezpečná forma s čárkou-ok

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

Dvojhodnotová forma vrací hodnotu plus logickou hodnotu — `ok` je false (místo vyvolání paniky), pokud aserce selže. **Vždy preferujte toto**, pokud si nejste jistí typem.

## Přepínač typu — rozdělení na základě více možných typů

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

Forma `switch v := i.(type)` kontroluje podkladový typ a váže `v` (typově vhodné v každém případě). Jedná se o čistý způsob, jak zpracovat rozhraní, které by mohlo obsahovat několik typů.

## Aserce i typů rozhraní

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

## Kdy je potřebujete

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

## Proč na tom záleží

Aserce typů a přepínače typů jsou nezbytné nástroje pro práci s hodnotami rozhraní — obnovují konkrétní informace o typu z `interface{}`/`any` nebo kontrolují, zda hodnota splňuje konkrétní rozhraní.

Sou nutné při zpracování dat neznámého nebo proměnlivého typu (analýza dynamického JSON, obecné zpracování, kontroly volitelného rozhraní jako "implementuje toto io.Closer?").

Porozumění **rozlišení paniky versus bezpečnosti** je kritické: prostá aserce `i.(T)` vyvolá paniku při neshodě, zatímco **forma s čárkou-ok** `v, ok := i.(T)` bezpečně hlásí selhání — použití bezpečné formy je klíčovou praxí, aby se zabránilo chybám za běhu.

Přepínač typu elegantně zpracovává více možných typů.

Znalost těchto nástrojů (a to, že jejich intenzivní použití často signalizuje, že byste měli zvážit generiky nebo lépe typované návrhy) je důležitá pro bezpečný a idiomatický Go a je běžným tématem při pohovorech, protože rozhraní a prázdné rozhraní jsou v jazyce tak centrální.