Apa itu type assertions dan type switches?

Question

Accepted Answer

Sebuah **type assertion** mengekstrak tipe konkret dari nilai interface, dan sebuah **type switch** membuat percabangan berdasarkan tipe yang mendasari interface. Mereka adalah cara Anda memulihkan informasi tipe spesifik dari interface (terutama empty interface / `any`).

## Type assertion — ekstrak 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 bahwa interface `i` menyimpan nilai dari `Type` dan mengekstraknya. Tetapi assertion yang salah **panic** — jadi biasanya Anda menggunakan bentuk comma-ok yang aman.

## Bentuk comma-ok yang 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 dua-nilai mengembalikan nilai plus boolean — `ok` adalah false (bukannya panic) jika assertion gagal. **Selalu gunakan ini** kecuali Anda yakin dengan tipenya.

## Type switch — percabangan pada beberapa kemungkinan tipe

```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)` memeriksa tipe yang mendasari dan mengikat `v` (diketik dengan tepat di setiap case). Ini adalah cara yang bersih untuk menangani interface yang dapat menyimpan beberapa tipe.

## Menyatakan tipe interface juga

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

## Saat Anda membutuhkan ini

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

Type assertions dan type switches adalah alat penting untuk bekerja dengan nilai interface — memulihkan informasi tipe konkret dari `interface{}`/`any` atau memeriksa apakah nilai memenuhi interface tertentu.

Mereka diperlukan saat menangani data dengan tipe yang tidak diketahui atau bervariasi (parsing JSON dinamis, pemrosesan generik, pemeriksaan interface opsional seperti "apakah ini mengimplementasikan io.Closer?").

Memahami **perbedaan panic-vs-safe** sangat penting: assertion biasa `i.(T)` panic saat tidak cocok, sementara **bentuk comma-ok** `v, ok := i.(T)` dengan aman melaporkan kegagalan — menggunakan bentuk aman adalah praktik kunci untuk menghindari crash runtime.

Type switch dengan elegan menangani beberapa kemungkinan tipe.

Mengetahui ini (dan bahwa penggunaan berat sering menandakan Anda sebaiknya menggunakan generics atau desain yang lebih tipe-aman) penting untuk Go yang aman dan idiomatis serta topik interview yang umum, karena interfaces dan empty interface sangat sentral dalam bahasa ini.