Koja je razlika između value i pointer receiver-a?

Question

Accepted Answer

**Receiver** metode je vrijednost na kojoj radi, deklarirana prije imena metode. Može biti **value receiver** (radi na kopiji) ili **pointer receiver** (radi na originalnom, može ga modificirati). Ispravnog izbora je važna za ispravnost (mutacija) i performanse.

## Value receiver — radi na KOPIJI

```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 dobija kopiju strukture, tako da izmjene ne utječu na original — korisno za metode samo za čitanje, ali greška ako ste namjeravali mutirati.

## Pointer receiver — radi na ORIGINALNOM

```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 radi na stvarnoj strukturi, tako da može **modificirati** je. Go automatski uzima adresu (`c.Increment()` radi čak i na vrijednosti).

## Kada koristiti što

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

## Pravilo konzistentnosti

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

Mješoviti value i pointer receiver-i na jednom tipu uzrokuju suptilne probleme — konvencija je odabrati jedan (obično pointer ako bilo koja metoda mutira) i koristiti ga za sve metode.

## Subtilnost zadovoljavanja sučelja

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

Ovo je česta greška: s pointer-receiver metodama, samo pointer tip zadovoljava sučelje.

## Zašto je to važno

Odabir value-vs-pointer receiver je fundamentalna, često pogrešno razumljena Go odluka koja utječe na ispravnost, performanse i zadovoljavanje sučelja.

Najčešća greška je korištenje **value receiver-a kada ste namjeravali mutirati** — izmjena tiho utječe samo na kopiju, tako da se promjena "ne primijeni". Pointer receiver-i su obavezni za mutaciju i preporučeni za velike strukture (kako bi se izbjegla skupna kopiranja na svakom pozivu).

**Pravilo konzistentnosti** (korištenje istog tipa receiver-a kroz sve metode tipa) izbjegava zbunjenje, a **subtilnost zadovoljavanja sučelja** (pointer-receiver metode znače da samo pointer tip zadovoljava sučelje) je klasična greška koja uzrokuje greške "does not implement interface".

Razumijevanje ovoga je bitno za pisanje ispravnog, učinkovitog Go-a i među je najčešćim praktičnim i interview temama, jer odabir ima neočite posljedice.