Méthodes en Golang : receveur valeur ou receveur pointeur

Déclarer une méthode

Une méthode est une fonction avec un receveur : un paramètre supplémentaire écrit avant le nom de la méthode. Le receveur rattache la méthode à un type.

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
}

Le nom du receveur est généralement une ou deux lettres tirées du type (c pour Circle). Go n'utilise pas this ni self, et les guides de style déconseillent ces noms.

Comme Circle a une méthode String() string, il satisfait fmt.Stringer, et fmt.Println affiche le résultat au lieu de {2}.

Receveurs valeur et receveurs pointeur

Un receveur valeur (c Circle) reçoit une copie. Un receveur pointeur (c *Circle) reçoit l'adresse, donc les modifications des champs sont conservées.

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 compile et ne fait rien de visible, un bug classique. Si une méthode doit modifier son receveur, il lui faut un receveur pointeur.

Les appels montrent aussi les deux commodités que Go vous offre. c.Inc() sur une variable adressable est réécrit en (&c).Inc(), et p.Value() sur un pointeur est réécrit en (*p).Value(). Vous écrivez rarement & ou * juste pour appeler une méthode.

Le & automatique a besoin de quelque chose d'adressable. Un élément de map ou un littéral composite ne l'est pas :

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

Stockez des pointeurs dans la map (map[string]*Counter) ou copiez la valeur, modifiez-la et réécrivez-la.

Quel receveur choisir

La FAQ de Go et la bibliothèque standard suivent une règle simple : soyez cohérent. Si une méthode a besoin d'un receveur pointeur, donnez des receveurs pointeurs à toutes les méthodes, pour que l'ensemble de méthodes soit prévisible. go vet signale une struct contenant un sync.Mutex qui est copiée via un receveur valeur (passes lock by value).

Ensembles de méthodes et interfaces

La distinction compte surtout pour les interfaces. L'ensemble de méthodes de T contient les méthodes à receveur valeur. L'ensemble de méthodes de *T contient les méthodes à receveur valeur et à receveur pointeur.

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())
	}
}

Écrire Square{Side: 3} sans le & dans cette slice ne compile pas :

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)

La raison : une interface peut contenir une copie d'un Square qui n'est pas adressable, donc Go ne peut pas prendre son adresse pour appeler une méthode à receveur pointeur. Voir les interfaces pour la suite de l'histoire.

Méthodes sur des types qui ne sont pas des structs

Tout type nommé déclaré dans votre package peut avoir des méthodes, pas seulement les 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))
}

Les limites : le type doit être défini dans le même package que la méthode, et son type sous-jacent ne peut pas être un pointeur ou une interface. Vous ne pouvez pas ajouter de méthodes à int, string ou time.Time depuis votre propre package. Envelopper dans un nouveau type nommé est la façon de faire en Go. String() sur un type entier est aussi la façon dont les enums obtiennent un affichage lisible ; voir les enums avec iota.

Method values et method expressions

Une méthode liée à un receveur précis est une valeur fonction :

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"))
}

Une method value avec un receveur valeur copie le receveur au moment de sa création, c'est pourquoi f dit toujours Ana. Avec un receveur pointeur, elle stockerait le pointeur et verrait les modifications ultérieures. Les method values sont pratiques pour les callbacks : http.HandleFunc("/", srv.handleIndex).

Erreurs courantes

• Un receveur valeur sur une méthode qui modifie. Ça compile, et ça modifie une copie sans bruit.
• Mélanger les sortes de receveurs. On ne sait plus si c'est T ou *T qui satisfait une interface. Choisissez-en une par type.
• Appeler une méthode à receveur pointeur sur un pointeur nil. C'est permis, et la méthode s'exécute avec un receveur nil. Elle ne provoque un panic que lorsqu'elle touche un champ. Certains types (comme une liste chaînée tolérante au nil) l'exploitent exprès ; la plupart ne s'y attendent pas.