ਮੁੱਲ ਅਤੇ ਪੋਇੰਟਰ ਰਿਸੀਵਰ ਵਿੱਚ ਕੀ ਫਰਕ ਹੈ?

Question

Accepted Answer

ਕਿਸੇ ਮੈਥਡ ਦਾ **receiver** ਉਹ ਮੁੱਲ ਹੈ ਜਿਸ 'ਤੇ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ, ਮੈਥਡ ਦੇ ਨਾਮ ਤੋਂ ਪਹਿਲਾਂ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਇੱਕ **value receiver** ਹੋ ਸਕਦਾ ਹੈ (ਇੱਕ ਕਾਪੀ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ) ਜਾਂ ਇੱਕ **pointer receiver** ਹੋ ਸਕਦਾ ਹੈ (ਅਸਲ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਸ ਨੂੰ ਬਦਲ ਸਕਦਾ ਹੈ)। ਸਹੀ ਚੋਣ ਸ਼ੁੱਧਤਾ (mutation) ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਦੋਵਾਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।

## 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 ਨੂੰ struct ਦੀ ਇੱਕ ਕਾਪੀ ਮਿਲਦੀ ਹੈ, ਇਸ ਲਈ ਸੋਧ ਅਸਲ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਕਰਦੀ — read-only ਮੈਥਡਾਂ ਲਈ ਲਾਭਦਾਇਕ, ਪਰ ਇਹ ਇੱਕ ਬਗ ਹੈ ਜੇ ਤੁਸੀਂ mutation ਕਰਨਾ ਚਾਹੁੰਦੇ ਸੀ।

## 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 ਆਪਣੇ ਆਪ ਨੂੰ ਪਤਾ ਲੈਂਦਾ ਹੈ (`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
```

Value ਅਤੇ pointer receivers ਨੂੰ ਇੱਕ ਟਾਇਪ 'ਤੇ ਮਿਲਾਉਣਾ ਸੂਖਮ ਸਮੱਸਿਆਵਾਂ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ — ਰਵਾਇਤ ਇੱਕ ਨੂੰ ਚੁਣਨਾ ਹੈ (ਆਮ ਤੌਰ 'ਤੇ ਪੁਆਇੰਟਰ ਜੇ ਕੋਈ ਮੈਥਡ mutation ਕਰਦਾ ਹੈ) ਅਤੇ ਸਾਰੇ ਮੈਥਡਾਂ ਲਈ ਇਸ ਨੂੰ ਵਰਤੋ।

## 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 ਮੈਥਡਾਂ ਦੇ ਨਾਲ, ਸਿਰਫ ਪੋਇੰਟਰ ਟਾਇਪ interface ਨੂੰ ਸਮਝਦਾ ਹੈ।

## ਇਸ ਦਾ ਕੀ ਮਾਤਰ ਹੈ

Value-vs-pointer receiver ਦੀ ਚੋਣ ਇੱਕ ਬੁਨਿਆਦੀ, ਅਕਸਰ ਗਲਤ ਸਮਝਿਆ ਜਾਣ ਵਾਲਾ Go ਫੈਸਲਾ ਹੈ ਜੋ ਸ਼ੁੱਧਤਾ, ਪ੍ਰਦਰਸ਼ਨ, ਅਤੇ interface satisfaction ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ।

ਸਭ ਤੋਂ ਆਮ ਬਗ ਇੱਕ **value receiver ਵਰਤਣਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ mutation ਕਰਨਾ ਚਾਹੁੰਦੇ ਸੀ** — ਸੋਧ ਖਾਮੋਸ਼ੀ ਨਾਲ ਸਿਰਫ ਇੱਕ ਕਾਪੀ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀ ਹੈ, ਇਸ ਲਈ ਤਬਦੀਲੀ "ਟਿਕੀ ਨਹੀਂ ਰਹਦੀ।" Pointer receivers mutation ਲਈ ਜ਼ਰੂਰੀ ਹਨ ਅਤੇ ਵੱਡੇ structs ਲਈ ਸਿਫਾਰਸ਼ ਕੀਤੇ ਜਾਂਦੇ ਹਨ (ਹਰ ਕਾਲ 'ਤੇ ਮਹਿੰਗੀ ਕਾਪੀਆਂ ਤੋਂ ਬਚਣ ਲਈ)।

**ਇੱਕਸਾਰਤਾ ਨਿਯਮ** (ਇੱਕ ਟਾਇਪ ਦੇ ਸਾਰੇ ਮੈਥਡਾਂ ਵਿੱਚ ਉਹੀ receiver type ਵਰਤੋ) ਉਲਝਣ ਨੂੰ ਰੋਕਦਾ ਹੈ, ਅਤੇ **interface-satisfaction ਦੀ ਸੂਖਮਤਾ** (pointer-receiver ਮੈਥਡਾਂ ਦਾ ਅਰਥ ਹੈ ਸਿਰਫ ਪੋਇੰਟਰ ਟਾਇਪ interface ਨੂੰ ਸਮਝਦਾ ਹੈ) ਇੱਕ ਕਲਾਸਿਕ ਮੇਲ ਹੈ ਜੋ "does not implement interface" ਗਲਤੀਆਂ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ।

ਇਹਨਾਂ ਨੂੰ ਸਮਝਣਾ ਸਹੀ, ਕੁਸ਼ਲ Go ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਅਤੇ ਇੰਟਰਵਿਊ ਵਿਸ਼ਿਆਂ ਵਿੱਚ ਸਭ ਤੋਂ ਆਮ ਹੈ, ਕਿਉਂਕਿ ਚੋਣ ਦੇ ਗੈਰ-ਸਪਸ਼ਟ ਨਤੀਜੇ ਹਨ।