value र pointer receivers बीचको फरक के हो?

Question

Accepted Answer

एक method को **receiver** भनेको यो value हो जस मा यो काम गर्छ, method नाम अगाडि घोषित गरिएको। यो **value receiver** (एक copy मा काम गर्छ) वा **pointer receiver** (मूल मा काम गर्छ, यो modify गर्न सक्छ) हो सक्छ। सही छनोट गर्नु दुबै correctness (mutation) र performance को लागि महत्त्वपूर्ण छ।

## Value receiver — एक COPY मा काम गर्छ

```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 ले struct को एक copy पाउँछ, त्यसैले modifications ले original लाई प्रभावित गर्दैन — read-only methods को लागि उपयोगी छ, तर यदि तपाईं mutate गर्न चाहनुभयो भने यो bug हो।

## 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 मा काम गर्छ, त्यसैले यो **modify** गर्न सक्छ। Go स्वचालित रूपमा address लिन्छ (`c.Increment()` value मा पनि काम गर्छ)।

## कुन समय कुन प्रयोग गर्ने

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

यो एक सामान्य gotcha हो: pointer-receiver methods को साथ, केवल pointer type ले interface लाई satisfy गर्छ।

## किन यो महत्त्वपूर्ण छ

Value-vs-pointer receiver को छनोट एक मौलिक, बारम्बार गलतफहमी गरिएको Go निर्णय हो जो correctness, performance, र interface satisfaction लाई प्रभावित गर्छ।

सबै भन्दा सामान्य bug भनेको **value receiver प्रयोग गर्नु जब तपाईं mutate गर्न चाहनुभयो** — modification मौनमा केवल एक copy लाई प्रभावित गर्छ, त्यसैले परिवर्तन "स्थिर रहदैन"। Pointer receivers mutation को लागि आवश्यक छ र ठूला structs को लागि सिफारिश गरिएको छ (हरेक call मा महँगो copies बचाउन)।

**Consistency नियम** (एक type को सबै methods को लागि एक जस्तै receiver type प्रयोग गर्नु) भ्रम बचाउँछ, र **interface-satisfaction सूक्ष्मता** (pointer-receiver methods को अर्थ केवल pointer type ले interface लाई satisfy गर्छ) एक classic gotcha हो जो "does not implement interface" errors सृष्टि गर्छ।

यी कुरा बुझ्नु सही, efficient Go लेख्नु को लागि अपरिहार्य छ र सबै भन्दा सामान्य व्यावहारिक र interview विषयहरू बीचमा छ, किनकि छनोटको गैर-स्पष्ट परिणामहरू छ।