Mi a típusafirmáció és a típusváltás?

Question

Accepted Answer

A **típusafirmáció** (type assertion) kibontja a konkrét típust egy interfész értékből, és a **típusváltás** (type switch) egy interfész alapjául szolgáló típusa alapján ágazik el. Ezek a módok, ahogyan konkrét típusinformációkat lehet helyreállítani egy interfészből (különösen az üres interfészből / `any`).

## Típusafirmáció — konkrét típus kibontása

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

Az `i.(Type)` szintaxis azt állítja, hogy az `i` interfész egy `Type` típusú értéket tartalmaz, és kibontja azt. De a hibás afirmáció **panikot okoz** — ezért általában a biztonságos comma-ok formát használják.

## A biztonságos comma-ok forma

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

A kétértékű forma visszaadja az értéket és egy logikai értéket — az `ok` hamis (a panika helyett), ha az afirmáció meghiúsul. **Mindig ezt válassza**, kivéve ha biztos a típusban.

## Típusváltás — több lehetséges típus alapján ágazik

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

A `switch v := i.(type)` forma az alapjául szolgáló típust ellenőrzi és `v`-t köti (megfelelően tipizálva minden esetben). Ez a tiszta módszer egy olyan interfész kezelésére, amely több típust is tárolhat.

## Interfészmetípusok afirmációja is

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

## Ha szükség van ezekre

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

## Miért fontos

A típusafirmáció és a típusváltás elengedhetetlen eszközök az interfészértékekkel való munkához — konkrét típusinformációk helyreállítása az `interface{}`/`any` értékekből vagy annak ellenőrzése, hogy egy érték egy adott interfészt valósít-e meg.

Szükségesek az ismeretlen vagy eltérő típusú adatok kezelésekor (dinamikus JSON elemzése, általános feldolgozás, opcionális interfész-ellenőrzések, például "implementálja-e ez az io.Closer-t?").

A **panika vs. biztonságos forma megkülönböztetésének** megértése kritikus: az egyszerű afirmáció `i.(T)` panikot okoz eltéréskor, míg a **comma-ok forma** `v, ok := i.(T)` biztonságosan jelenti a kudarcot — a biztonságos forma használata kulcsfontosságú a futásidejű összeomlások elkerüléséhez.

A típusváltás elegánsan kezel több lehetséges típust.

Ezek ismerete (és az, hogy a túlzott használat gyakran azt jelzi, hogy generikusakra vagy jól tipizált tervekre kellene támaszkodnia) fontos a biztonságos, idiomatikus Go-hoz, valamint egy gyakori interjúkérdéshez, mivel az interfészek és az üres interfész olyan központiak a nyelvben.