Hvad er forskellen mellem value og pointer receivers?

Question

Accepted Answer

En metodes **receiver** er den værdi, den opererer på, deklareret før metodens navn. Det kan være en **value receiver** (opererer på en kopi) eller en **pointer receiver** (opererer på originalen, kan modificere den). Det er vigtigt at vælge rigtigt både for korrekthed (mutation) og performance.

## Value receiver — opererer på en KOPI

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

En value receiver får en kopi af strukturen, så modifikationer påvirker ikke originalen — brugbart til read-only metoder, men en fejl hvis du mente at mutere.

## Pointer receiver — opererer på ORIGINALEN

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

En pointer receiver opererer på den faktiske struktur, så den kan **modificere** den. Go tager automatisk adressen (`c.Increment()` virker selv på en værdi).

## Hvornår skal man bruge hvilken

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

## Konsistensreglen

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

At blande value og pointer receivers på én type forårsager subtile problemer — konventionen er at vælge én (normalt pointer hvis nogen metode muterer) og bruge den til alle metoder.

## Interface satisfaction subtilitet

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

Dette er en almindelig gotcha: med pointer-receiver metoder opfylder kun pointer-typen interfacet.

## Hvorfor det betyder noget

Valgt mellem value og pointer receiver er en fundamental, ofte misforstået Go-beslutning, der påvirker korrekthed, performance og interface satisfaction.

Den mest almindelige fejl er at bruge en **value receiver når du mente at mutere** — modifikationen påvirker stille og roligt kun en kopi, så ændringen "holder ikke fast." Pointer receivers er påkrævede til mutation og anbefales til store strukturer (for at undgå dyre kopier ved hvert kald).

**Konsistensreglen** (brug den samme receiver-type på tværs af en types metoder) undgår forvirring, og **interface-satisfaction subtiliteten** (pointer-receiver metoder betyder at kun pointer-typen opfylder interfacet) er en klassisk gotcha, der forårsager "does not implement interface"-fejl.

At forstå disse er væsentligt for at skrive korrekt, effektiv Go og er blandt de mest almindelige praktiske og interviewemner, da valget har ikke-åbenlyse konsekvenser.