Jaký je rozdíl mezi value a pointer receivers?

Question

Accepted Answer

Metody mají **receiver** — hodnotu, na které operují, deklarovanou před jménem metody. Může jít o **value receiver** (operuje na kopii) nebo **pointer receiver** (operuje na originálu, může ho modifikovat). Správná volba záleží na korektnosti (mutace) i výkonu.

## Value receiver — operuje na KOPII

```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 dostane kopii struktury, takže modifikace neovlivní originál — užitečné pro read-only metody, ale chyba, pokud jste zamýšleli mutaci.

## Pointer receiver — operuje na ORIGINÁLU

```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 operuje na skutečné struktuře, takže ji může **modifikovat**. Go automaticky vezme adresu (`c.Increment()` funguje i na hodnotu).

## Kdy který použít

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

## Pravidlo konzistence

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

Mísení value a pointer receivers u jednoho typu způsobuje jemné problémy — konvencí je vybrat si jeden (obvykle pointer, pokud nějaká metoda mutuje) a používat ho pro všechny metody.

## Jemnost satisfakce interfaců

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

Toto je běžná chyba: s pointer-receiver metodami pouze typ pointeru splňuje interface.

## Proč na tom záleží

Volba value vs. pointer receiver je základní, často nesprávně pochopené rozhodnutí v Go, které ovlivňuje korektnost, výkon a satisfakci interfaců.

Nejčastější chybou je použití **value receiveru, když jste zamýšleli mutaci** — modifikace tiše ovlivní pouze kopii, takže se změna "neuchytí". Pointer receivery jsou vyžadovány pro mutaci a doporučovány pro velké struktury (aby se zabránilo drahým kopiím při každém volání).

**Pravidlo konzistence** (používejte stejný receiver type across všech metod typu) vyhýbá se zmatení, a **jemnost satisfakce interfaců** (pointer-receiver metody znamenají, že pouze typ pointeru splňuje interface) je klasická chyba, která způsobuje chyby "does not implement interface".

Porozumění těmto konceptům je podstatné pro psaní správného a efektivního Go a patří mezi nejčastější praktická a interview témata, protože volba má neočividné důsledky.