Apa kuwi type assertions lan type switches?

Question

Accepted Answer

A **type assertion** ngekstrak tipe konkret saka nilai interface, lan **type switch** cabang ing tipe dasar interface. Iki cara ngambali informasi tipe spesifik saka interface (khususé empty interface / `any`).

## Type assertion — ngekstrak tipe 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)
```

Sintaks `i.(Type)` menyatakan yen interface `i` ngemut nilai saka `Type` lan ngekstraknya. Nanging assertion sing salah **panic** — dadi biasane sampeyan nggunakake bentuk comma-ok sing aman.

## Bentuk comma-ok sing aman

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

Bentuk rong-nilai mengembalikan nilai plus boolean — `ok` yaiku false (tinimbang panic) yen assertion gagal. **Luwih seneng ini** kejaba mung yen sampeyan yakin tentang tipenya.

## Type switch — cabang ing nggoleki tipe sing bisa

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

Bentuk `switch v := i.(type)` mriksa tipe dasar lan ngikat `v` (ketik kanthi tepat ing saben kasus). Iki cara sing bersih kanggo nangani interface sing bisa ngemut sawetara tipe.

## Menyatakake tipe interface uga

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

## Nalika sampeyan butuh iki

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

## Mengapa iki penting

Type assertions lan type switches yaiku alat penting kanggo nggarap nilai interface — ngambali informasi tipe konkret saka `interface{}`/`any` utawa mriksa apa-apa nilai ngrengkuh interface tartamtu.

Kuwi dibutuhake nalika nangani data sing ora dikenal utawa beda-beda tipeé (parsing JSON dinamis, pemrosesan generik, pangusapan opsional-interface kayata "apa iki implement io.Closer?").

Paham **pembedaan panic-vs-aman** iku sangat penting: assertion biasa `i.(T)` panic ing ketidakcocokan, dene **bentuk comma-ok** `v, ok := i.(T)` nyatakake gagal kanthi aman — nggunakake bentuk aman yaiku praktek kunci kanggo nyegah padune runtime.

Type switch nangani sawetara tipe sing bisa kanthi elegan.

Mangerti iki (lan yen panggunaan abot asring nandakake sampeyan kudu nggayuh generics utawa desain sing luwih ketik tinimbang) penting kanggo Go sing aman, idiomatis, lan topik interview umum, amarga interfaces lan empty interface kuwi sangat tengah letak ing basa.