Metodi in Golang: receiver valore e receiver puntatore spiegati

Dichiarare un metodo

Un metodo è una funzione con un receiver: un parametro in più scritto prima del nome del metodo. Il receiver lega il metodo a un tipo.

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
}

Il nome del receiver di solito è una o due lettere prese dal tipo (c per Circle). Go non usa this o self, e le guide di stile sconsigliano quei nomi.

Siccome Circle ha un metodo String() string, soddisfa fmt.Stringer, e fmt.Println stampa il risultato invece di {2}.

Receiver valore e receiver puntatore

Un receiver valore (c Circle) riceve una copia. Un receiver puntatore (c *Circle) riceve l'indirizzo, quindi le modifiche ai campi restano.

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 compila e non fa niente di visibile, un bug classico. Se un metodo deve modificare il suo receiver, ha bisogno di un receiver puntatore.

Le chiamate mostrano anche le due comodità che ti offre Go. c.Inc() su una variabile indirizzabile viene riscritto come (&c).Inc(), e p.Value() su un puntatore viene riscritto come (*p).Value(). Raramente scrivi & o * solo per chiamare un metodo.

La & automatica richiede qualcosa di indirizzabile. Un elemento di una map o un letterale composito non lo sono:

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

Memorizza puntatori nella map (map[string]*Counter) oppure copia fuori il valore, modificalo e riscrivilo.

Quale receiver scegliere

Le FAQ di Go e la libreria standard seguono una regola pratica: sii coerente. Se un qualsiasi metodo ha bisogno di un receiver puntatore, dai a tutti i metodi un receiver puntatore, così il method set è prevedibile. go vet segnala una struct che contiene un sync.Mutex e viene copiata attraverso un receiver valore (passes lock by value).

Method set e interface

La distinzione conta soprattutto per le interface. Il method set di T contiene i metodi con receiver valore. Il method set di *T contiene sia i metodi con receiver valore sia quelli con receiver puntatore.

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

Scrivere Square{Side: 3} senza la & in quella slice non compila:

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)

Il motivo: un'interface può contenere una copia di uno Square che non è indirizzabile, quindi Go non può prenderne l'indirizzo per chiamare un metodo con receiver puntatore. Vedi interface per il resto della storia.

Metodi su tipi che non sono struct

Qualsiasi tipo con nome dichiarato nel tuo package può avere metodi, non solo le struct.

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

I limiti: il tipo deve essere definito nello stesso package del metodo, e il suo tipo sottostante non può essere un puntatore o un'interface. Non puoi aggiungere metodi a int, string o time.Time dal tuo package. Avvolgerli in un nuovo tipo con nome è il modo Go. String() su un tipo intero è anche il modo in cui gli enum ottengono un output leggibile; vedi enum con iota.

Method value e method expression

Un metodo legato a un receiver specifico è un valore funzione:

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

Un method value con receiver valore copia il receiver quando viene creato, ed è per questo che f dice ancora Ana. Con un receiver puntatore memorizzerebbe il puntatore e vedrebbe le modifiche successive. I method value sono comodi per le callback: http.HandleFunc("/", srv.handleIndex).

Errori comuni

• Receiver valore su un metodo che modifica. Compila, e modifica una copia senza avvisi.
• Mescolare i tipi di receiver. Rende poco chiaro se sia T o *T a soddisfare un'interface. Scegline uno per tipo.
• Chiamare un metodo con receiver puntatore su un puntatore nil. È permesso, e il metodo gira con un receiver nil. Va in panic solo quando tocca un campo. Alcuni tipi (come una linked list che gestisce il nil) lo sfruttano di proposito; la maggior parte non se lo aspetta.