Golang Metotlar: Değer ve Pointer Alıcılar

Metot tanımlamak

Metot, alıcısı olan bir fonksiyondur: metot adından önce yazılan ek bir parametre. Alıcı metodu bir tipe bağlar.

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
}

Alıcı adı genellikle tipten alınan bir ya da iki harftir (Circle için c). Go this ya da self kullanmaz ve stil rehberleri bu adları önermez.

Circle'ın bir String() string metodu olduğu için fmt.Stringer'ı karşılar ve fmt.Println, {2} yerine sonucu yazdırır.

Değer alıcılar ve pointer alıcılar

Bir değer alıcı (c Circle) bir kopya alır. Bir pointer alıcı (c *Circle) adresi alır, bu yüzden alanlardaki değişiklikler kalıcı olur.

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 derlenir ve görünür hiçbir şey yapmaz; klasik bir hata. Bir metodun alıcısını değiştirmesi amaçlanıyorsa pointer alıcıya ihtiyacı vardır.

Çağrılar Go'nun sağladığı iki kolaylığı da gösteriyor. Adreslenebilir bir değişken üzerinde c.Inc(), (&c).Inc() olarak yeniden yazılır; bir pointer üzerinde p.Value() ise (*p).Value() olarak yeniden yazılır. Yalnızca bir metodu çağırmak için nadiren & ya da * yazarsınız.

Otomatik & adreslenebilir bir şey ister. Bir map elemanı ya da bir bileşik literal adreslenebilir değildir:

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'te pointer saklayın (map[string]*Counter) ya da değeri dışarı kopyalayın, değiştirin ve geri yazın.

Hangi alıcıyı seçmeli

Go SSS'si ve standart kütüphane tek bir pratik kurala uyar: tutarlı olun. Herhangi bir metot pointer alıcıya ihtiyaç duyuyorsa, metot kümesi öngörülebilir olsun diye tüm metotlara pointer alıcı verin. go vet, bir değer alıcı üzerinden kopyalanan ve sync.Mutex tutan bir struct'ı işaretler (passes lock by value).

Metot kümeleri ve interface'ler

Bu ayrım en çok interface'ler için önemlidir. T'nin metot kümesi değer alıcılı metotları içerir. *T'nin metot kümesi hem değer hem de pointer alıcılı metotları içerir.

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

O slice'ta & olmadan Square{Side: 3} yazmak derlenmez:

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)

Nedeni: bir interface, adreslenebilir olmayan bir Square kopyası tutabilir, bu yüzden Go bir pointer metodunu çağırmak için onun adresini alamaz. Hikâyenin geri kalanı için interface'ler sayfasına bakın.

Struct olmayan tiplerde metotlar

Yalnızca struct'lar değil, paketinizde tanımlanan her adlandırılmış tipin metotları olabilir.

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

Sınırlar: tip metotla aynı pakette tanımlanmış olmalıdır ve temel tipi bir pointer ya da interface olamaz. Kendi paketinizden int, string ya da time.Time'a metot ekleyemezsiniz. Go'daki yol, yeni bir adlandırılmış tipe sarmaktır. Bir tam sayı tipi üzerindeki String(), enum'ların okunabilir çıktı almasının da yoludur; bkz. iota ile enum'lar.

Metot değerleri ve metot ifadeleri

Belirli bir alıcıya bağlanmış bir metot bir fonksiyon değeridir:

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

Değer alıcılı bir metot değeri, oluşturulduğu anda alıcıyı kopyalar; f'nin hâlâ Ana demesinin nedeni budur. Pointer alıcıyla pointer'ı saklar ve sonraki değişiklikleri görürdü. Metot değerleri callback'ler için kullanışlıdır: http.HandleFunc("/", srv.handleIndex).

Sık yapılan hatalar

• Değiştiren bir metotta değer alıcı. Derlenir, sessizce bir kopyayı değiştirir.
• Alıcı türlerini karıştırmak. Bir interface'i T'nin mi yoksa *T'nin mi karşıladığını belirsiz yapar. Her tip için birini seçin.
• Nil bir pointer üzerinde pointer metodu çağırmak. İzinlidir ve metot nil bir alıcıyla çalışır. Yalnızca bir alana dokunduğunda panic olur. Bazı tipler (nil güvenli bir bağlı liste gibi) bunu bilerek kullanır; çoğu ise beklemez.