Co dělají attr_accessor, attr_reader a attr_writer?

Question

Accepted Answer

Jedná se o Ruby metody, které **automaticky generují getter a/nebo setter metody** pro instance proměnné — což eliminuje boilerplate kód. Protože jsou instance proměnné (`@name`) soukromé a nejsou přímo přístupné zvenčí, potřebujete accessor metody pro čtení/zápis, a `attr_*` je generuje stručně.

## Problém, který řeší

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

## Tři generátory accessorů

```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`** → pouze getter (přístup pro čtení).
- **`attr_writer`** → pouze setter (přístup pro zápis).
- **`attr_accessor`** → getter i setter (přístup pro čtení i zápis).

Každý z nich přijímá symboly pojmenování instance proměnných a automaticky generuje odpovídající metody — jeden řádek nahradí několik ručně psaných definic metod.

## Volba správného (zapouzdření)

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

Volba `attr_reader` (místo `attr_accessor`) pro pole, která by se neměla libovolně měnit zvenčí, je dobré zapouzdření — exponujete pouze přístup, který chcete.

## Proč to má důležitost

Rozmíšlení `attr_accessor`/`attr_reader`/`attr_writer` je základní každodenní znalost Ruby, protože se objevují v téměř každé Ruby třídě.

Hlavní důvod jejich existence: instance proměnné (`@name`) jsou **soukromé a nejsou přímo přístupné** zvenčí objektu, proto potřebujete accessor metody pro jejich čtení nebo zápis — a psaní těchto getterů/setterů ručně pro každý atribut je únavné opakování kódu.

Tyto metody **generují accessory automaticky** (`attr_reader` pro přístup jen pro čtení, `attr_writer` pro přístup jen pro zápis, `attr_accessor` pro oba), nahrazují několik definic metod jediným stručným řádkem — což je charakteristické pro Ruby eleganci a stručnost.

Porozumění tomu, co každá generuje, a **volba vhodné** je také otázkou dobrého **zapouzdření**: použití `attr_reader` (jen pro čtení) pro pole, která by neměla být libovolně měněna zvenčí, a `attr_accessor` pouze tam, kde je přístup pro čtení i zápis opravdu zamýšlen, kontroluje, jak je stav objektu exponován (např. zůstatek bankovního účtu je čitelný, ale lze ho měnit pouze řídícími metodami).

Protože jsou tyto accessory všudypřítomné v Ruby třídách (a Rails modelech), znalost toho, jak fungují, co každá generuje, a jak vybrat pro správné zapouzdření, je nezbytná znalost pro psaní a čtení Ruby tříd — je to jedna z prvních věcí, se kterými se setkáte při definování Ruby tříd, a odráží přístup jazyka ke stručné a výstižné řešení běžné potřeby (kontrolovaný přístup ke stavu objektu).