Çfarë janë type assertions dhe type switches?

Question

Accepted Answer

Një **type assertion** nxjerr tipin konkret nga një vlerë interface-i, dhe një **type switch** degëzohet në bazë të tipit themelor të një interface-i. Ato janë mënyra se si rikuperoni informacionin specifik të tipit nga një interface (veçanërisht empty interface-i / `any`).

## Type assertion — nxjerrje e një tipi konkret

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

Sintaksa `i.(Type)` pohon se interface-i `i` mban një vlerë të `Type` dhe e nxjerr atë. Por një pohim i gabuar **panikohet** — kështu që zakonisht përdorni formën e sigurt comma-ok.

## Forma e sigurt 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 me dy vlera kthen vlerën plus një boolean — `ok` është false (në vend që të panikon) nëse pohimi dështon. **Gjithmonë preferoni këtë** përveç nëse jeni të sigurt për tipin.

## Type switch — degëzim në shumë tipe të mundshme

```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)` kontrollon tipin themelor dhe lidh `v` (i tipizuar në mënyrë të përshtatshme në çdo rast). Është mënyra e pastër për të trajtuar një interface-i që mund të mbajë disa tipe.

## Pohimi i tipeve interface gjithashtu

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

## Kur ju duhen këto

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

## Pse ka rëndësi

Type assertions dhe type switches janë mjete thelbësore për punën me vlerat e interface-it — rikuperimi i informacionit të tipit konkret nga `interface{}`/`any` ose kontrollimi nëse një vlerë plotëson një interface-i të caktuar.

Ato janë të nevojshme kur trajtoni të dhëna me tipe të panjohura ose të ndryshme (analizimi i JSON-it dinamik, përpunimi gjenerik, kontrollime të interface-it fakultativ si "a zbaton ky io.Closer?").

Kuptimi i **dallimit panic-vs-safe** është kritik: një pohim i thjeshtë `i.(T)` panikohet në mospërputhje, ndërsa **forma comma-ok** `v, ok := i.(T)` raporton me siguri dështimin — përdorimi i formës së sigurt është një praktikë kyçe për të shmangur rrëzime gjatë ekzekutimit.

Type switch-i trajtë me elegancë shumë tipe të mundshme.

Tja njohja këtyre (dhe se përdorimi i dendur shpesh sinjalizon që duhet të arrini për generics ose dizajne më të tipizuara) është e rëndësishme për Go-në e sigurt, idiomatike dhe një temë e zakonshme në intervista, pasi interface-et dhe empty interface-i janë aq qendror për gjuhën.