Was ist der Unterschied zwischen Value- und Pointer-Receivern?

Question

Accepted Answer

Ein **Receiver** einer Methode ist der Wert, auf dem sie operiert, deklariert vor dem Methodennamen. Er kann ein **Value Receiver** (operiert auf einer Kopie) oder ein **Pointer Receiver** (operiert auf dem Original, kann es verändern) sein. Die richtige Wahl ist sowohl für Korrektheit (Mutation) als auch für Performance wichtig.

## Value Receiver – operiert auf einer KOPIE

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

Ein Value Receiver erhält eine Kopie der Struktur, daher beeinflussen Änderungen das Original nicht – nützlich für schreibgeschützte Methoden, aber ein Bug, wenn du eine Mutation beabsichtigt hast.

## Pointer Receiver – operiert auf dem ORIGINAL

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

Ein Pointer Receiver operiert auf der eigentlichen Struktur und kann sie daher **verändern**. Go nimmt die Adresse automatisch (`c.Increment()` funktioniert auch auf einem Wert).

## Wann welcher zu verwenden ist

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

## Die Konsistenzregel

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

Value und Pointer Receiver auf einem Typ zu mischen verursacht subtile Probleme – Konvention ist, sich für eines zu entscheiden (normalerweise Pointer, wenn eine Methode mutiert) und es für alle Methoden zu verwenden.

## Interface-Erfüllungs-Subtilität

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

Das ist eine häufige Falle: Bei Pointer-Receiver-Methoden erfüllt nur der Pointer-Typ das Interface.

## Warum es wichtig ist

Die Wahl zwischen Value und Pointer Receiver ist eine fundamentale, häufig missverstandene Go-Entscheidung, die Korrektheit, Performance und Interface-Erfüllung beeinflusst.

Der häufigste Bug ist die Verwendung eines **Value Receiver, wenn du eine Mutation beabsichtigt hast** – die Änderung beeinflusst stillschweigend nur eine Kopie, daher "bleibt" die Änderung nicht. Pointer Receiver sind für Mutation erforderlich und empfohlen für große Strukturen (um teure Kopien bei jedem Aufruf zu vermeiden).

Die **Konsistenzregel** (verwende denselben Receiver-Typ über alle Methoden eines Typs) vermeidet Verwirrung, und die **Interface-Erfüllungs-Subtilität** (Pointer-Receiver-Methoden bedeuten, dass nur der Pointer-Typ das Interface erfüllt) ist eine klassische Falle, die "does not implement interface"-Fehler verursacht.

Das Verständnis dieser Konzepte ist essentiell, um korrektes und effizientes Go zu schreiben, und gehört zu den häufigsten praktischen und Interview-Themen, da die Wahl nicht offensichtliche Konsequenzen hat.