Ni nini type assertions na type switches?

Question

Accepted Answer

**Type assertion** huchimba concrete type kutoka kwa thamani ya interface, na **type switch** hutawi kulingana na underlying type ya interface. Ndio jinsi unavyorejesha taarifa za type mahususi kutoka kwa interface (hasa empty interface / `any`).

## Type assertion — chimba concrete 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)
```

Syntax ya `i.(Type)` huthibitisha kwamba interface `i` inashikilia thamani ya `Type` na kuichimba. Lakini assertion isiyo sahihi **inapanic** — kwa hivyo kawaida unatumia safe comma-ok form.

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

Fomu ya thamani-mbili hurejesha thamani pamoja na boolean — `ok` ni false (badala ya kupanic) ikiwa assertion itashindwa. **Daima pendelea hii** isipokuwa una uhakika wa type.

## Type switch — tawi kulingana na types kadhaa zinazowezekana

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

Fomu ya `switch v := i.(type)` hukagua underlying type na kufunga `v` (yenye type ifaayo katika kila case). Ni njia safi ya kushughulikia interface inayoweza kushikilia types kadhaa.

## Kuthibitisha interface types pia

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

## Ni lini unahitaji hizi

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

## Kwa nini ni muhimu

Type assertions na type switches ni zana muhimu za kufanya kazi na thamani za interface — kurejesha taarifa za concrete type kutoka kwa `interface{}`/`any` au kukagua kama thamani inatosheleza interface fulani.

Zinahitajika wakati wa kushughulikia data ya type isiyojulikana au tofauti (kuchanganua dynamic JSON, usindikaji wa generic, ukaguzi wa optional-interface kama "je, hii inatekeleza io.Closer?").

Kuelewa **tofauti ya panic-dhidi-ya-safe** ni muhimu: assertion ya kawaida `i.(T)` hupanic kwa kutolingana, wakati **comma-ok form** `v, ok := i.(T)` huripoti kushindwa kwa usalama — kutumia safe form ni desturi muhimu ya kuepuka runtime crashes.

Type switch hushughulikia kwa ustadi types kadhaa zinazowezekana.

Kujua hizi (na kwamba matumizi makubwa mara nyingi huashiria kwamba unapaswa kufikia generics au miundo yenye type bora badala yake) ni muhimu kwa Go salama, ya kiidiomatiki na ni mada ya kawaida ya mahojiano, kwa kuwa interfaces na empty interface ni za msingi sana katika lugha.