Apa yang dilakukan oleh attr_accessor, attr_reader, dan attr_writer?

Question

IT Interview Practice · Accepted Answer

Ini adalah method Ruby yang **secara otomatis menghasilkan method getter dan/atau setter** untuk variabel instance — menghilangkan boilerplate. Karena variabel instance (`@name`) bersifat private dan tidak dapat diakses langsung dari luar, Anda memerlukan method accessor untuk membaca/menulis mereka, dan `attr_*` menghasilkan ini dengan singkat.

## Masalah yang mereka selesaikan

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

## Tiga accessor generator

```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 saja (akses read-only).
- **`attr_writer`** → setter saja (akses write-only).
- **`attr_accessor`** → keduanya getter dan setter (akses read-write).

Masing-masing mengambil symbol yang menamakan variabel instance, dan menghasilkan method yang sesuai secara otomatis — satu baris menggantikan beberapa definisi method manual.

## Memilih yang tepat (enkapsulasi)

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

Memilih `attr_reader` (vs `attr_accessor`) untuk field yang tidak seharusnya diatur sembarangan dari luar adalah enkapsulasi yang baik — mengekspos hanya akses yang Anda maksudkan.

## Mengapa ini penting

Memahami `attr_accessor`/`attr_reader`/`attr_writer` adalah pengetahuan Ruby dasar yang fundamental, karena mereka muncul di hampir setiap class Ruby.

Alasan inti keberadaan mereka: variabel instance (`@name`) bersifat **private dan tidak dapat diakses langsung** dari luar object, jadi Anda memerlukan method accessor untuk membaca atau menulis mereka — dan menulis getter/setter tersebut secara manual untuk setiap atribut adalah boilerplate yang membosankan.

Method ini **menghasilkan accessor secara otomatis** (`attr_reader` untuk read-only, `attr_writer` untuk write-only, `attr_accessor` untuk keduanya), menggantikan beberapa definisi method dengan satu baris yang singkat — sebuah ciri khas keanggunan dan kesederhanaan Ruby.

Memahami apa yang setiap method hasilkan dan **memilih yang sesuai** juga merupakan masalah **enkapsulasi yang baik**: menggunakan `attr_reader` (read-only) untuk field yang tidak seharusnya diubah sembarangan dari luar, dan `attr_accessor` hanya di mana akses read-write benar-benar dimaksudkan, mengontrol cara state object diekspos (misalnya membuat saldo bank dapat dibaca tetapi hanya dapat diubah melalui method yang dikontrol).

Karena accessor ini ada di mana-mana dalam class Ruby (dan Rails model), mengetahui cara kerjanya, apa yang setiap method hasilkan, dan cara memilih untuk enkapsulasi yang tepat adalah pengetahuan penting yang harus diketahui untuk menulis dan membaca class Ruby — ini adalah salah satu hal pertama yang Anda temui saat mendefinisikan class Ruby dan mencerminkan pendekatan bahasa yang ringkas dan ekspresif terhadap kebutuhan umum (akses terkontrol ke state object).

Masalah yang mereka selesaikan

Tiga accessor generator

Memilih yang tepat (enkapsulasi)

Mengapa ini penting

Pertanyaan terkait