Vad är skillnaden mellan value och pointer receivers?

Question

Accepted Answer

En metods **receiver** är det värde den arbetar på, deklarerad före metodnamnet. Det kan vara en **value receiver** (arbetar på en kopia) eller en **pointer receiver** (arbetar på originalet, kan modifiera det). Att välja rätt spelar roll för både korrekthet (mutation) och prestanda.

## Value receiver — arbetar på en KOPIA

```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 kopia av struken, så modifieringar påverkar inte originalet — användbart för read-only-metoder, men ett fel om du avsåg att mutera.

## Pointer receiver — arbetar på ORIGINALET

```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 arbetar på den faktiska struken, så den kan **modifiera** den. Go tar automatiskt adressen (`c.Increment()` fungerar även på ett värde).

## När ska man använda vilken

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

## Konsistensregeln

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

Att blanda value och pointer receivers på en typ orsakar subtila problem — konventionen är att välja en (vanligtvis pointer om någon metod muterar) och använda den för alla 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
```

Detta är ett vanligt gotcha: med pointer-receiver-metoder uppfyller endast pointer-typen interfacet.

## Varför det spelar roll

Valet av value kontra pointer receiver är ett fundamentalt, ofta missförstådd Go-beslut som påverkar korrekthet, prestanda och interface-uppfyllelse.

Den vanligaste buggen är att använda en **value receiver när du avsåg att mutera** — modifieringen påverkar bara en kopia, så ändringen "fastnar inte". Pointer receivers krävs för mutation och rekommenderas för stora struker (för att undvika dyra kopior vid varje anrop).

**Konsistensregeln** (använd samma receiver-typ över en typs metoder) undviker förvirring, och **interface-satisfaction-subtiliteten** (pointer-receiver-metoder betyder att endast pointer-typen uppfyller interfacet) är ett klassiskt gotcha som orsakar "does not implement interface"-fel.

Att förstå dessa är väsentligt för att skriva korrekt, effektiv Go och är bland de vanligaste praktiska och intervju-ämnena, eftersom valet har icke-uppenbara konsekvenser.