Hvad gør attr_accessor, attr_reader og attr_writer?

Question

Accepted Answer

Disse er Ruby-metoder, der **automatisk genererer getter- og/eller setter-metoder** for instansvariable — og eliminerer dermed kedelig boilerplate-kode. Fordi instansvariable (`@name`) er private og ikke direkte tilgængelige udefra, skal du bruge accessor-metoder til at læse/skrive dem, og `attr_*` genererer disse på en kortfattet måde.

## 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-generatorer

```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`** → kun getter (skrivebeskyttet adgang).
- **`attr_writer`** → kun setter (skrivebeskyttet).
- **`attr_accessor`** → både getter og setter (læse-skrive).

Hver enkelt tager symboler, der navngiver instansvariablene, og genererer de tilsvarende metoder automatisk — én linje erstatter flere manuelle metodedefinitioner.

## At vælge den rigtige (indkapsling)

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

At vælge `attr_reader` (i stedet for `attr_accessor`) til felter, der ikke bør sættes vilkårligt udefra, er god indkapsling — du eksponerer kun den adgang, du har til hensigt.

## Hvorfor det betyder noget

At forstå `attr_accessor`/`attr_reader`/`attr_writer` er fundamental hverdags-Ruby-viden, da de optræder i næsten enhver Ruby-klasse.

Hovedgrunden til, at de eksisterer: instansvariable (`@name`) er **private og ikke direkte tilgængelige** udefra et objekt, så du har brug for accessor-metoder til at læse eller skrive dem — og at skrive disse getters/setters manuelt for hver attribut er kedelig boilerplate-kode.

Disse metoder **genererer accessorerne automatisk** (`attr_reader` for skrivebeskyttet, `attr_writer` for read-only, `attr_accessor` for begge), og erstatter flere metodedefinitioner med en enkelt kortfattet linje — et kendetegn på Rubys elegance og kortfattethed.

At forstå, hvad hver enkelt genererer, og **at vælge den passende en** er også et spørgsmål om god **indkapsling**: at bruge `attr_reader` (skrivebeskyttet) til felter, der ikke bør ændres vilkårligt udefra, og `attr_accessor` kun hvor læse-skrive-adgang virkelig er beregnet, kontrollerer, hvordan et objekts tilstand eksponeres (f.eks. at gøre en bankbalance læsbar, men kun ændringsbar gennem kontrollerede metoder).

Da disse accessorer er allestedsnærværende i Ruby-klasser (og Rails-modeller), er det afgørende viden at kende, hvordan de virker, hvad hver enkelt genererer, og hvordan man vælger for korrekt indkapsling — det er en af de første ting, du møder, når du definerer Ruby-klasser, og det afspejler sprogets kortfattede, udtryksfulde tilgang til et almindeligt behov (kontrolleret adgang til objekt-tilstand).