attr_accessor, attr_reader और attr_writer क्या करते हैं?

Question

Accepted Answer

ये Ruby methods हैं जो instance variables के लिए **स्वचालित रूप से getter और/या setter methods generate करते हैं** — boilerplate को समाप्त करते हुए। चूँकि instance variables (`@name`) private हैं और बाहर से सीधे accessible नहीं हैं, आपको उन्हें read/write करने के लिए accessor methods की आवश्यकता होती है, और `attr_*` इन्हें संक्षिप्त रूप से generate करता है।

## The problem they solve

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

## The three accessor generators

```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 (read-only access)।
- **`attr_writer`** → केवल setter (write-only)।
- **`attr_accessor`** → getter और setter दोनों (read-write)।

प्रत्येक instance variables को नाम देने वाले symbols लेता है, और संबंधित methods को स्वचालित रूप से generate करता है — एक line कई manual method definitions की जगह लेती है।

## Choosing the right one (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
```

उन fields के लिए `attr_reader` चुनना (बनाम `attr_accessor`) जिन्हें बाहर से मनमाने ढंग से set नहीं किया जाना चाहिए, अच्छा encapsulation है — केवल वह access उजागर करना जो आप चाहते हैं।

## यह क्यों महत्वपूर्ण है

`attr_accessor`/`attr_reader`/`attr_writer` को समझना मूलभूत रोज़मर्रा का Ruby ज्ञान है, क्योंकि वे लगभग हर Ruby class में आते हैं।

वे क्यों मौजूद हैं इसका मूल कारण: instance variables (`@name`) किसी object के बाहर से **private और सीधे accessible नहीं** हैं, इसलिए आपको उन्हें read या write करने के लिए accessor methods की आवश्यकता होती है — और हर attribute के लिए उन getters/setters को manually लिखना थकाऊ boilerplate है।

ये methods **accessors को स्वचालित रूप से generate करते हैं** (`attr_reader` read-only के लिए, `attr_writer` write-only के लिए, `attr_accessor` दोनों के लिए), कई method definitions को एक संक्षिप्त line से बदलते हुए — Ruby की elegance और संक्षिप्तता की एक पहचान।

प्रत्येक क्या generate करता है यह समझना और **उपयुक्त को चुनना** अच्छे **encapsulation** का भी मामला है: उन fields के लिए `attr_reader` (read-only) का उपयोग करना जिन्हें बाहर से मनमाने ढंग से set नहीं किया जाना चाहिए, और `attr_accessor` केवल वहाँ जहाँ read-write access वास्तव में अभीष्ट है, नियंत्रित करता है कि किसी object की state कैसे उजागर होती है (जैसे एक bank balance को readable बनाना लेकिन केवल नियंत्रित methods के माध्यम से बदलने योग्य)।

चूँकि ये accessors Ruby classes (और Rails models) में सर्वव्यापी हैं, यह जानना कि वे कैसे काम करते हैं, प्रत्येक क्या generate करता है, और उचित encapsulation के लिए कैसे चुनें, Ruby classes लिखने और पढ़ने के लिए आवश्यक, अवश्य-जानने योग्य ज्ञान है — यह उन पहली चीज़ों में से एक है जिनका आप Ruby classes define करते समय सामना करते हैं और एक आम आवश्यकता (object state तक नियंत्रित access) के लिए language के संक्षिप्त, अभिव्यंजक दृष्टिकोण को दर्शाता है।