Kas yra tipo assert ir tipo switch?

Question

Accepted Answer

**Tipo assert** ištraukia konkretų tipą iš sąsajos reikšmės, o **tipo switch** sąsajos pagrindiniam tipui nukreipti šakas. Tai yra būdai atkurti specifinę tipo informaciją iš sąsajos (ypač iš tuščios sąsajos / `any`).

## Tipo assert — ištraukti konkretų tipą

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

Sintaksė `i.(Type)` nurodo, kad sąsaja `i` turi reikšmę `Type` ir ją ištraukia. Tačiau neteisingas assert **panika** — todėl paprastai naudojate saugią kablelio-ok formą.

## Saugi kablelio-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
}
```

Dviejų reikšmių forma grąžina reikšmę ir bule — `ok` yra `false` (vietoj panikos), jei assert nepavyksta. **Visada pirmenybę teikite tai**, jei nesate tikri tipo.

## Tipo switch — šakoti pagal kelis galimus tipus

```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)` patikrina pagrindinį tipą ir sieja `v` (tinkamą tipą kiekvienu atveju). Tai švarus būdas tvarkyti sąsają, kuri gali turėti kelis tipus.

## Taip pat assercijavimas sąsajos tipams

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

## Kada jums to reikia

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

## Kodėl tai svarbu

Tipo assert ir tipo switch yra esminiai sąsajos reikšmių darbo įrankiai — atkuriant konkrečią tipo informaciją iš `interface{}`/`any` arba tikrinant, ar reikšmė atitinka konkrečią sąsają.

Jie reikalingi tvarkant nežinomus arba įvairaus tipo duomenis (dinaminės JSON analizavimas, bendrasis apdorojimas, pasirenkama sąsaja - patikros kaip "ar tai įgyvendina io.Closer?").

Critical suprasti **panika versus saugą distinkcija**: paprastas assert `i.(T)` panika nesutarime, o **kablelio-ok forma** `v, ok := i.(T)` saugiai praneša apie gedimą — naudoti saugią formą yra pagrindinė praktika, norint išvengti runtime katastrofų.

Tipo switch elegantiškai tvarko kelis galimus tipus.

Suvokimas šių (ir to, kad intensyvus jų naudojimas dažnai rodo, kad turėtumėte pasiekti generics arba geriau tipuotus dizainus) yra svarbus saugiam, idiomatiniam Go ir dažna pokalbio tema, nes sąsajos ir tuščia sąsaja yra tokios pagrindinės kalbai.