Golang Methoden: Value Receiver vs Pointer Receiver erklärt

Eine Methode deklarieren

Eine Methode ist eine Funktion mit einem Receiver: einem zusätzlichen Parameter vor dem Methodennamen. Der Receiver bindet die Methode an einen Typ.

package main

import (
	"fmt"
	"math"
)

type Circle struct {
	Radius float64
}

func (c Circle) Area() float64 {
	return math.Pi * c.Radius * c.Radius
}

func (c Circle) String() string {
	return fmt.Sprintf("Circle(r=%.1f)", c.Radius)
}

func main() {
	c := Circle{Radius: 2}
	fmt.Printf("%.2f\n", c.Area())
	fmt.Println(c) // uses the String method
}

Der Receiver-Name besteht meist aus ein oder zwei Buchstaben des Typs (c für Circle). Go verwendet kein this oder self, und Styleguides raten von diesen Namen ab.

Da Circle eine Methode String() string hat, erfüllt es fmt.Stringer, und fmt.Println gibt deren Ergebnis statt {2} aus.

Value Receiver und Pointer Receiver

Ein Value Receiver (c Circle) bekommt eine Kopie. Ein Pointer Receiver (c *Circle) bekommt die Adresse, also bleiben Änderungen an Feldern erhalten.

package main

import "fmt"

type Counter struct {
	n int
}

func (c Counter) IncByValue() {
	c.n++ // changes the copy only
}

func (c *Counter) Inc() {
	c.n++
}

func (c Counter) Value() int {
	return c.n
}

func main() {
	var c Counter
	c.IncByValue()
	fmt.Println(c.Value()) // 0

	c.Inc() // Go takes &c automatically
	c.Inc()
	fmt.Println(c.Value()) // 2

	p := &c
	fmt.Println(p.Value()) // Go dereferences p automatically
}

IncByValue kompiliert und bewirkt nichts Sichtbares, ein klassischer Bug. Soll eine Methode ihren Receiver ändern, braucht sie einen Pointer Receiver.

Die Aufrufe zeigen auch die beiden Erleichterungen, die Go dir bietet. c.Inc() auf einer adressierbaren Variablen wird zu (&c).Inc() umgeschrieben, und p.Value() auf einem Pointer zu (*p).Value(). Du schreibst also selten & oder *, nur um eine Methode aufzurufen.

Das automatische & braucht etwas Adressierbares. Ein Map-Element oder ein Composite Literal ist das nicht:

m := map[string]Counter{"a": {}}
m["a"].Inc()    // compile error: cannot call pointer method Inc on Counter
Counter{}.Inc() // same error: a composite literal is not addressable

Speichere Pointer in der Map (map[string]*Counter) oder kopier den Wert heraus, änder ihn und schreib ihn zurück.

Welchen Receiver wählen

Die Go-FAQ und die Standardbibliothek folgen einer Faustregel: Sei einheitlich. Braucht eine Methode einen Pointer Receiver, gib allen Methoden Pointer Receiver, damit das Method Set vorhersehbar ist. go vet meldet ein Struct mit einem sync.Mutex, das über einen Value Receiver kopiert wird (passes lock by value).

Method Sets und Interfaces

Am wichtigsten ist der Unterschied bei Interfaces. Das Method Set von T enthält die Methoden mit Value Receiver. Das Method Set von *T enthält die Methoden mit Value Receiver und die mit Pointer Receiver.

package main

import "fmt"

type Shape interface {
	Area() float64
}

type Square struct{ Side float64 }

func (s *Square) Area() float64 { return s.Side * s.Side }

type Rect struct{ W, H float64 }

func (r Rect) Area() float64 { return r.W * r.H }

func main() {
	shapes := []Shape{
		&Square{Side: 3},  // *Square has Area
		Rect{W: 2, H: 5},  // Rect has Area
		&Rect{W: 1, H: 1}, // *Rect has it too
	}
	for _, s := range shapes {
		fmt.Printf("%T %.0f\n", s, s.Area())
	}
}

Schreibst du in diesem Slice Square{Side: 3} ohne das &, kompiliert es nicht:

cannot use Square{…} (value of struct type Square) as Shape value in array or slice literal: Square does not implement Shape (method Area has pointer receiver)

Der Grund: Ein Interface kann eine nicht adressierbare Kopie eines Square enthalten, also kann Go nicht deren Adresse nehmen, um eine Pointer-Methode aufzurufen. Den Rest der Geschichte erzählt die Seite zu Interfaces.

Methoden auf Typen, die keine Structs sind

Jeder benannte Typ, der in deinem Paket deklariert ist, kann Methoden haben, nicht nur Structs.

package main

import (
	"fmt"
	"strings"
)

type Celsius float64

func (c Celsius) Fahrenheit() float64 {
	return float64(c)*9/5 + 32
}

type Tags []string

func (t Tags) String() string {
	return "#" + strings.Join(t, " #")
}

type Status int

func (s Status) String() string {
	switch s {
	case 0:
		return "pending"
	case 1:
		return "done"
	}
	return fmt.Sprintf("Status(%d)", int(s))
}

func main() {
	fmt.Println(Celsius(100).Fahrenheit())
	fmt.Println(Tags{"go", "backend"})
	fmt.Println(Status(1), Status(7))
}

Die Grenzen: Der Typ muss im selben Paket definiert sein wie die Methode, und sein zugrunde liegender Typ darf kein Pointer und kein Interface sein. Aus deinem eigenen Paket kannst du int, string oder time.Time keine Methoden hinzufügen. In Go verpackst du den Typ stattdessen in einen neuen benannten Typ. String() auf einem Ganzzahltyp ist auch der Weg, wie Enums eine lesbare Ausgabe bekommen; siehe Enums mit iota.

Method Values und Method Expressions

Eine Methode, die an einen bestimmten Receiver gebunden ist, ist ein Funktionswert:

package main

import "fmt"

type Greeter struct{ Name string }

func (g Greeter) Hello(to string) string {
	return g.Name + " says hi to " + to
}

func main() {
	g := Greeter{Name: "Ana"}

	f := g.Hello // method value: receiver bound now
	g.Name = "Bob"
	fmt.Println(f("Cy")) // still Ana: the receiver was copied

	h := Greeter.Hello // method expression: receiver becomes the first parameter
	fmt.Println(h(g, "Dee"))
}

Ein Method Value mit Value Receiver kopiert den Receiver beim Erzeugen, deshalb sagt f immer noch Ana. Mit Pointer Receiver würde er den Pointer speichern und spätere Änderungen sehen. Method Values sind praktisch für Callbacks: http.HandleFunc("/", srv.handleIndex).

Häufige Fehler

• Value Receiver bei einer ändernden Methode. Kompiliert und ändert still eine Kopie.
• Receiver-Arten mischen. Dann ist unklar, ob T oder *T ein Interface erfüllt. Entscheide dich pro Typ für eine Art.
• Eine Pointer-Methode auf einem nil-Pointer aufrufen. Erlaubt, und die Methode läuft mit einem nil-Receiver. Eine Panic gibt es erst, wenn sie auf ein Feld zugreift. Manche Typen (etwa eine nil-sichere verkettete Liste) nutzen das absichtlich; die meisten rechnen nicht damit.