Mitä eroa on arvon ja osoittimen vastaanottimilla?

Question

Accepted Answer

Metodin **vastaanotin** on arvo, johon se vaikuttaa ja joka deklaroidaan metodin nimen edessä. Se voi olla **arvovastaanotin** (vaikuttaa kopioon) tai **osoitinvastaanotin** (vaikuttaa alkuperäiseen, voi muokata sitä). Oikean valinnan tekeminen on tärkeää sekä oikeellisuuden (mutaatio) että suorituskyvyn kannalta.

## Arvovastaanotin — vaikuttaa KOPIOON

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

Arvovastaanotin saa kopion structista, joten muutokset eivät vaikuta alkuperäiseen — hyödyllinen vain luvuille tarkoitetuissa metodeissa, mutta virhe, jos aiot muokata.

## Osoitinvastaanotin — vaikuttaa ALKUPERÄISEEN

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

Osoitinvastaanotin vaikuttaa todelliseen structiin, joten se voi **muokata** sitä. Go ottaa osoitteen automaattisesti (`c.Increment()` toimii myös arvolla).

## Milloin käyttää kumpaa

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

## Johdonmukaisuuden sääntö

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

Arvo- ja osoitinvastaanottimien sekoittaminen samalla tyypillä aiheuttaa hienovaraisia ongelmia — käytäntö on valita yksi (yleensä osoitin, jos mikä tahansa metodi muokkaa) ja käyttää sitä kaikissa metodeissa.

## Rajapinnan toteutumisen hienovaraisuus

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

Tämä on yleinen ansa: osoitinvastaanottimilla vain osoitintyyppi toteuttaa rajapinnan.

## Miksi se on tärkeää

Arvo- vs. osoitinvastaanottimen valinta on perustavanlaatuinen, usein väärin ymmärretty Go-päätös, joka vaikuttaa oikeellisuuteen, suorituskykyyn ja rajapinnan toteutumiseen.

Tavallisin virhe on käyttää **arvovastaanottinta, kun aiot muokata** — muutus vaikuttaa vain kopioon, joten muutos "ei pysy". Osoitinvastaanottajat ovat välttämättömiä mutaatiolle ja suositeltavia suurille structeille (kalliin kopioinnin välttämiseksi joka kutsulla).

**Johdonmukaisuuden sääntö** (käytä samaa vastaanottimen tyyppiä kaikissa tyypin metodeissa) välttää sekaannusta, ja **rajapinnan toteutumisen hienovaraisuus** (osoitinvastaanottimella vain osoitintyyppi toteuttaa rajapinnan) on klassinen ansa, joka aiheuttaa "does not implement interface" -virheitä.

Näiden ymmärtäminen on olennaista oikean ja tehokkaan Go-koodin kirjoittamiselle ja on yksi yleisimmistä käytännön ja haastattelu-aiheista, koska valinnalla on ei-ilmeisiä seurauksia.