В чем разница между value receiver и pointer receiver?

Question

Accepted Answer

**Receiver** (получатель) метода — это значение, над которым он работает, объявленное перед именем метода. Это может быть **value receiver** (работает с копией) или **pointer receiver** (работает с оригиналом, может его изменять). Правильный выбор важен как для корректности (мутация), так и для производительности.

## Value receiver — работает с КОПИЕЙ

```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 получает копию структуры, поэтому изменения не влияют на оригинал — полезно для методов только для чтения, но это ошибка, если вы планировали мутировать.

## Pointer receiver — работает с ОРИГИНАЛОМ

```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 работает с реальной структурой, поэтому может её **изменять**. Go автоматически берёт адрес (`c.Increment()` работает даже на значении).

## Когда использовать что

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

## Правило консистентности

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

Смешивание value и pointer receivers у одного типа вызывает тонкие проблемы — соглашение состоит в том, чтобы выбрать один (обычно pointer, если какой-нибудь метод мутирует) и использовать его для всех методов.

## Тонкость удовлетворения интерфейса

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

Это частая ошибка: с pointer-receiver методами только тип pointer удовлетворяет интерфейсу.

## Почему это важно

Выбор между value и pointer receiver — фундаментальное и часто неправильно понимаемое решение в Go, которое влияет на корректность, производительность и удовлетворение интерфейса.

Самая частая ошибка — использование **value receiver, когда вы планировали мутировать** — изменение незаметно влияет только на копию, поэтому изменение «не закрепляется». Pointer receivers требуются для мутации и рекомендуются для больших структур (чтобы избежать дорогих копий при каждом вызове).

**Правило консистентности** (использовать один и тот же receiver type для всех методов типа) избегает путаницы, и **тонкость удовлетворения интерфейса** (pointer-receiver методы означают, что только тип pointer удовлетворяет интерфейсу) — это классическая ошибка, вызывающая ошибки «does not implement interface».

Понимание этих концепций необходимо для написания корректного и эффективного Go кода и входит в числе наиболее частых практических и собеседовательских тем, поскольку выбор имеет неочевидные последствия.