Metody w Golang: odbiorca wartościowy a wskaźnikowy

Deklarowanie metody

Metoda to funkcja z odbiorcą: dodatkowym parametrem zapisanym przed nazwą metody. Odbiorca wiąże metodę z typem.

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
}

Nazwa odbiorcy to zwykle jedna lub dwie litery wzięte od nazwy typu (c dla Circle). Go nie używa this ani self, a przewodniki stylu odradzają takie nazwy.

Ponieważ Circle ma metodę String() string, spełnia fmt.Stringer, a fmt.Println wypisuje jej wynik zamiast {2}.

Odbiorcy wartościowi i wskaźnikowi

Odbiorca wartościowy (c Circle) dostaje kopię. Odbiorca wskaźnikowy (c *Circle) dostaje adres, więc zmiany pól zostają zachowane.

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 się kompiluje i nie robi nic widocznego, to klasyczny błąd. Jeśli metoda ma zmieniać swojego odbiorcę, potrzebuje odbiorcy wskaźnikowego.

Wywołania pokazują też dwa udogodnienia, które daje Go. c.Inc() na adresowalnej zmiennej zostaje przepisane na (&c).Inc(), a p.Value() na wskaźniku na (*p).Value(). Rzadko piszesz & albo * tylko po to, żeby wywołać metodę.

Automatyczne & wymaga czegoś adresowalnego. Element mapy ani literał złożony takie nie są:

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

Przechowuj w mapie wskaźniki (map[string]*Counter) albo skopiuj wartość, zmień ją i zapisz z powrotem.

Którego odbiorcy wybrać

FAQ Go i biblioteka standardowa trzymają się jednej praktycznej zasady: bądź konsekwentny. Jeśli którakolwiek metoda potrzebuje odbiorcy wskaźnikowego, daj odbiorców wskaźnikowych wszystkim metodom, żeby zbiór metod był przewidywalny. go vet zgłasza strukturę z sync.Mutex, która jest kopiowana przez odbiorcę wartościowego (passes lock by value).

Zbiory metod i interfejsy

To rozróżnienie ma największe znaczenie przy interfejsach. Zbiór metod T zawiera metody z odbiorcą wartościowym. Zbiór metod *T zawiera metody z odbiorcą zarówno wartościowym, jak i wskaźnikowym.

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

Zapisanie w tym slice'ie Square{Side: 3} bez & się nie kompiluje:

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)

Powód: interfejs może przechowywać kopię Square, która nie jest adresowalna, więc Go nie może pobrać jej adresu, żeby wywołać metodę wskaźnikową. Resztę tej historii opisuje strona o interfejsach.

Metody na typach, które nie są strukturami

Metody może mieć każdy typ nazwany zadeklarowany w twoim pakiecie, nie tylko struktura.

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

Ograniczenia: typ musi być zdefiniowany w tym samym pakiecie co metoda, a jego typ bazowy nie może być wskaźnikiem ani interfejsem. Ze swojego pakietu nie dodasz metod do int, string ani time.Time. Opakowanie w nowy typ nazwany to sposób Go. String() na typie całkowitym to także sposób na czytelny wynik dla enumów; zobacz enumy z iota.

Wartości metod i wyrażenia metod

Metoda związana z konkretnym odbiorcą jest wartością funkcyjną:

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

Wartość metody z odbiorcą wartościowym kopiuje odbiorcę w chwili utworzenia, dlatego f nadal mówi Ana. Z odbiorcą wskaźnikowym przechowałaby wskaźnik i widziałaby późniejsze zmiany. Wartości metod przydają się jako callbacki: http.HandleFunc("/", srv.handleIndex).

Częste błędy

• Odbiorca wartościowy w metodzie, która coś zmienia. Kompiluje się i po cichu zmienia kopię.
• Mieszanie rodzajów odbiorców. Nie wiadomo wtedy, czy interfejs spełnia T, czy *T. Wybierz jeden rodzaj dla każdego typu.
• Wywołanie metody wskaźnikowej na wskaźniku nil. Jest dozwolone i metoda wykonuje się z odbiorcą nil. Panika pojawia się dopiero przy dostępie do pola. Niektóre typy (np. lista łączona odporna na nil) korzystają z tego celowo; większość się tego nie spodziewa.