Cad é an difríonn idir glacadóirí luacha agus glacadóirí pointeora?

Question

Accepted Answer

Is é **receiver** an modh ná an luach ar a ndéanann sé oibríochtaí air, arna fhógairt roimh ainm an mhodh. Is féidir leis a bheith ina **receiver luacha** (oibríonn ar chóip) nó ina **receiver pointeora** (oibríonn ar an bhunaidh, is féidir leis é a athrú). Bíonn tábhacht le roghnú go ceart maidir le beachtacht (athrú) agus feidhmíochta araon.

## Glacadóir luacha — oibríonn ar CHÓIP

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

Faigheann glacadóir luacha cóip den struct, mar sin ní bhíonn tionchar ag modhnuithe ar an bhunaidh — úsáideach do mhodh-léite amháin, ach fabht má bhí sé i gceist agat athrú a dhéanamh.

## Glacadóir pointeora — oibríonn ar an BHUNAIDH

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

Oibríonn glacadóir pointeora ar an struct iarbhír, ionas gur féidir leis **athrú** a dhéanamh air. Tógann Go an seoladh go foluain (`c.Increment()` oibríonn fiú ar luach).

## Cathain a úsáid cé acu

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

## An riail chomhsheasmhachta

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

Meascadh glacadóirí luacha agus pointeora ar chineál amháin a bhíonn ina chúis le fadhbanna fúarchéille — gconspáid is ea a roghnú ceann amháin (go hiondúil pointeara má athruithe aon mhodh amháin) agus é a úsáid do gach modh.

## Finéaltas sásúchta an chomhéadain

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

Is gné runda coitianta í seo: le modh-ghlacadóirí pointeora, ní shásaíonn ach an cineál pointeora an comhéadan.

## Cén fáth a bhíonn tábhacht leis

Is cinneadh bunúsach, go mór-mhíthhuigthe Go an rogha receiver luacha in aghaidh pointeora, agus bíonn tionchar aici ar bhreachacht, feidhmíochta, agus sásúchta an chomhéadain.

An fabht is coitianta is ea **receiver luacha a úsáid nuair ba bhreá leat athrú a dhéanamh** — bíonn an t-athrú ag tionchar ar chóip amháin go ciúin, mar sin ní "fhanann" an t-athrú. Tá gá le glacadóirí pointeora le haghaidh athruithe agus moltar iad d'structs móra (chun cóipeanna costasacha a sheachaint ar gach glaoch).

Bíonn an **riail chomhsheasmhachta** (an cineál receiver céanna a úsáid ar bhus mhodh-dhóchán an chineáil) ag seachaint mearbhaill, agus is gné runda ar dhath cliste an **sásúchta comhéadain** (ciallaíonn glacadóirí modh-phointeora go dtugann pointeora amháin an comhéadan) a bhíonn ina chúis le "nach gcomhlíonann sé an comhéadan" earráidí.

Tá sé ríthábhachtach a thuiscint seo chun Go ceart, éifeachtach a scríobh agus is measc an topicí gealadh practúlach agus agallamh, mar go bhfuil iarmhairtí neamhshoiléir ag baint den rogha.