Czym są asercje typów i przełączniki typów?

Question

Accepted Answer

**Asercja typu** wyodrębnia konkretny typ z wartości interfejsu, a **przełącznik typu** rozgałęzia się na podstawie typu podstawowego interfejsu. To sposób, w który odzyskujesz konkretne informacje o typie z interfejsu (szczególnie pustego interfejsu / `any`).

## Asercja typu — wyodrębnienie konkretnego 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)
```

Syntaksa `i.(Type)` stwierdza, że interfejs `i` przechowuje wartość typu `Type` i wyodrębnia ją. Ale błędna asercja **panikuje** — więc zwykle używasz bezpiecznej formy comma-ok.

## Bezpieczna forma comma-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
}
```

Forma dwuwartościowa zwraca wartość plus wartość logiczną — `ok` jest false (zamiast panikować), jeśli asercja się nie powiedzie. **Zawsze preferuj to**, chyba że jesteś pewien typu.

## Przełącznik typu — rozgałęzienie na wiele możliwych typów

```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)` sprawdza typ podstawowy i wiąże `v` (odpowiednio typowany w każdym przypadku). To czysty sposób na obsługę interfejsu, który może zawierać kilka typów.

## Asercja typów interfejsu również

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

## Kiedy ich potrzebujesz

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

## Dlaczego to ważne

Asercje typów i przełączniki typów są niezbędnymi narzędziami do pracy z wartościami interfejsu — odzyskiwania konkretnych informacji o typie z `interface{}`/`any` lub sprawdzenia, czy wartość spełnia określony interfejs.

Są potrzebne podczas obsługi danych o nieznanym lub zmiennym typie (parsowanie dynamicznego JSON, przetwarzanie generyczne, opcjonalne kontrole interfejsu, takie jak "czy to implementuje io.Closer?").

Zrozumienie **rozróżnienia panic-vs-safe** jest krytyczne: zwykła asercja `i.(T)` panikuje w przypadku niezgodności, podczas gdy **forma comma-ok** `v, ok := i.(T)` bezpiecznie raportuje niepowodzenie — użycie bezpiecznej formy jest kluczową praktyką, aby uniknąć awarii czasu wykonywania.

Przełącznik typu elegancko obsługuje wiele możliwych typów.

Znajomość tych (i faktu, że intensywne użycie często sygnalizuje, że zamiast tego powinieneś sięgnąć do generics lub lepszych typowanych wzorów projektowych) jest ważna dla bezpiecznego, idiomatic Go i jest częstym pytaniem na rozmowach kwalifikacyjnych, ponieważ interfejsy i pusty interfejs są tak centralne dla języka.