Menene type assertions da type switches?

Question

Accepted Answer

A **type assertion** yana cire kaffin nau'i daga kimar interface, kuma **type switch** yana rarrasa ne bisa ga kaffin nau'in interface. Suna ne hanya da za ku samu kaffin bayanan nau'i daga interface (musamman empty interface / `any`).

## Type assertion — cire kaffin nau'i

```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 `i.(Type)` yana tabbatarwa cewa interface `i` yana riƙe da kimar `Type` kuma yana cicewa. Amma assertion na daidai **yana bugi** — saboda haka yawanci kuna amfani da nau'in saafe na comma-ok.

## Nau'in saafe na 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
}
```

Nau'in alkibari huwa yana ba kimar da boolean — `ok` yana zama jitu (maimakon bugi) idan assertion ta kulli. **Kullun gwammace wannan** sai lokacin da kuka saba da nau'in.

## Type switch — rarrasa ne bisa ga nau'i marasa iyaka

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

Syntax `switch v := i.(type)` yana duba kaffin nau'in kuma yana tattara `v` (nau'i daidai a kowane yalwa). Ita ce hanya masu tsarki don jiyya interface da na iya riƙe nau'i da dama.

## Tabbatarwa ga nau'in interface kuma

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

## Lokacin da kuke buƙatar waɗannan

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

## Dalilin da ya dame

Type assertions da type switches sune kayan aikin mahimmanci don aiki da kimar interface — bubuwa kaffin bayanan nau'i daga `interface{}`/`any` ko dubawa ko kima ta saka wani interface. Yana buƙata lokacin jiyya bayanan nau'i da bai sani ko da bambambanta (bincike JSON mai canjin yanayi, jiyya na gida, gwaji na interface mai ziyarwa kamar "shin wannan yana aiki da io.Closer?").
">Fahim hanyar **bugi-da-saafe** yana da mahimmanci sosai: tabbatarwa mai tsafi `i.(T)` yana bugi akan daidaita, yayin da **nau'in comma-ok** `v, ok := i.(T)` yana tabbatar da kulli a aminci — amfani da nau'in saafe shine hanya mahimmanci don nisantar daruwar aiki. Nau'in switch yana ɗaukar nau'i marasa iyaka cikin tsarki.

Sanin waɗannan (da cewa amfani mai yawa sau da yawa yana nunawa za ku buƙata na aiki da jeneriks ko designs masu kyau-kyau a maimakon) yana da mahimmanci don Go mai aminci, m-da-tsarkaki kuma shine jira gida gida, saboda interfaces da empty interface sune mahimmanci sosai ga harshe.