attr_accessor, attr_reader และ attr_writer ทำอะไร?

Question

Accepted Answer

เหล่านี้คือเมธอดของ Ruby ที่ **สร้างเมธอด getter และ/หรือ setter โดยอัตโนมัติ** สำหรับ instance variable เพื่อขจัดโค้ดซ้ำซ้อน เนื่องจาก instance variable (`@name`) เป็น private และเข้าถึงโดยตรงจากภายนอกไม่ได้ คุณจึงต้องมีเมธอด accessor เพื่ออ่าน/เขียนมัน และ `attr_*` สร้างเมธอดเหล่านี้ให้อย่างกระชับ

## ปัญหาที่มันแก้ไข

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

## ตัวสร้าง 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 เท่านั้น (เข้าถึงแบบอ่านอย่างเดียว)
- **`attr_writer`** → setter เท่านั้น (เขียนอย่างเดียว)
- **`attr_accessor`** → ทั้ง getter และ setter (อ่าน-เขียน)

แต่ละตัวรับซิมโบลที่ระบุชื่อ instance variable และสร้างเมธอดที่สอดคล้องโดยอัตโนมัติ หนึ่งบรรทัดแทนที่การนิยามเมธอดด้วยมือหลายตัว

## การเลือกตัวที่เหมาะสม (encapsulation)

```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` (แทน `attr_accessor`) สำหรับฟิลด์ที่ไม่ควรถูกตั้งค่าตามอำเภอใจจากภายนอก เป็น encapsulation ที่ดี โดยเปิดเผยเฉพาะการเข้าถึงที่คุณตั้งใจ

## ทำไมจึงสำคัญ

การเข้าใจ `attr_accessor`/`attr_reader`/`attr_writer` เป็นความรู้พื้นฐานของ Ruby ในชีวิตประจำวัน เนื่องจากมันปรากฏในแทบทุกคลาส Ruby

เหตุผลหลักที่มันมีอยู่: instance variable (`@name`) เป็น **private และเข้าถึงโดยตรงไม่ได้** จากภายนอกออบเจ็กต์ ดังนั้นคุณจึงต้องมีเมธอด accessor เพื่ออ่านหรือเขียนมัน และการเขียน getter/setter เหล่านั้นด้วยมือสำหรับทุกแอตทริบิวต์เป็นโค้ดซ้ำซ้อนที่น่าเบื่อ

เมธอดเหล่านี้ **สร้าง accessor โดยอัตโนมัติ** (`attr_reader` สำหรับอ่านอย่างเดียว, `attr_writer` สำหรับเขียนอย่างเดียว, `attr_accessor` สำหรับทั้งสอง) แทนที่การนิยามเมธอดหลายตัวด้วยบรรทัดเดียวอันกระชับ ซึ่งเป็นเอกลักษณ์ของความสง่างามและความกระชับของ Ruby

การเข้าใจว่าแต่ละตัวสร้างอะไร และ **การเลือกตัวที่เหมาะสม** ยังเป็นเรื่องของ **encapsulation** ที่ดี: การใช้ `attr_reader` (อ่านอย่างเดียว) สำหรับฟิลด์ที่ไม่ควรถูกตั้งค่าตามอำเภอใจจากภายนอก และใช้ `attr_accessor` เฉพาะที่ตั้งใจให้เข้าถึงแบบอ่าน-เขียนจริง ๆ ควบคุมว่าสถานะของออบเจ็กต์ถูกเปิดเผยอย่างไร (เช่น ทำให้ยอดเงินในบัญชีอ่านได้แต่เปลี่ยนแปลงได้เฉพาะผ่านเมธอดที่ควบคุม)

เนื่องจาก accessor เหล่านี้แพร่หลายในคลาส Ruby (และโมเดล Rails) การรู้ว่ามันทำงานอย่างไร แต่ละตัวสร้างอะไร และจะเลือกอย่างไรเพื่อ encapsulation ที่เหมาะสม เป็นความรู้ที่จำเป็นต้องรู้สำหรับการเขียนและอ่านคลาส Ruby เป็นหนึ่งในสิ่งแรก ๆ ที่คุณพบเมื่อนิยามคลาส Ruby และสะท้อนแนวทางที่กระชับและสื่อความหมายได้ดีของภาษานี้ต่อความต้องการที่พบบ่อย (การเข้าถึงสถานะของออบเจ็กต์อย่างมีการควบคุม)