Hva gjør attr_accessor, attr_reader og attr_writer?

Question

Accepted Answer

Disse er Ruby-metoder som **automatisk genererer getter- og/eller setter-metoder** for instansvariabler — noe som eliminerer boilerplate-kode. Siden instansvariabler (`@name`) er private og ikke direkte tilgjengelige fra utsiden, trenger du accessor-metoder for å lese/skrive dem, og `attr_*` genererer disse kortfattet.

## Problemet de løser

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

## De tre accessor-generatorene

```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`** → getter kun (skrivebeskyttet tilgang).
- **`attr_writer`** → setter kun (skriv-kun).
- **`attr_accessor`** → både getter og setter (lese-skriv).

Hver av dem tar symboler som navngir instansvariablene, og genererer de tilsvarende metodene automatisk — én linje erstatter flere manuelle metodedefinísjoner.

## Velge riktig (innkapsling)

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

Å velge `attr_reader` (i stedet for `attr_accessor`) for felt som ikke skal settes vilkårlig fra utsiden er god innkapsling — du eksponerer bare den tilgangen du har til hensikt.

## Hvorfor det er viktig

Å forstå `attr_accessor`/`attr_reader`/`attr_writer` er grunnleggende, daglig Ruby-kunnskap, siden de vises i nesten hver Ruby-klasse.

Hovedgrunnen til at de eksisterer: instansvariabler (`@name`) er **private og ikke direkte tilgjengelige** fra utsiden av et objekt, så du trenger accessor-metoder for å lese eller skrive dem — og å skrive disse getterne/setterne manuelt for hver attributt er kjedelig boilerplate-kode.

Disse metodene **genererer accessorene automatisk** (`attr_reader` for skrivebeskyttet, `attr_writer` for skriv-kun, `attr_accessor` for begge), noe som erstatter flere metodedefinísjoner med en enkelt kortfattet linje — et kjennetegn på Rubys eleganse og kortfattethet.

Å forstå hva hver genererer og **velge den passende** er også et spørsmål om god **innkapsling**: bruk av `attr_reader` (skrivebeskyttet) for felt som ikke skal endres vilkårlig fra utsiden, og `attr_accessor` bare hvor lese-skriv-tilgang er genuint tiltenkt, kontrollerer hvordan et objekts tilstand eksponeres (for eksempel gjøre en banksaldo lesbar men bare kan endres gjennom kontrollerte metoder).

Siden disse accessorene er allestedsnærværende i Ruby-klasser (og Rails-modeller), er det essensielt, nødvendig kunnskap å vite hvordan de fungerer, hva hver genererer, og hvordan man velger for riktig innkapsling når man skriver og leser Ruby-klasser — det er en av de første tingene du møter når du definerer Ruby-klasser og gjenspeiler språkets kortfattede, ekspressive tilnærming til et vanlig behov (kontrollert tilgang til objekttilstand).