A metódus vevője az az érték, amelyen működik, a metódus neve előtt deklarálva. Lehet értékvevő (egy másolaton működik) vagy mutatóvevő (az eredetín működik, módosítható). A helyes választás a helyességre (mutáció) és a teljesítményre is hatással van.
Counter { count }
Increment() {
c.count++
}
c := Counter{}
c.Increment()
fmt.Println(c.count)
Az értékvevő a struct egy másolatát kapja meg, így a módosítások nem érintik az eredeti értéket — hasznos csak olvasási metódusoknál, de hiba, ha mutációra szántad.
func (c *Counter) Increment() { // POINTER receiver — c points to the original
c.count++ // modifies the ACTUAL struct
}
c := Counter{}
c.Increment() // Go automatically takes &c
fmt.Println(c.count) // 1 — the original WAS modified
A mutatóvevő az atual structon működik, így módosíthatja azt. A Go automatikusan veszi a címet (c.Increment() működik még egy értéken is).
Use a POINTER receiver when:
✓ The method needs to MODIFY the receiver (mutation)
✓ The struct is LARGE (avoid copying it on every call — performance)
✓ For CONSISTENCY (see below)
Use a VALUE receiver when:
✓ The method only READS, the type is small, and you want copy semantics
✓ The type is naturally a value (small structs, basic types)
// ✅ be consistent — if ANY method needs a pointer receiver, use pointer for ALL
func (c *Counter) Increment() { c.count++ }
func (c *Counter) Value() int { return c.count } // pointer too, for consistency
Az érték- és mutatóvevők keverése egy típuson finom hibákat okoz — a konvenció az, hogy az egyiket válaszd (általában mutatót, ha valamelyik metódus mutálja), és azt használd minden metódusban.
type Incrementer interface { Increment() }
// if Increment has a POINTER receiver, only *Counter satisfies the interface, not Counter
var i Incrementer = &Counter{} // ✅ works
var j Incrementer = Counter{} // ❌ Counter (value) does NOT satisfy it
Ez egy gyakori hiba: mutatóvevő metódusoknál csak a mutatótípus elégíti ki az interfészt.
Az érték- vs mutatóvevő választás egy alapvető, gyakran félreértett Go döntés, amely a helyességre, a teljesítményre és az interface-teljesítésre hatással van.
A leggyakoribb hiba az értékvevő használata, amikor mutációra szántad — a módosítás halkan csak a másolaton hat, így a módosítás "nem ragad meg". Mutatóvevők szükségesek a mutációhoz, és nagyobb structokhoz ajánlottak (hogy elkerüljük az drága másolatokat minden híváskor).
Az egységességi szabály (ugyanazt a vevőtípust használd egy típus összes metódusában) kerüli a zavarokat, és az interface-teljesítés árnyalatossága (mutatóvevő metódusoknál csak a mutatótípus elégíti ki az interfészt) egy klasszikus hiba, amely "does not implement interface" hibákat okoz.
Ezek megértése lényeges a helyes és hatékony Go írásához, és az egyik leggyakoribb gyakorlati és interjú témák közé tartozik, mivel a választásnak nem nyilvánvaló következményei vannak.