Apa bedane antara value receiver lan pointer receiver?

Question

Accepted Answer

**Receiver** saka metode yaiku nilai sing dioperasi, dideklarasi sadurunge jeneng metode. Bisa dadi **value receiver** (operasi ing salinan) utawa **pointer receiver** (operasi ing asline, bisa diowahi). Milih kanthi bener penting kanggo kabenaran (mutasi) lan performance.

## Value receiver — operasi ing 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 entuk salinan saka struct, dadi perubahan ora kanggo asline — migunani kanggo metode mung baca, nanging bug yen sampeyan niat ganti.

## Pointer receiver — operasi ing ASLINE

```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 operasi ing struct nyata, dadi bisa **ganti** iku. Go otomatis njupuk alamat (`c.Increment()` gumana sanajan ing nilai).

## Kapan nggunakake sing 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
```

Campur value receiver lan pointer receiver ing tipe siji nyebabake masalah samar — konvensi yaiku pilih siji (biasane pointer yenpun metode ganti) lan gunakake kanggo kabeh metode.

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

Iki gotcha umum: karo metode pointer-receiver, mung tipe pointer sing tumutuwa interface.

## Ngapa penting

Pilihan value-vs-pointer receiver yaiku keputusan Go fundamental, asring salah paham, sing kanggo kabenaran, performance, lan kepuasan interface.

Bug paling umum yaiku nggunakake **value receiver nalika sampeyan niat ganti** — perubahan senyap-senyap kanggo salinan, dadi owahan "ora melekat". Pointer receiver perlu kanggo mutasi lan cocok kanggo struct besar (cegah salinan mahal ing saben panggilan).

**Aturan konsistensi** (gunakake tipe receiver sama ing kabeh metode saka tipe) cegah kebingunan, lan **subtlety kepuasan interface** (metode pointer-receiver tegese mung tipe pointer sing tumutuwa interface) yaiku gotcha klasik sing nyebabake "does not implement interface" errors.

Paham iki penting kanggo nulis Go bener lan efisien lan minangka topik praktis lan interview paling umum, amarga pilihan duwe konsekuensi ora jelas.