Bagaimanakah interface berfungsi dalam Go?

Question

Accepted Answer

Sebuah **interface** Go mentakrifkan satu set tandatangan kaedah — satu kontrak tingkah laku. Yang penting, interface dipenuhi secara **tersirat**: mana-mana jenis yang mempunyai kaedah tersebut secara automatik memenuhi interface itu, **tanpa pengisytiharan "implements" eksplisit**. Pendekatan struktural, duck-typing ini tersendiri dan berkuasa.

## Mentakrif dan melaksanakan interface secara tersirat

```go
// define an interface — a set of method signatures
type Speaker interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "Woof" }   // Dog has Speak() → it IS a Speaker

type Cat struct{}
func (c Cat) Speak() string { return "Meow" }   // Cat too — implicitly

// NO "implements Speaker" anywhere — satisfaction is automatic
var s Speaker = Dog{}    // works because Dog has the Speak() method
s.Speak()                // "Woof"
```

Tiada kata kunci `implements` — jika sesuatu jenis mempunyai semua kaedah interface, ia memenuhi interface itu secara automatik. Ini memisahkan interface daripada pelaksanaannya (pelaksana tidak perlu pun tahu interface itu wujud).

## Polimorfisme melalui interface

```go
func announce(s Speaker) {        // accepts ANY type that has Speak()
    fmt.Println(s.Speak())
}
announce(Dog{})    // "Woof"
announce(Cat{})    // "Meow"

speakers := []Speaker{Dog{}, Cat{}}   // a slice of different types via the interface
for _, sp := range speakers { sp.Speak() }
```

Interface membolehkan polimorfisme — tulis kod terhadap tingkah laku, dan mana-mana jenis yang mematuhinya akan berfungsi.

## Interface kosong dan `any`

```go
var x interface{}     // the empty interface — satisfied by EVERY type (no methods required)
x = 42
x = "hello"
// Go 1.18+: `any` is an alias for interface{}
func print(v any) { fmt.Println(v) }   // accepts anything
```

Interface kosong (`interface{}` / `any`) memegang sebarang nilai — digunakan apabila jenisnya tidak diketahui terlebih dahulu (walaupun generics kini sering menggantikannya).

## Interface standard library yang akan anda guna sentiasa

```go
type Stringer interface { String() string }   // controls fmt printing
type error interface { Error() string }        // the error type itself!
type io.Reader interface { Read(p []byte) (n int, err error) }
type io.Writer interface { Write(p []byte) (n int, err error) }
```

Sebahagian besar standard library dibina di atas interface kecil (`io.Reader`/`io.Writer`, `error`, `Stringer`) — melaksanakannya menjadikan jenis anda berfungsi dengan seluruh ekosistem.

## Simpulan bahasa: terima interface, pulangkan struct

```text
Go favors SMALL interfaces (often one method) defined where they're USED (the consumer),
not where types are defined. "The bigger the interface, the weaker the abstraction."
```

## Mengapa ia penting

Interface adalah teras reka bentuk Go serta pendekatannya terhadap abstraksi dan polimorfisme — dan **pemenuhan tersiratnya** (tiada kata kunci `implements`; penaipan struktural) ialah salah satu ciri paling tersendiri dan berkuasa dalam bahasa ini.

Pemisahan ini bermakna jenis dan interface berkembang secara bebas, anda boleh mentakrifkan interface *selepas* jenis yang memenuhinya, dan mana-mana jenis yang mematuhi akan terpasang ke dalam kod berasaskan interface secara automatik — membolehkan reka bentuk yang fleksibel, gandingan longgar, serta ujian yang mudah (gantikan dengan pelaksanaan mock).

Memahami pelaksanaan tersirat, polimorfisme melalui interface, interface kosong/`any`, simpulan bahasa interface kecil ("terima interface, pulangkan struct"), dan interface standard library yang lazim (`error`, `io.Reader`/`Writer`, `Stringer`) adalah penting untuk Go yang idiomatik.

Ia topik temu duga yang kerap justeru kerana model tersirat dan struktural ini berbeza secara asas daripada interface eksplisit dalam Java/C#.

Mentakrif dan melaksanakan interface secara tersirat

Polimorfisme melalui interface

Interface kosong dan any

Interface standard library yang akan anda guna sentiasa

Simpulan bahasa: terima interface, pulangkan struct

Mengapa ia penting

Interface kosong dan `any`