Kaj počneta attr_accessor, attr_reader in attr_writer?

Question

Accepted Answer

To so Ruby metode, ki **samodejno generirajo getter in/ali setter metode** za instance spremenljivke — pri čemer se izognete načrtnemu kodu. Ker so instance spremenljivke (`@name`) zasebne in niso dostopne neposredno od zunaj, potrebujete accessor metode za branje/pisanje v njih, in `attr_*` to generira na kratek način.

## Težava, ki jo rešujejo

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

## Trije generator accessorjev

```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`** → samo getter (dostop samo za branje).
- **`attr_writer`** → samo setter (dostop samo za pisanje).
- **`attr_accessor`** → getter in setter (dostop za branje in pisanje).

Vsaka sprejme simbole, ki poimenujejo instance spremenljivke, in samodejno generira ustrezne metode — ena vrstica nadomesti več ročnih definicij metod.

## Izbira prave metode (enkapsulacija)

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

Izbira `attr_reader` (namesto `attr_accessor`) za polja, ki jih ne bi smeli nastavljati poljubno od zunaj, je dobra enkapsulacija — izpostavite samo dostop, ki ga nameravate.

## Zakaj je to pomembno

Razumevanje `attr_accessor`/`attr_reader`/`attr_writer` je temeljno vsakdanje znanje o Ruby-ju, saj se pojavljajo v skoraj vsakem Ruby razredu.

Osnovni razlog, zakaj obstajajo: instance spremenljivke (`@name`) so **zasebne in niso dostopne neposredno** od zunaj objekta, zato potrebujete accessor metode za branje ali pisanje v njih — in ročno pisanje teh getter/setter metod za vsak atribut je dolgočasno in neelegantno.

Te metode **samodejno generirajo accessorje** (`attr_reader` za samo branje, `attr_writer` za samo pisanje, `attr_accessor` za oboje), pri čemer nadomestijo več definicij metod z eno samo kratko vrstico — to je značilnost Ruby-jevega elegantnemu in lakonskega pristopa.

Razumevanje, kaj vsaka generira, in **izbira ustrezne metode** je tudi stvar dobre **enkapsulacije**: uporaba `attr_reader` (samo branje) za polja, ki jih ne bi smeli poljubno spreminjati od zunaj, in `attr_accessor` samo tam, kjer je dostop za branje in pisanje res namenjen, nadzira način, kako je stanje objekta izpostavljeno (na primer, da je stanje bančnega računa berljivo, vendar ga je mogoče spreminjati samo preko nadzorovanih metod).

Ker so ti accessorji vseprisotni v Ruby razredih (in Rails modelih), je poznavanje njihovega delovanja, kaj vsaka generira, in kako izbrati za pravilno enkapsulacijo bistveno, nezogljivo znanje za pisanje in branje Ruby razredov — to je ena prvih stvari, na katero naletite pri definiranju Ruby razredov in odseva jezikovni jedrnati in izrazit pristop k pogosti potrebi (nadzorovani dostop do stanja objekta).