Apakah penegasan jenis (type assertion) dan suis jenis (type switch)?

Question

Accepted Answer

Sebuah **penegasan jenis** (type assertion) mengekstrak jenis konkrit daripada nilai interface, dan sebuah **suis jenis** (type switch) bercabang berdasarkan jenis asas sesuatu interface. Inilah cara anda mendapatkan semula maklumat jenis tertentu daripada interface (terutamanya interface kosong / `any`).

## Penegasan jenis — ekstrak jenis konkrit

```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)` menegaskan bahawa interface `i` memegang nilai bagi `Type` dan mengekstraknya. Tetapi penegasan yang salah akan **panic** — jadi biasanya anda menggunakan bentuk comma-ok yang selamat.

## Bentuk comma-ok yang selamat

```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 memulangkan nilai serta satu boolean — `ok` adalah false (bukannya panic) jika penegasan gagal. **Sentiasa utamakan ini** melainkan anda pasti tentang jenisnya.

## Suis jenis — bercabang pada pelbagai jenis yang mungkin

```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)` menyemak jenis asas dan mengikat `v` (ditaip dengan sesuai dalam setiap kes). Ia cara yang kemas untuk mengendalikan interface yang mungkin memegang beberapa jenis.

## Menegaskan jenis 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
}
```

## Bila anda memerlukannya

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

Penegasan jenis dan suis jenis ialah alat penting untuk bekerja dengan nilai interface — mendapatkan semula maklumat jenis konkrit daripada `interface{}`/`any` atau menyemak sama ada sesuatu nilai memenuhi interface tertentu.

Ia diperlukan apabila mengendalikan data yang jenisnya tidak diketahui atau pelbagai (menghurai JSON dinamik, pemprosesan generik, semakan interface pilihan seperti "adakah ini melaksanakan io.Closer?").

Memahami **perbezaan panic lawan selamat** adalah kritikal: penegasan biasa `i.(T)` panic apabila tidak sepadan, manakala **bentuk comma-ok** `v, ok := i.(T)` melaporkan kegagalan dengan selamat — menggunakan bentuk yang selamat ialah amalan utama untuk mengelakkan kemalangan masa jalan.

Suis jenis mengendalikan pelbagai jenis yang mungkin dengan elegan.

Mengetahui ini (dan bahawa penggunaan berat sering menandakan anda patut beralih kepada generics atau reka bentuk bertaip lebih baik) adalah penting untuk Go yang selamat dan idiomatik serta topik temu duga yang biasa, kerana interface dan interface kosong begitu teras dalam bahasa ini.