Menene bambanci tsakanin mai karɓa ƙima da mai karɓa ɗigo?

Question

Accepted Answer

**Karɓar** hanya ita ce ƙima da ta aiki a gida, sanye a gida jiya sunin hanya. Za ta iya zama **mai karɓa ƙima** (tana aiki a kan kwafin) ko **mai karɓa ɗigo** (tana aiki a kan asali, za ta iya canza ta). Zaɓin daidai yana matuƙa ga duka daidaita (sauyi) da ƙarfin aiki.

## Mai karɓa ƙima — aiki a kan KWAFIN

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

Mai karɓa ƙima yana karɓa kwafin struct, saboda haɗa bada ta ba karɓa asali ba — aiki ne a gida don hanyoyin karanta-kawai, amma bu'a ne idan kun nufi sauyi.

## Mai karɓa ɗigo — aiki a kan ASALI

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

Mai karɓa ɗigo yana aiki a kan struct na gaske, saboda haka za ta iya **canza** ta. Go ya kamata ataje ainihi (`c.Increment()` yana aiki har ma a kan ƙima).

## Lokacin amfani da wacce

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

## Ka'idar daidaita

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

Magugulantar mai karɓa ƙima da mai karɓa ɗigo a jiya iri yana haifar da matsaloli marasa fahimi — al'ada ita ce zaɓi ɗaya (yawanin lokaci ɗigo idan wata hanya sauya) kuma amfani da ta ga duka hanyoyi.

## Kasuwance-buƙatun 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
```

Buƙatar gotcha ce: tare da hanyoyin mai karɓa ɗigo, ɗigo-iri ne kawai ya gamsu da kasuwance.

## Menene bukatu

Zaɓin ƙima-da-ɗigo na mai karɓa ita ce muhimmacin, abin da aka sanatsa Go wanda ya tasiri daidaita, ƙarfi, da buƙatun kasuwance.

Mafi yawan bu'a ita ce amfani **mai karɓa ƙima lokacin da kuke nufi sauyi** — sauyi yana shafar kwafin ne kawai, saboda haka canja "ba ta fice ba." Mai karɓar ɗigo ana buƙata ga sauyi da shawarar ga girman struct (don guji jajaye mai tsada a kowane kira).

**Ka'idar daidaita** (amfani da iri daya na karɓar a kan hanyoyin iri) yana guji wasiwaci, da **kasuwance-buƙatun subtlety** (hanyoyin mai karɓa ɗigo sune "ba ta aiki kasuwance" kuskure) ita ce galaba gotcha wanda yana haifar da kuskure. Fahimta waɗannan ita ce muhimmaci wajen rubuta daidaitaccen, ƙarfin aiki Go kuma tsakanin muhimman abubuwan amfani da tattaunawa, tunda zaɓin yana da kankara marasa wuya.