மதிப்பு receiver மற்றும் pointer receiver இடையே உள்ள வேறுபாடு என்ன?

Question

Accepted Answer

ஒரு method-ன் **receiver** என்பது அது செயல்பட்ட மதிப்பு, method பெயருக்கு முன்னதாக அறிவிக்கப்படுகிறது. இது **value receiver** (ஒரு copy-ல் செயல்படுகிறது) அல்லது **pointer receiver** (original-ல் செயல்படுகிறது, அதை மாற்ற முடியும்). சரியாக தேர்ந்தெடுப்பது சரியுறுதி (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-ஐ பெறுகிறது, எனவே மாற்றங்கள் original-ஐ பாதிக்காது — read-only methods-க்கு பயனுள்ளது, ஆனால் நீங்கள் mutate செய்ய விரும்பினால் ஒரு bug ஆகும்.

## Pointer receiver — ORIGINAL-ல் செயல்படுகிறது

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

```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-ஐ கலப்பது நுட்பமான சிக்கல்களை ஏற்படுத்தும் — convention ஆனது ஒன்றை தேர்ந்தெடுப்பது (பொதுவாக pointer என்றால் ஏதேனும் method mutates) மற்றும் அதை அனைத்து methods-க்கும் பயன்படுத்துவது ஆகும்.

## Interface satisfaction subtlety

```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 choice ஆனது ஒரு fundamental, அடிக்கடி misunderstood Go முடிவு ஆகும் இது correctness, performance, மற்றும் interface satisfaction-ஐ பாதிக்கிறது.

மிகவும் பொதுவான bug ஆனது ஒரு **value receiver-ஐ பயன்படுத்துவது நீங்கள் mutate செய்ய விரும்பினால்** — modification தனியாக ஒரு copy-ஐ மட்டுமே பாதிக்கிறது, எனவே change "stick ஆகாது." Pointer receivers mutation-க்கு தேவைப்பட்டு பெரிய structs-க்கு பரிந்துரைக்கப்படுகிறது (ஒவ்வொரு call-ல் महंगे copies தவிர்க்க).

**Consistency rule** (ஒரு type-ன் methods முழுவதும் same receiver type பயன்படுத்த) confusion-ஐ தவிர்க்கிறது, மற்றும் **interface-satisfaction subtlety** (pointer-receiver methods mean pointer type மட்டுமே interface-ஐ satisfy செய்கிறது) ஒரு classic gotcha ஆகும் "does not implement interface" errors-ஐ ஏற்படுத்தும்.

இவற்றை புரிந்துகொள்வது சரியான, efficient Go-ஐ எழுத முக்கியமாக இருக்கிறது மற்றும் மிகவும் பொதுவான practical மற்றும் interview topics-ல் இருக்கிறது, choice-க்கு non-obvious consequences இருப்பதால்.