value మరియు pointer receivers మధ్య తేడా ఏమిటి?

Question

Accepted Answer

ఒక method యొక్క **receiver** అనేది అది పనిచేసే విలువ, method పేరు ముందు ప్రకటించబడుతుంది. ఇది **value receiver** (కాపీపై పనిచేస్తుంది) లేదా **pointer receiver** (అసలు విషయంపై పనిచేస్తుంది, దానిని సవరించగలదు) కావచ్చు. సరిగ్గా ఎంచుకోవడం సరిదనం (mutation) మరియు performance రెండింటికీ ముఖ్యమైనది.

## Value receiver — కాపీపై పనిచేస్తుంది

```go
type Counter struct { count int }

func (c Counter) Increment() {     // VALUE receiver — c is a COPY
    c.count++                       // modifies the copy, NOT the original
}

c := Counter{}
c.Increment()
fmt.Println(c.count)   // 0 — the original is UNCHANGED (the copy was modified)
```

ఒక value receiver స్ట్రక్ట్ యొక్క కాపీని పొందుతుంది, కాబట్టి సవరణలు అసలు విషయానికి ప్రభావం చేయవు — read-only methods కోసం ఉపయోగకరమైనది, కానీ మీరు mutate చేయాలని ఉద్దేశించినట్లయితే ఇది బగ్.

## Pointer receiver — అసలు విషయంపై పనిచేస్తుంది

```go
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
```

ఒక pointer receiver వాస్తవ struct పై పనిచేస్తుంది, కాబట్టి దానిని **సవరించగలదు**. Go స్వయంచాలకంగా address ను తీసుకుంటుంది (`c.Increment()` విలువపై కూడా కుడా పని చేస్తుంది).

## ఎక్కడ ఉపయోగించాలి

```text
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)
```

## Consistency నియమం

```go
// ✅ 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
```

ఒక type పై value మరియు pointer receivers ను మిక్స్ చేయడం సూక్ష్మమైన సమస్యలను కలిగిస్తుంది — సమావేశం ఏదో ఒకటి (సాధారణంగా pointer ఎంచుకోవడం ఏదైనా method mutate చేస్తే) ఎంచుకోవడం మరియు దానిని అన్ని methods కోసం ఉపయోగించడం.

## Interface satisfaction సూక్ష్మత

```go
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
```

ఇది సాధారణ ఆపద: pointer-receiver methods తో, వేరు pointer type మాత్రమే interface ని సంతృప్తిపరుస్తుంది.

## ఇది ఎందుకు ముఖ్యమైనది

Value-vs-pointer receiver ఎంపిక ఒక ప్రాథమిక, తరచుగా తప్పుగా అర్థం చేసుకున్న Go నిర్ణయం, ఇది సరిదనం, performance మరియు interface satisfaction ను ప్రభావితం చేస్తుంది.

సర్వసాధారణ బగ్ ఏమిటంటే **మీరు mutate చేయాలని ఉద్దేశించినప్పుడు value receiver ని ఉపయోగించడం** — సవరణ నిశ్శబ్దంగా కాపీపై మాత్రమే ప్రభావం చేస్తుంది, కాబట్టి మార్పు "stick చేయదు." Pointer receivers mutation కోసం అవసరమైనవి మరియు పెద్ద structs కోసం సిఫార్సు చేయబడ్డాయి (ప్రతి call లో ఖరీదైన కాపీలను నివారించడానికి).

**Consistency నియమం** (type యొక్క సभी methods పై ఒకే receiver type ని ఉపయోగించడం) గందరగోళాన్ని నివారిస్తుంది, మరియు **interface-satisfaction సూక్ష్మత** (pointer-receiver methods అంటే వేరు pointer type మాత్రమే interface ని సంతృప్తిపరుస్తుంది) "does not implement interface" errors లను కలిగిస్తున్న క్లాసిక్ ఆపద.

ఇవాటిని అర్థం చేసుకోవడం సరిగ్గా, సమర్థవంతమైన Go రాయడానికి అవసరమైనది మరియు సర్వసాధారణ ఆచరణాత్మక మరియు interview విషయాల్లో ఉంటుంది, ఎందుకంటే ఎంపిక స్పష్టం కాని పరిణామాలను కలిగి ఉంటుంది.