value और pointer receivers में क्या अंतर है?

Question

Accepted Answer

एक method का **receiver** वह value है जिस पर वह काम करता है, method के नाम से पहले घोषित किया जाता है। यह एक **value receiver** (एक copy पर काम करता है) या एक **pointer receiver** (मूल पर काम करता है, उसे संशोधित कर सकता है) हो सकता है। सही चुनाव 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 पाता है, इसलिए संशोधन मूल को प्रभावित नहीं करते — 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 पर काम करता है, इसलिए वह उसे **संशोधित** कर सकता है। 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 संतुष्टि की सूक्ष्मता

```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 को संतुष्ट करता है।

## यह क्यों महत्वपूर्ण है

value-बनाम-pointer receiver का चुनाव एक बुनियादी, अक्सर गलत समझा जाने वाला Go निर्णय है जो correctness, performance, और interface संतुष्टि को प्रभावित करता है।

सबसे आम bug तब होता है जब आप mutate करना चाहते थे लेकिन **value receiver का उपयोग कर लिया** — संशोधन चुपचाप केवल एक copy को प्रभावित करता है, इसलिए परिवर्तन "टिकता नहीं।" mutation के लिए pointer receivers आवश्यक हैं और बड़े structs के लिए अनुशंसित (हर call पर महंगी copies से बचने के लिए)।

**consistency नियम** (एक type के methods में समान receiver type का उपयोग) भ्रम से बचाता है, और **interface-संतुष्टि की सूक्ष्मता** (pointer-receiver methods का मतलब केवल pointer type interface को संतुष्ट करता है) एक classic gotcha है जो "does not implement interface" errors का कारण बनता है।

इन्हें समझना सही, कुशल Go लिखने के लिए आवश्यक है और सबसे आम व्यावहारिक व interview विषयों में से है, क्योंकि इस चुनाव के गैर-स्पष्ट परिणाम होते हैं।