Ce fac attr_accessor, attr_reader și attr_writer?

Question

Accepted Answer

Acestea sunt metode Ruby care **generează automat metode getter și/sau setter** pentru variabilele de instanță — eliminând codul repetitiv. Deoarece variabilele de instanță (`@name`) sunt private și nu sunt accesibile direct din exterior, ai nevoie de metode accessor pentru a le citi/scrie, iar `attr_*` le generează concis.

## Problema pe care o rezolvă

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

## Cei trei generatori de 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`** → doar getter (acces doar pentru citire).
- **`attr_writer`** → doar setter (acces doar pentru scriere).
- **`attr_accessor`** → atât getter cât și setter (acces pentru citire și scriere).

Fiecare primește simboluri care denumesc variabilele de instanță și generează automat metodele corespunzătoare — o singură linie înlocuiește mai multe definiții manuale de metode.

## Alegerea celei potrivite (encapsulare)

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

Alegerea `attr_reader` (în loc de `attr_accessor`) pentru câmpuri care nu ar trebui setate arbitrar din exterior este o bună encapsulare — expui doar accesul pe care-l intenționezi.

## De ce conteaza

Înțelegerea `attr_accessor`/`attr_reader`/`attr_writer` este o cunoștință Ruby fundamentală de zi cu zi, deoarece apar în aproape fiecare clasă Ruby.

Motivul esențial pentru care există: variabilele de instanță (`@name`) sunt **private și nu sunt accesibile direct** din exterior unui obiect, deci ai nevoie de metode accessor pentru a le citi sau scrie — și a rescrie manual acești getteri/setteri pentru fiecare atribut este cod repetitiv obositor.

Aceste metode **generează automat accesorii** (`attr_reader` pentru doar citire, `attr_writer` pentru doar scriere, `attr_accessor` pentru ambele), înlocuind mai multe definiții de metode cu o singură linie concisă — o caracteristică a eleganței și conciziei Ruby.

Înțelegerea ceea ce generează fiecare și **alegerea celei potrivite** este de asemenea o chestiune de bună **encapsulare**: folosind `attr_reader` (doar citire) pentru câmpuri care nu ar trebui setate arbitrar din exterior, și `attr_accessor` doar acolo unde accesul de citire-scriere este cu adevărat intenționat, controlezi cum este expusă starea unui obiect (de exemplu, făcând un sold bancar citibil dar modificabil doar prin metode controlate).

Deoarece acești accesorii sunt omniprezenți în clasele Ruby (și modelele Rails), cunoașterea modului în care funcționează, ceea ce generează fiecare și cum să alegi pentru o encapsulare corespunzătoare este esențiala, cunoștințe obligatorii pentru a scrie și citi clase Ruby — este una dintre primele lucruri pe care le întâlnești când definești clase Ruby și reflectă abordarea limbajului concisă și expresivă a unei nevoi comune (acces controlat la starea obiectului).