Apakah perbezaan antara penerima nilai dan penerima penunjuk?

Question

Accepted Answer

**Penerima** sesuatu kaedah ialah nilai yang ia kendalikan, diisytiharkan sebelum nama kaedah. Ia boleh menjadi **penerima nilai** (beroperasi pada salinan) atau **penerima penunjuk** (beroperasi pada asal, boleh mengubahnya). Memilih dengan betul penting untuk ketepatan (mutasi) dan prestasi.

## Penerima nilai — beroperasi pada SALINAN

```go
type Counter struct { count int }

func (c Counter) Increment() {     // VALUE receiver — c is a COPY
    c.count++                       // modifies the copy, NOT the original
}

c := Counter{}
c.Increment()
fmt.Println(c.count)   // 0 — the original is UNCHANGED (the copy was modified)
```

Penerima nilai mendapat salinan struktur, jadi pengubahan tidak menjejaskan asal — berguna untuk kaedah baca sahaja, tetapi bug jika anda bermaksud mengubah.

## Penerima penunjuk — beroperasi pada ASAL

```go
func (c *Counter) Increment() {    // POINTER receiver — c points to the original
    c.count++                       // modifies the ACTUAL struct
}

c := Counter{}
c.Increment()          // Go automatically takes &c
fmt.Println(c.count)   // 1 — the original WAS modified
```

Penerima penunjuk beroperasi pada struktur sebenar, jadi ia boleh **mengubah** ia. Go secara automatik mengambil alamat (`c.Increment()` berfungsi bahkan pada nilai).

## Bila menggunakan mana

```text
Use a POINTER receiver when:
  ✓ The method needs to MODIFY the receiver (mutation)
  ✓ The struct is LARGE (avoid copying it on every call — performance)
  ✓ For CONSISTENCY (see below)

Use a VALUE receiver when:
  ✓ The method only READS, the type is small, and you want copy semantics
  ✓ The type is naturally a value (small structs, basic types)
```

## Peraturan konsistensi

```go
// ✅ be consistent — if ANY method needs a pointer receiver, use pointer for ALL
func (c *Counter) Increment() { c.count++ }
func (c *Counter) Value() int { return c.count }   // pointer too, for consistency
```

Mencampurkan penerima nilai dan penunjuk pada satu jenis menyebabkan masalah halus — konvensyen ialah memilih satu (biasanya penunjuk jika kaedah apa pun mengubah) dan menggunakannya untuk semua kaedah.

## Kehalusan kepuasan antarmuka

```go
type Incrementer interface { Increment() }

// if Increment has a POINTER receiver, only *Counter satisfies the interface, not Counter
var i Incrementer = &Counter{}   // ✅ works
var j Incrementer = Counter{}    // ❌ Counter (value) does NOT satisfy it
```

Ini adalah perangkap biasa: dengan kaedah penerima penunjuk, hanya jenis penunjuk yang memenuhi antarmuka.

## Mengapa penting

Pilihan penerima nilai-vs-penunjuk ialah keputusan Go yang fundamental, sering kali disalahfahami, yang menjejaskan ketepatan, prestasi, dan kepuasan antarmuka.

Bug paling biasa ialah menggunakan **penerima nilai apabila anda bermaksud mengubah** — pengubahan diam-diam menjejaskan hanya salinan, jadi perubahan "tidak kekal". Penerima penunjuk diperlukan untuk mutasi dan disyorkan untuk struktur besar (untuk mengelakkan salinan mahal pada setiap panggilan).

**Peraturan konsistensi** (gunakan jenis penerima yang sama di semua kaedah jenis) mengelakkan kekeliruan, dan **kehalusan kepuasan antarmuka** (kaedah penerima penunjuk bermakna hanya jenis penunjuk memenuhi antarmuka) ialah perangkap klasik yang menyebabkan ralat "does not implement interface".

Memahami perkara-perkara ini adalah penting untuk menulis Go yang betul dan cekap serta merupakan antara topik praktikal dan temu duga yang paling biasa, kerana pilihan mempunyai akibat yang tidak jelas.