Apa perbedaan antara value receiver dan pointer receiver?

Question

Accepted Answer

**Receiver** sebuah method adalah nilai yang dioperasikannya, dideklarasikan sebelum nama method. Receiver dapat berupa **value receiver** (mengoperasikan salinan) atau **pointer receiver** (mengoperasikan yang asli, dapat memodifikasinya). Memilih dengan benar penting untuk kebenaran (mutasi) dan performa.

## Value receiver — mengoperasikan 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)
```

Value receiver mendapatkan salinan struct, jadi modifikasi tidak mempengaruhi yang asli — berguna untuk method read-only, tetapi bug jika Anda bermaksud melakukan mutasi.

## Pointer receiver — mengoperasikan yang ASLI

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

Pointer receiver mengoperasikan struct yang sebenarnya, jadi dapat **memodifikasinya**. Go secara otomatis mengambil alamatnya (`c.Increment()` bekerja bahkan pada value).

## Kapan 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)
```

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

Mencampur value dan pointer receiver pada satu tipe menyebabkan masalah halus — konvensinya adalah memilih salah satu (biasanya pointer jika ada method yang melakukan mutasi) dan menggunakannya untuk semua method.

## Subtilitas kepuasan interface

```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 gotcha umum: dengan method pointer-receiver, hanya tipe pointer yang memuaskan interface.

## Mengapa ini penting

Pilihan value-vs-pointer receiver adalah keputusan Go fundamental yang sering disalahpahami dan memengaruhi kebenaran, performa, dan kepuasan interface.

Bug paling umum adalah menggunakan **value receiver ketika Anda bermaksud melakukan mutasi** — modifikasi diam-diam hanya mempengaruhi salinan, jadi perubahan "tidak tertanam". Pointer receiver diperlukan untuk mutasi dan direkomendasikan untuk struct besar (untuk menghindari salinan mahal pada setiap pemanggilan).

**Aturan konsistensi** (gunakan tipe receiver yang sama di seluruh method tipe) menghindari kebingungan, dan **subtilitas kepuasan interface** (method pointer-receiver berarti hanya tipe pointer yang memuaskan interface) adalah gotcha klasik yang menyebabkan error "does not implement interface".

Memahami hal-hal ini sangat penting untuk menulis Go yang benar dan efisien, dan merupakan salah satu topik praktis dan interview paling umum, karena pilihan memiliki konsekuensi yang tidak jelas.