Kuo skiriasi vertės imtuvas ir rodyklės imtuvas?

Question

Accepted Answer

Metodo **imtuvas** yra reikšmė, kurią jis apdoroja, paskelbta prieš metodo pavadinimą. Tai gali būti **vertės imtuvas** (apdoroja kopiją) arba **rodyklės imtuvas** (apdoroja originalą, gali jį keisti). Teisingas pasirinkimas svarbus tiek tikslumui (mutacija), tiek efektyvumui.

## Vertės imtuvas — apdoroja KOPIJĄ

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

Vertės imtuvas gauna struktūros kopiją, todėl pakeitimai neveikia originalą — naudingas tik skaitymui skirtems metodams, bet klaida, jei norėjote keisti.

## Rodyklės imtuvas — apdoroja 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
```

Rodyklės imtuvas apdoroja tikrą struktūrą, todėl gali ją **keisti**. Go automatiškai paima adresą (`c.Increment()` veikia net ir su verte).

## Kada naudoti kurį

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

## Nuoseklumo taisyklė

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

Maišant vertės ir rodyklės imtuvus vienam tipui sukelia subtilias problemas — konvencija pasirinkti vieną (paprastai rodyklę, jei koks nors metodas keičia) ir naudoti jį visiems metodams.

## Sąsajos tenkinimo subtilybė

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

Tai bendra spąstai: su rodyklės imtuvo metodais tik rodyklės tipas tenkina sąsają.

## Kodėl tai svarbu

Vertės ir rodyklės imtuvo pasirinkimas yra pagrindinė, dažnai nesuprasta Go sprendimų, veikianti tikslumą, efektyvumą ir sąsajos tenkinimą.

Dažniausia klaida yra naudoti **vertės imtuvą, kai norėjote keisti** — pakeitimas tyliai veikia tik kopiją, todėl pakeitimas "nelieka". Rodyklės imtuvai reikalingi mutacijai ir rekomenduojami didelėms struktūroms (kad būtų išvengta brangių kopijų su kiekvienu iškvietimu).

**Nuoseklumo taisyklė** (naudoti tą patį imtuvo tipą visuose tipo metoduose) išvengti painiavos, o **sąsajos tenkinimo subtilybė** (rodyklės imtuvo metodai reiškia, kad tik rodyklės tipas tenkina sąsają) yra klasikiniai spąstai, kurie sukelia "does not implement interface" klaidas.

Šių supratimas yra būtinas norint parašyti teisingą, efektyvų Go ir yra dažniausias praktinis ir pokalbio klausimas, nes pasirinkimas turi neakivaizdžias pasekmes.