મૂલ્ય અને પોઇન્ટર રીસીવર વચ્ચે શું તફાવત છે?

Question

Accepted Answer

એક મેથડનું **રીસીવર** એ મૂલ્ય છે જેના પર તે કાર્ય કરે છે, જે મેથડ નામ પહેલા ઘોષિત કરવામાં આવે છે. તે **મૂલ્ય રીસીવર** હોઈ શકે છે (કોપી પર કાર્ય કરે છે) અથવા **પોઇન્ટર રીસીવર** હોઈ શકે છે (મૂળ પર કાર્ય કરે છે, તેને સુધારી શકે છે). યોગ્ય પસંદગી કરવી સાચીતા (mutation) અને કામગીરીમાં બંને માટે મહત્વપૂર્ણ છે।

## મૂલ્ય રીસીવર — કોપી પર કાર્ય કરે છે

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

મૂલ્ય રીસીવર struct ની કોપી મેળવે છે, તેથી તેમાં પરિવર્તનો મૂળને અસર કરતા નથી — માત્ર-વાંચન મેથડ્સ માટે ઉપયોગી છે, પરંતુ એક bug છે જો તમે mutation ની અપેક્ષા રાખી હોય।

## પોઇન્ટર રીસીવર — મૂળ પર કાર્ય કરે છે

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

પોઇન્ટર રીસીવર વાસ્તવિક 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)
```

## સુસંગતા નિયમ

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

મૂલ્ય અને પોઇન્ટર રીસીવર્સને એક પ્રકાર પર મિશ્રિત કરવું સૂક્ષ્મ સમસ્યાઓ પેદા કરે છે — સંમેલન એક (સામાન્યત: પોઇન્ટર જો કોઈ પણ મેથડ mutation કરે) પસંદ કરવાનું અને તમામ મેથડ્સ માટે તેનો ઉપયોગ કરવાનું છે।

## Interface સંતુષ્ટિ સૂક્ષ્મતા

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

યહ એક સામાન્ય gotcha છે: પોઇન્ટર-રીસીવર મેથડ્સ સાથે, માત્ર પોઇન્ટર પ્રકાર interface ને સંતોષે છે।

## શા માટે તે મહત્વપૂર્ણ છે

મૂલ્ય-વર્સસ-પોઇન્ટર રીસીવર પસંદગી એક મૌલિક, વારંવાર-ગેરસમજાયેલી Go નિર્ણય છે જે સાચીતા, કામગીરી અને interface સંતુષ્ટિને અસર કરે છે।

સૌથી સામાન્ય bug એ છે કે **મૂલ્ય રીસીવર વાપરવો જ્યારે તમે mutation કરવા માંગ્યા** — તેમાં પરિવર્તન શાંતિથી માત્ર એક કોપીને અસર કરે છે, તેથી પરિવર્તન "લાગતું નથી।" મેથડને મહત્તમ struct માટે પોઇન્ટર રીસીવર્સ mutation માટે આવશ્યક છે અને ભલામણ કરવામાં આવે છે (દરેક કૉલ પર મંહગા કોપી ટાળવા માટે)।

**સુસંગતા નિયમ** (પ્રકારની તમામ મેથડ્સ પર સમાન રીસીવર પ્રકાર વાપરો) મૂંઝવણ ટાળે છે, અને **interface-સંતુષ્ટિ સૂક્ષ્મતા** (પોઇન્ટર-રીસીવર મેથડ્સનો અર્થ એ છે કે માત્ર પોઇન્ટર પ્રકાર interface ને સંતોષે છે) એક ક્લાસિક gotcha છે જે "does not implement interface" ભૂલો તરફ દોરી જાય છે।

આને સમજવું યોગ્ય, કાર્યક્ષમ Go લખવા માટે આવશ્યક છે અને તે સૌથી સામાન્ય વ્યવહારુ અને ઇન્ટરવ્યુ વિષયોમાંથી એક છે, કારણ કે પસંદગીના અ-સ્પષ્ટ પરિણામો છે।