Методы в Golang: получатель-значение и получатель-указатель

Объявление метода

Метод это функция с получателем: дополнительным параметром, который пишется перед именем метода. Получатель привязывает метод к типу.

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
}

Имя получателя обычно состоит из одной-двух букв, взятых из имени типа (c для Circle). Go не использует this или self, и руководства по стилю не советуют такие имена.

Поскольку у Circle есть метод String() string, он удовлетворяет fmt.Stringer, и fmt.Println печатает результат этого метода вместо {2}.

Получатель-значение и получатель-указатель

Получатель-значение (c Circle) получает копию. Получатель-указатель (c *Circle) получает адрес, поэтому изменения полей сохраняются.

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 компилируется и не делает ничего заметного: классический баг. Если метод должен менять получатель, ему нужен получатель-указатель.

Вызовы также показывают два удобства Go. c.Inc() на адресуемой переменной переписывается в (&c).Inc(), а p.Value() на указателе переписывается в (*p).Value(). Писать & или * только ради вызова метода приходится редко.

Автоматическому & нужно что-то адресуемое. Элемент мапы или составной литерал таковыми не являются:

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

Храните в мапе указатели (map[string]*Counter) или скопируйте значение, измените его и запишите обратно.

Какой получатель выбрать

Go FAQ и стандартная библиотека следуют одному практическому правилу: единообразие. Если хоть одному методу нужен получатель-указатель, дайте указатели всем методам, чтобы набор методов был предсказуемым. go vet отмечает структуру с sync.Mutex, которая копируется через получатель-значение (passes lock by value).

Наборы методов и интерфейсы

Сильнее всего разница проявляется в интерфейсах. Набор методов T содержит методы с получателем-значением. Набор методов *T содержит методы и с получателем-значением, и с получателем-указателем.

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

Если убрать & перед Square{Side: 3} в этом слайсе, код не скомпилируется:

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)

Причина: интерфейс может хранить копию Square, которая не адресуема, поэтому Go не может взять её адрес, чтобы вызвать метод указателя. Продолжение этой истории на странице об интерфейсах.

Методы на типах, которые не являются структурами

Методы могут быть у любого именованного типа, объявленного в вашем пакете, а не только у структур.

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

Ограничения: тип должен быть определён в том же пакете, что и метод, а его базовый тип не может быть указателем или интерфейсом. Добавить методы к int, string или time.Time из своего пакета нельзя. Путь Go: обернуть в новый именованный тип. String() на целочисленном типе также даёт перечислениям читаемый вывод; см. перечисления через iota.

Значения методов и выражения методов

Метод, привязанный к конкретному получателю, это функциональное значение:

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

Значение метода с получателем-значением копирует получатель в момент создания, поэтому f по-прежнему говорит Ana. С получателем-указателем сохранился бы указатель, и последующие изменения были бы видны. Значения методов удобны для колбэков: http.HandleFunc("/", srv.handleIndex).

Частые ошибки

• Получатель-значение у метода, который должен менять состояние. Компилируется и молча меняет копию.
• Смешение видов получателей. Становится неясно, что удовлетворяет интерфейсу, T или *T. Выберите один вариант для типа.
• Вызов метода указателя на nil-указателе. Это разрешено, и метод выполняется с nil-получателем. Паника возникает, только когда он обращается к полю. Некоторые типы (например, nil-безопасный связный список) используют это намеренно; большинство такого не ожидают.