Métodos en Golang: receptores por valor y por puntero

Declarar un método

Un método es una función con receptor: un parámetro extra escrito antes del nombre del método. El receptor ata el método 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
}

El nombre del receptor suele ser una o dos letras tomadas del tipo (c para Circle). Go no usa this ni self, y las guías de estilo desaconsejan esos nombres.

Como Circle tiene un método String() string, cumple fmt.Stringer, y fmt.Println imprime su resultado en lugar de {2}.

Receptores por valor y por puntero

Un receptor por valor (c Circle) recibe una copia. Un receptor puntero (c *Circle) recibe la dirección, así que los cambios en los campos se mantienen.

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 y no hace nada visible, un bug clásico. Si un método debe modificar su receptor, necesita un receptor puntero.

Las llamadas también muestran las dos comodidades que te da Go. c.Inc() sobre una variable direccionable se reescribe como (&c).Inc(), y p.Value() sobre un puntero se reescribe como (*p).Value(). Rara vez escribes & o * solo para llamar a un método.

El & automático necesita algo direccionable. Un elemento de un map o un literal compuesto no lo son:

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

Guarda punteros en el map (map[string]*Counter) o saca el valor, cámbialo y vuelve a guardarlo.

Qué receptor elegir

Las FAQ de Go y la librería estándar siguen una regla práctica: sé coherente. Si algún método necesita un receptor puntero, dale receptor puntero a todos, para que el conjunto de métodos sea predecible. go vet marca un struct que contiene un sync.Mutex y se copia a través de un receptor por valor (passes lock by value).

Conjuntos de métodos e interfaces

La distinción importa sobre todo con las interfaces. El conjunto de métodos de T contiene los métodos con receptor por valor. El conjunto de métodos de *T contiene los métodos con receptor por valor y los de receptor puntero.

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

Escribir Square{Side: 3} sin el & en ese slice no 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)

El motivo: una interfaz puede contener una copia de un Square que no es direccionable, así que Go no puede tomar su dirección para llamar a un método de puntero. Consulta interfaces para el resto de la historia.

Métodos sobre tipos que no son structs

Cualquier tipo con nombre declarado en tu paquete puede tener métodos, no solo los 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))
}

Los límites: el tipo tiene que estar definido en el mismo paquete que el método, y su tipo subyacente no puede ser un puntero ni una interfaz. No puedes añadir métodos a int, string ni time.Time desde tu propio paquete. Envolverlos en un tipo con nombre nuevo es la forma de hacerlo en Go. String() sobre un tipo entero es también la manera de dar a los enums una salida legible; consulta enums con iota.

Method values y method expressions

Un método ligado a un receptor concreto es un valor función:

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 receptor por valor copia el receptor al crearse, y por eso f sigue diciendo Ana. Con un receptor puntero guardaría el puntero y vería los cambios posteriores. Los method values vienen bien para los callbacks: http.HandleFunc("/", srv.handleIndex).

Errores comunes

• Receptor por valor en un método que modifica. Compila y cambia en silencio una copia.
• Mezclar tipos de receptor. Deja poco claro si es T o *T quien cumple una interfaz. Elige uno por tipo.
• Llamar a un método de puntero sobre un puntero nil. Está permitido, y el método se ejecuta con un receptor nil. Solo provoca un panic cuando toca un campo. Algunos tipos (como una lista enlazada segura ante nil) lo usan a propósito; la mayoría no lo espera.