Hva er forskjellen mellom value og pointer receivers?

Question

Accepted Answer

En metodes **receiver** er verdien den opererer på, deklarert før metodens navn. Det kan være en **value receiver** (opererer på en kopi) eller en **pointer receiver** (opererer på originalen, kan modifisere den). Valget er viktig både for korrekthet (mutasjon) og ytelse.

## 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 av strukturen, så endringer påvirker ikke originalen — nyttig for lesemetoder, men en feil hvis du hadde tenkt å 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 strukturen, så den kan **modifisere** den. Go tar automatisk adressen (`c.Increment()` fungerer selv på en verdi).

## Når du skal bruke 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)
```

## Konsistensregelen

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

Blanding av value og pointer receivers på en type forårsaker subtile problemer — konvensjonen er å velge en (vanligvis pointer hvis noen metode muterer) og bruke den for alle metoder.

## Interface-satisfaksjon 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 vanlig gotcha: med pointer-receiver-metoder tilfredsstiller kun pointer-typen interfacet.

## Hvorfor det betyr noe

Valget mellom value og pointer receiver er en grunnleggende, ofte misforstått Go-beslutning som påvirker korrekthet, ytelse og interface-satisfaksjon.

Den vanligste feilen er å bruke en **value receiver når du hadde tenkt å mutere** — modifikasjonen påvirker stilltiende bare en kopi, så endringen "stikker ikke fast." Pointer receivers er påkrevd for mutasjon og anbefalt for store strukturer (for å unngå dyre kopier ved hvert kall).

**Konsistensregelen** (bruk samme receiver-type på tvers av en types metoder) unngår forvirring, og **subtiliteten med interface-satisfaksjon** (pointer-receiver-metoder betyr at bare pointer-typen tilfredsstiller interfacet) er en klassisk gotcha som forårsaker "does not implement interface"-feil.

Å forstå disse er essensielt for å skrive korrekt, effektiv Go og er blant de mest vanlige praktiske og intervju-emnene, siden valget har ikke-åpenbare konsekvenser.