מתודות ב-Golang: value receiver מול pointer receiver

הצהרה על מתודה

מתודה היא פונקציה עם receiver: פרמטר נוסף שנכתב לפני שם המתודה. ה-receiver קושר את המתודה לטיפוס.

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
}

שם ה-receiver הוא בדרך כלל אות אחת או שתיים מתוך שם הטיפוס (c בשביל Circle). ב-Go לא משתמשים ב-this או ב-self, ומדריכי הסגנון ממליצים להימנע מהשמות האלה.

מכיוון שלטיפוס Circle יש מתודה String() string, הוא מממש את fmt.Stringer, ו-fmt.Println מדפיסה את התוצאה במקום {2}.

value receivers ו-pointer receivers

value receiver (c Circle) מקבל עותק. pointer receiver (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 מתקמפלת ולא עושה שום דבר שאפשר לראות, באג קלאסי. אם מתודה אמורה לשנות את ה-receiver שלה, היא צריכה pointer receiver.

הקריאות מראות גם את שתי הנוחויות ש-Go נותנת לכם. c.Inc() על משתנה שיש לו כתובת נכתב מחדש כ-(&c).Inc(), ו-p.Value() על pointer נכתב מחדש כ-(*p).Value(). כמעט אף פעם לא כותבים & או * רק כדי לקרוא למתודה.

ה-& האוטומטי צריך משהו שיש לו כתובת. לאיבר של map או לליטרל מורכב אין:

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

שמרו pointers ב-map (map[string]*Counter), או העתיקו את הערך החוצה, שנו אותו וכתבו אותו בחזרה.

איזה receiver לבחור

ה-FAQ של Go והספרייה הסטנדרטית פועלים לפי כלל אצבע אחד: היו עקביים. אם מתודה כלשהי צריכה pointer receiver, תנו לכל המתודות pointer receivers, כך שה-method set יהיה צפוי. go vet מסמן struct שמחזיק sync.Mutex ומועתק דרך value receiver (passes lock by value).

method sets ו-interfaces

ההבחנה חשובה במיוחד ל-interfaces. ה-method set של T מכיל את המתודות עם value receiver. ה-method set של *T מכיל גם את המתודות עם value receiver וגם את אלה עם pointer receiver.

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} בלי ה-& ב-slice הזה לא מתקמפלת:

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)

הסיבה: interface יכול להחזיק עותק של Square שאין לו כתובת, ולכן Go לא יכולה לקחת את הכתובת שלו כדי לקרוא למתודה עם pointer. ראו את העמוד על interfaces להמשך הסיפור.

מתודות על טיפוסים שהם לא structs

לכל טיפוס בעל שם שהוצהר בחבילה שלכם יכולות להיות מתודות, לא רק ל-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))
}

המגבלות: הטיפוס חייב להיות מוגדר באותה חבילה כמו המתודה, והטיפוס הבסיסי שלו לא יכול להיות pointer או interface. אי אפשר להוסיף מתודות ל-int, ל-string או ל-time.Time מהחבילה שלכם. עטיפה בטיפוס חדש בעל שם היא הדרך של Go. String() על טיפוס של מספר שלם הוא גם הדרך שבה enums מקבלים פלט קריא; ראו enums עם iota.

method values ו-method expressions

מתודה שקשורה ל-receiver מסוים היא ערך של פונקציה:

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

method value עם value receiver מעתיק את ה-receiver כשהוא נוצר, ולכן f עדיין אומרת Ana. עם pointer receiver הוא היה שומר את ה-pointer ורואה שינויים מאוחרים יותר. method values נוחים ל-callbacks: http.HandleFunc("/", srv.handleIndex).

טעויות נפוצות

• value receiver על מתודה שמשנה. מתקמפל, ומשנה בשקט עותק.
• ערבוב של סוגי receivers. כך לא ברור אם T או *T מממש interface. בחרו סוג אחד לכל טיפוס.
• קריאה למתודה עם pointer receiver על pointer שהוא nil. מותר, והמתודה רצה עם receiver שהוא nil. היא נכנסת ל-panic רק כשהיא נוגעת בשדה. חלק מהטיפוסים (כמו רשימה מקושרת שבטוחה ל-nil) משתמשים בזה בכוונה; רובם לא מצפים לזה.