Apakah yang dilakukan oleh attr_accessor, attr_reader dan attr_writer?

Question

Accepted Answer

Ini adalah kaedah Ruby yang **secara automatik menjana kaedah getter dan/atau setter** untuk pemboleh ubah instance — menghapuskan boilerplate. Memandangkan pemboleh ubah instance (`@name`) adalah peribadi dan tidak boleh diakses secara langsung dari luar, anda memerlukan kaedah accessor untuk membaca/menulisnya, dan `attr_*` menjana ini secara ringkas.

## Masalah yang ia 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 penjana accessor

```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 sahaja (akses baca-sahaja).
- **`attr_writer`** → setter sahaja (tulis-sahaja).
- **`attr_accessor`** → kedua-dua getter dan setter (baca-tulis).

Setiap satu mengambil symbol yang menamakan pemboleh ubah instance, dan menjana kaedah yang sepadan secara automatik — satu baris menggantikan beberapa takrifan kaedah manual.

## Memilih yang betul (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` (berbanding `attr_accessor`) untuk medan yang tidak sepatutnya ditetapkan sewenang-wenangnya dari luar adalah enkapsulasi yang baik — mendedahkan hanya akses yang anda niatkan.

## Mengapa ia penting

Memahami `attr_accessor`/`attr_reader`/`attr_writer` adalah pengetahuan Ruby asas harian, kerana ia muncul dalam hampir setiap kelas Ruby.

Sebab teras ia wujud: pemboleh ubah instance (`@name`) adalah **peribadi dan tidak boleh diakses secara langsung** dari luar objek, jadi anda memerlukan kaedah accessor untuk membaca atau menulisnya — dan menulis getter/setter tersebut secara manual untuk setiap atribut adalah boilerplate yang membosankan.

Kaedah ini **menjana accessor secara automatik** (`attr_reader` untuk baca-sahaja, `attr_writer` untuk tulis-sahaja, `attr_accessor` untuk kedua-duanya), menggantikan beberapa takrifan kaedah dengan satu baris ringkas — satu ciri khas keanggunan dan keringkasan Ruby.

Memahami apa yang dijana oleh setiap satu dan **memilih yang sesuai** juga adalah soal **enkapsulasi** yang baik: menggunakan `attr_reader` (baca-sahaja) untuk medan yang tidak sepatutnya ditetapkan sewenang-wenangnya dari luar, dan `attr_accessor` hanya di mana akses baca-tulis benar-benar diniatkan, mengawal bagaimana keadaan objek didedahkan (cth. menjadikan baki bank boleh dibaca tetapi hanya boleh diubah melalui kaedah terkawal).

Memandangkan accessor ini di mana-mana dalam kelas Ruby (dan model Rails), mengetahui cara ia berfungsi, apa yang dijana oleh setiap satu, dan cara memilih untuk enkapsulasi yang betul adalah pengetahuan yang penting dan mesti diketahui untuk menulis dan membaca kelas Ruby — ia adalah salah satu perkara pertama yang anda temui semasa mentakrifkan kelas Ruby dan mencerminkan pendekatan ringkas dan ekspresif bahasa ini kepada keperluan biasa (akses terkawal kepada keadaan objek).