Mitä attr_accessor, attr_reader ja attr_writer tekevät?

Question

IT Interview Practice · Accepted Answer

Nämä ovat Ruby-metodeja, jotka **automaattisesti luovat getter- ja/tai setter-metodeja** instanssimuuttujille — eliminoiden boilerplate-koodin. Koska instanssimuuttujat (`@name`) ovat yksityisiä ja eivät ole suoraan saavutettavissa ulkopuolelta, tarvitset accessor-metodeja niiden lukemiseen ja kirjoittamiseen, ja `attr_*` luo nämä ytimekkäästi.

## Ongelma, jonka ne ratkaisevat

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

## Kolme accessor-generaattoria

```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`** → vain getter (vain luku -oikeudet).
- **`attr_writer`** → vain setter (vain kirjoitus).
- **`attr_accessor`** → sekä getter että setter (luku-kirjoitus).

Jokainen ottaa symboleja instanssimuuttujien nimiksi ja luo vastaavat metodit automaattisesti — yksi rivi korvaa useita manuaalisia metodimääritelmiä.

## Oikean valinnan tekeminen (kapselointi)

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

`attr_reader` valitseminen (vs `attr_accessor`) kentille, joita ei pitäisi asettaa mielivaltaisesti ulkopuolelta, on hyvää kapsélointia — se paljastaa vain tarkoitetun pääsyn.

## Miksi se on tärkeää

Ymmärrys `attr_accessor`/`attr_reader`/`attr_writer`-metodeista on perustava päivittäisen Ruby-osaamisen osa, koska ne esiintyvät lähes jokaisessa Ruby-luokassa.

Ydinraja niille olemassaololle: instanssimuuttujat (`@name`) ovat **yksityisiä ja eivät ole suoraan saavutettavissa** objektin ulkopuolelta, joten tarvitset accessor-metodeja niiden lukemiseen tai kirjoittamiseen — ja näiden getter- ja setter-metodien kirjoittaminen manuaalisesti jokaisen attribuutin kohdalta on tylsää boilerplate-koodia.

Nämä metodit **luovat accessor-metodit automaattisesti** (`attr_reader` vain-lukemista varten, `attr_writer` vain-kirjoitusta varten, `attr_accessor` molempiin), korvaten useita metodimääritelmiä yhdellä ytimekällä rivillä — Ruby:n tyylikkyyden ja ytimekkyden hallinto.

Ymmärrys siitä, mitä kukin luoo ja **oikean valinnan tekeminen** on myös **kapsäloinnin** asia: käyttämällä `attr_reader`-ia (vain-lukeminen) kentille, joita ei pitäisi mielivaltaisesti asettaa ulkopuolelta, ja `attr_accessor`-ia vain silloin, kun luku-kirjoitus -pääsy on todella tarkoitettu, hallitaan objektin tilan paljastamista (esim. pankkitilin saldon lukemisen salliminen mutta muutoksen vain kontrolloitujen metodien kautta).

Koska nämä accessor-metodit ovat kaikkialla Ruby-luokissa (ja Rails-malleissa), niiden toiminnan ymmärtäminen, mitä kukin luoo, ja valinta oikealle kapsäloinnille on olennaista, pakollista tietoa Ruby-luokkien kirjoittamiselle ja lukemiselle — se on yksi ensimmäisistä asioista, joita kohtaat Ruby-luokkien määrittelyssä ja kuvastaa kielen ytimekästä, ilmaisevaa lähestymistapaa yleiseen tarpeeseen (kontrolloitu pääsy objektin tilaan).

Ongelma, jonka ne ratkaisevat

Kolme accessor-generaattoria

Oikean valinnan tekeminen (kapselointi)

Miksi se on tärkeää

Aiheeseen liittyvät kysymykset