Do czego służą attr_accessor, attr_reader i attr_writer?

Question

Accepted Answer

Są to metody Ruby, które **automatycznie generują metody getter i/lub setter** dla zmiennych instancji — eliminując boilerplate. Ponieważ zmienne instancji (`@name`) są prywatne i niedostępne bezpośrednio z zewnątrz, potrzebujesz metod dostępowych do odczytu/zapisu, a `attr_*` generuje je zwięźle.

## Problem, który rozwiązują

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

## Trzy generatory dostępu

```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`** → tylko getter (dostęp tylko do odczytu).
- **`attr_writer`** → tylko setter (dostęp tylko do zapisu).
- **`attr_accessor`** → zarówno getter, jak i setter (dostęp do odczytu i zapisu).

Każda przyjmuje symbole nazewające zmienne instancji i generuje odpowiadające im metody automatycznie — jeden wiersz zastępuje kilka ręcznych definicji metod.

## Wybieranie właściwego (enkapsulacja)

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

Wybór `attr_reader` (zamiast `attr_accessor`) dla pól, które nie powinny być ustawiane arbitralnie z zewnątrz, to dobra enkapsulacja — ujawnianie tylko dostępu, który zamierzasz.

## Dlaczego to ważne

Rozumienie `attr_accessor`/`attr_reader`/`attr_writer` jest fundamentalną, codzienną wiedzą o Ruby, ponieważ pojawiają się w prawie każdej klasie Ruby.

Podstawowy powód ich istnienia: zmienne instancji (`@name`) są **prywatne i niedostępne bezpośrednio** z zewnątrz obiektu, więc potrzebujesz metod dostępowych do ich odczytu lub zapisu — a pisanie tych getterów/setterów ręcznie dla każdego atrybutu to nudny boilerplate.

Te metody **generują dostępy automatycznie** (`attr_reader` dla dostępu tylko do odczytu, `attr_writer` dla dostępu tylko do zapisu, `attr_accessor` dla obu), zastępując kilka definicji metod jednym zwięźle wierszem — to cecha elegancji i zwięzłości Ruby.

Rozumienie tego, co każda generuje i **wybieranie odpowiedniej** to także kwestia dobrej **enkapsulacji**: użycie `attr_reader` (tylko do odczytu) dla pól, które nie powinny być arbitralnie ustawiane z zewnątrz, i `attr_accessor` tylko tam, gdzie dostęp do odczytu i zapisu jest faktycznie zamierzony, kontroluje jak stan obiektu jest ujawniany (np. saldo bankowe czytelne, ale zmieniane tylko poprzez kontrolowane metody).

Ponieważ te dostępy są wszechobecne w klasach Ruby (i modelach Rails), wiedza o tym, jak działają, co każda generuje i jak wybrać dla właściwej enkapsulacji, jest niezbędna, obowiązkowa wiedza do pisania i czytania klas Ruby — to jedno z pierwszych rzeczy, które spotykasz przy definiowaniu klas Ruby i odzwierciedla zwięzłe, wyraziste podejście języka do wspólnej potrzeby (kontrolowany dostęp do stanu obiektu).