attr_accessor, attr_reader ve attr_writer ne işe yarar?

Question

Accepted Answer

Bunlar Ruby metotlarıdır ve **instance variable'ları için getter ve/veya setter metotlarını otomatik olarak oluştururlar** — standart kodu ortadan kaldırır. Instance variable'lar (`@name`) private olduğundan ve dışarıdan doğrudan erişilemediğinden, onları okumak/yazmak için accessor metotlarına ihtiyacınız vardır ve `attr_*` bunları kısaca oluşturur.

## Çözdükleri sorun

```ruby
# ❌ without attr_* — manually writing getters/setters (tedious boilerplate)
class Person
  def initialize(name)
    @name = name
  end
  def name           # manual getter
    @name
  end
  def name=(value)   # manual setter
    @name = value
  end
end
```

## Üç accessor üreteç

```ruby
class Person
  attr_reader :name      # generates a GETTER only (read-only): person.name
  attr_writer :email     # generates a SETTER only (write-only): person.email = ...
  attr_accessor :age     # generates BOTH getter and setter: person.age / person.age = ...

def initialize(name, age)
    @name = name
    @age = age
  end
end

person = Person.new("Ann", 30)
person.name        # "Ann" — reader
person.age = 31     # writer
person.age          # 31 — reader
person.name = "X"   # ❌ NoMethodError — name is read-only (attr_reader, no setter)
```

- **`attr_reader`** → sadece getter (salt okunur erişim).
- **`attr_writer`** → sadece setter (salt yazılır).
- **`attr_accessor`** → hem getter hem setter (okuma-yazma).

Her biri instance variable'ları adlandıran semboller alır ve karşılık gelen metotları otomatik olarak oluşturur — bir satır birkaç manuel metot tanımını değiştirir.

## Doğru olanını seçmek (encapsulation)

```ruby
class BankAccount
  attr_reader :balance     # ✅ balance is readable but NOT directly settable (protect it)

def initialize
    @balance = 0
  end
  def deposit(amount)       # changes go through a controlled method, not a raw setter
    @balance += amount if amount > 0
  end
end
```

Dışarıdan keyfi olarak ayarlanmaması gereken alanlar için `attr_reader` (vs `attr_accessor`) seçmek iyi encapsulation'dır — yalnızca amaçladığınız erişimi ortaya koymak.

## Neden önemli

`attr_accessor`/`attr_reader`/`attr_writer` kavramını anlamak temel günlük Ruby bilgisidir, çünkü neredeyse her Ruby class'ında görülürler.

Bunların var olma sebebi: instance variable'lar (`@name`) **private ve dışarıdan doğrudan erişilemez** olduğundan, onları okumak veya yazmak için accessor metotlarına ihtiyacınız vardır — ve her attribute için bu getter/setter'ları manuel olarak yazmak yorucu standart koddur.

Bu metotlar **accessor'ları otomatik olarak oluştururlar** (`attr_reader` salt okunur için, `attr_writer` salt yazılır için, `attr_accessor` her ikisi için), birkaç metot tanımını tek bir kısa satırla değiştirir — bu Ruby'nin elegansı ve kısa olmasının bir işaretidir.

Her birinin ne oluşturduğunu anlamak ve **uygun olanı seçmek** aynı zamanda iyi **encapsulation** meselesidir: bir nesnenin durumunun nasıl ortaya konduğunu kontrol etmek için okunmaması gereken alanlar için `attr_reader` (salt okunur) kullanmak ve gerçekten okuma-yazma erişiminin amaçlandığı yerlerde `attr_accessor` kullanmak (örneğin bir banka bakiyesini okunabilir ama yalnızca kontrollü metotlar aracılığıyla değiştirilebilir kılmak).

Bu accessor'lar Ruby class'larında (ve Rails model'lerinde) her yerde olduğundan, nasıl çalıştıklarını, her birinin ne oluşturduğunu ve uygun encapsulation için nasıl seçeceğini bilmek Ruby class'ları yazıp okuması için gerekli, mutlaka bilinmesi gereken bilgidir — Ruby class'ları tanımlarken ilk karşılaştığınız şeylerden biridir ve dilin ortak bir ihtiyaca (nesne durumuna kontrollü erişim) yönelik kısa, anlaşılır yaklaşımını yansıtır.