Vad gör attr_accessor, attr_reader och attr_writer?

Question

Accepted Answer

Dessa är Ruby-metoder som **automatiskt genererar getter- och/eller setter-metoder** för instansvariabler — vilket eliminerar boilerplate-kod. Eftersom instansvariabler (`@name`) är privata och inte direkt åtkomliga från utsidan, behöver du accessor-metoder för att läsa/skriva dem, och `attr_*` genererar dessa på ett koncist sätt.

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

```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`** → endast getter (skrivskyddad åtkomst).
- **`attr_writer`** → endast setter (skrivbar åtkomst).
- **`attr_accessor`** → både getter och setter (läs-skriv åtkomst).

Varje tar symboler som namnger instansvariablerna och genererar motsvarande metoder automatiskt — en rad ersätter flera manuella metoddefinitioner.

## Välja rätt (inkapsling)

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

Att välja `attr_reader` (istället för `attr_accessor`) för fält som inte bör sättas godtyckligt från utsidan är god inkapsling — du exponerar endast den åtkomst du avser.

## Varför det är viktigt

Att förstå `attr_accessor`/`attr_reader`/`attr_writer` är fundamental daglig Ruby-kunskap, eftersom de förekommer i nästan alla Ruby-klasser.

Huvudskälet till att de finns: instansvariabler (`@name`) är **privata och inte direkt åtkomliga** från utsidan ett objekt, så du behöver accessor-metoder för att läsa eller skriva dem — och att skriva dessa getters/setters manuellt för varje attribut är långtråkig boilerplate-kod.

Dessa metoder **genererar accessorerna automatiskt** (`attr_reader` för skrivskydd, `attr_writer` för enbart skrivbar, `attr_accessor` för båda), vilket ersätter flera metoddefinitioner med en enda koncis rad — en hallmark av Rubys elegans och koncishet.

Att förstå vad var och en genererar och **välja rätt** är också en fråga om god **inkapsling**: att använda `attr_reader` (skrivskydd) för fält som inte bör kunna ändras godtyckligt från utsidan, och `attr_accessor` endast där läs-skriv-åtkomst verkligen är avsedd, styr hur ett objekts tillstånd exponeras (t.ex. att göra ett bankkonto läsbart men bara ändringsbar genom kontrollerade metoder).

Eftersom dessa accessorer är överallt i Ruby-klasser (och Rails-modeller), är det essentiell, måste-kunna-kunskap att veta hur de fungerar, vad var och en genererar och hur man väljer för korrekt inkapsling — det är en av de första sakerna du stöter på när du definierar Ruby-klasser och återspeglar språkets koncisa, uttrycksfulla syn på ett vanligt behov (kontrollerad åtkomst till objekttillstånd).