attr_accessor, attr_reader आणि attr_writer हे काय करतात?

Question

Accepted Answer

हे Ruby methods आहेत जे **instance variables साठी getter आणि/किंवा setter methods स्वयंचलितपणे generate करतात** — boilerplate code दूर करून. Instance variables (`@name`) private असल्याने आणि बाहेरून थेट accessible नसल्याने, त्यांना read/write करण्यासाठी accessor methods आवश्यक आहेत, आणि `attr_*` हे concisely generate करते.

## समस्या जी ते सोडवतात

```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 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 करते — एक ओळ अनेक manual method definitions ची जागा घेते.

## योग्य निवडणे (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 अनियंत्रितपणे बाहेरून set केल्या जाऊ नयेत त्यांसाठी `attr_reader` (vs `attr_accessor`) निवडणे हे चांगले encapsulation आहे — केवळ आपल्या आशयाचे access expose करून.

## हे महत्वाचे का आहे

`attr_accessor`/`attr_reader`/`attr_writer` समजून घेणे हे मूलभूत दैनंदिन Ruby ज्ञान आहे, कारण ते जवळजवळ प्रत्येक Ruby class मध्ये दिसतात.

ते अस्तित्वात असण्याचे मुख्य कारण: instance variables (`@name`) **private असतात आणि object च्या बाहेरून थेट 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 ची जागा एका concise ओळीने घेतात — हे Ruby च्या elegance आणि conciseness चे वैशिष्ट्य आहे.

प्रत्येक कोणते generate करते हे समजून घेणे आणि **योग्य निवड करणे** हे चांगल्या **encapsulation** चे प्रश्न आहे: ज्या fields अनियंत्रितपणे बाहेरून set केल्या जाऊ नयेत त्यांसाठी `attr_reader` (read-only) वापरणे, आणि `attr_accessor` केवळ जिथे read-write access खरोखर आशयित असेल तिथे वापरणे, object च्या state कसे expose होते हे नियंत्रित करते (उदा. bank balance readable करणे परंतु नियंत्रित methods द्वारे केवळ बदलता येणे).

कारण हे accessors Ruby classes मध्ये (आणि Rails models मध्ये) सर्वव्यापी आहेत, त्यांचे काम कसे होते, प्रत्येक काय generate करते, आणि योग्य encapsulation साठी कसे निवड करायची हे जाणून घेणे हे अपरिहार्य, must-know ज्ञान आहे Ruby classes लिहिण्यासाठी आणि वाचण्यासाठी — जेव्हा Ruby classes परिभाषित करू तेव्हा हे प्रथम गोष्टींपैकी एक आहे आणि एका सामान्य गरजेच्या (object state मध्ये नियंत्रित access) साठी भाषेचा concise, expressive दृष्टिकोन प्रतिबिंबित करते.