Kakšna je razlika med prejemniki vrednosti in prejemniki kazalcev?

Question

Accepted Answer

**Prejemnik** metode je vrednost, na katero deluje, deklariran pred imenom metode. Lahko je **prejemnik vrednosti** (deluje na kopiji) ali **prejemnik kazalca** (deluje na originalu, lahko ga spremeni). Pravilna izbira je pomembna za pravilnost (mutacija) in učinkovitost.

## Prejemnik vrednosti — deluje 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)
```

Prejemnik vrednosti dobi kopijo strukture, zato spremembe ne vplivajo na original — koristno za metode samo za branje, vendar je napaka, če ste nameravali mutirati.

## Prejemnik kazalca — deluje na ORIGINALU

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

Prejemnik kazalca deluje na dejansko strukturo, zato jo lahko **spremeni**. Go samodejno vzame naslov (`c.Increment()` deluje tudi na vrednosti).

## Kdaj uporabiti kaj

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

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

Mešanje prejemnikov vrednosti in kazalcev na enem tipu povzroča subtilne probleme — konvencija je izbrati enega (običajno kazalec, če katera koli metoda mutira) in ga uporabiti za vse metode.

## Subtilnost izpolnjevanja vmesnika

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

To je pogosta pasti: s prejemniki kazalca samo tip kazalca izpolnjuje vmesnik.

## Zakaj je to pomembno

Izbira prejemnika vrednosti ali kazalca je temeljno in pogosto nepravilno razumljeno odločitev v Go-u, ki vpliva na pravilnost, učinkovitost in izpolnjevanje vmesnikov.

Najpogostejša napaka je uporaba **prejemnika vrednosti, ko ste nameravali mutirati** — sprememba tiho vpliva samo na kopijo, zato sprememba "ne ostane". Prejemniki kazalca so obvezni za mutacijo in priporočeni za velike strukture (da se izognete dragim kopijam pri vsakem klicu).

**Pravilo skladnosti** (uporabljajte isto vrsto prejemnika v vseh metodah tipa) se izogne zmedi, in **subtilnost izpolnjevanja vmesnika** (prejemniki kazalca pomenijo, da samo tip kazalca izpolnjuje vmesnik) je klasična pasti, ki povzroča napake "ne implementira vmesnika".

Razumevanje tega je nujno za pisanje pravilnega in učinkovitega Go-ja in je med najpogostejšimi praktičnimi in intervjuskimi temami, saj ima izbira neočitne posledice.