Değer alıcısı (value receiver) ile işaretçi alıcısı (pointer receiver) arasındaki fark nedir?

Question

Accepted Answer

Bir metodun **alıcısı (receiver)**, metodun adından önce bildirilen, üzerinde çalıştığı değerdir. Bir **değer alıcısı** (kopya üzerinde çalışır) veya bir **işaretçi alıcısı** (orijinal üzerinde çalışır, onu değiştirebilir) olabilir. Doğru seçim yapmak hem doğruluk (mutasyon) hem de performans açısından önemlidir.

## Değer alıcısı — BİR KOPYA üzerinde çalışır

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

Değer alıcısı struct'ın bir kopyasını alır, bu nedenle değişiklikler orijinali etkilemez — salt okunur metotlar için faydalı, ancak mutasyon yapmak istiyorsanız bir hatadır.

## İşaretçi alıcısı — ORIJINAL üzerinde çalışır

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

İşaretçi alıcısı gerçek struct üzerinde çalışır, bu nedenle onu **değiştirebilir**. Go otomatik olarak adresi alır (`c.Increment()` bir değer üzerinde bile çalışır).

## Hangisini ne zaman kullanmalı

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

## Tutarlılık kuralı

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

Bir tür üzerinde değer ve işaretçi alıcılarını karıştırmak ince sorunlara yol açar — geleneksel olarak birini seçmek (genellikle herhangi bir metot mutasyon yapıyorsa işaretçi) ve bunu tüm metotlar için kullanmak önerilen yoldur.

## Arayüz (Interface) tatmin etme ince noktası

```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 yaygın bir hata: işaretçi alıcı metotlarında, sadece işaretçi tipi arayüzü tatmin eder.

## Neden önemli

Değer-ve-işaretçi alıcı seçimi, doğruluk, performans ve arayüz tatmin etmeyi etkileyen temel, sıkça yanlış anlaşılan bir Go kararıdır.

En yaygın hata **mutasyon yapmak istediğinizde değer alıcısı kullanmak** — değişiklik sessizce sadece bir kopyayı etkiler, bu nedenle değişiklik "yapılmamış" gibi görünür. İşaretçi alıcıları mutasyon için gerekli ve büyük struct'lar için önerilir (her çağrıda pahalı kopyaları önlemek için).

**Tutarlılık kuralı** (bir türün tüm metotlarında aynı alıcı tipini kullanmak) karışıklığı önler ve **arayüz tatmin etme ince noktası** (işaretçi alıcı metotları, sadece işaretçi tipinin arayüzü tatmin edeceği anlamına gelir) "does not implement interface" hatalarına neden olan klasik bir hatadır.

Bunları anlamak, doğru ve verimli Go yazması açısından gereklidir ve seçimin bariz olmayan sonuçları olduğu için en yaygın pratik ve mülakat konularındandır.