attr_accessor, attr_reader మరియు attr_writer ఏమి చేస్తాయి?

Question

Accepted Answer

ఇవి Ruby పద్ధతులు, ఇవి **ఇన్‍స్టెన్స్ వేరియబుల్‍ల కోసం getter మరియు/లేదా setter పద్ధతులను స్వయంచాలకంగా ఉత్పత్తి చేస్తాయి** — బాయిలర్‍ప్లేట్‌ను తొలగిస్తాయి. ఇన్‍స్టెన్స్ వేరియబుల్‍లు (`@name`) ప్రైవేట్ మరియు బాహ్యంగా నేరుగా యాక్సెస్‌కు అందుబాటులో లేనందున, వాటిని చదవడానికి/రాయడానికి 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 మాత్రమే (read-only యాక్సెస్).
- **`attr_writer`** → setter మాత్రమే (write-only).
- **`attr_accessor`** → getter మరియు setter రెండూ (read-write).

ప్రతిదీ ఇన్‍స్టెన్స్ వేరియబుల్‍లకు పేరు పెట్టే చిహ్నాలను తీసుకుంటుంది మరియు సంబంధిత పద్ధతులను స్వయంచాలకంగా ఉత్పత్తి చేస్తుంది — ఒక పంక్తి అనేక మానవిక పద్ధతి నిర్వచనాలను భర్తీ చేస్తుంది.

## సరైనదాన్ని ఎంచుకోవడం (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 క్లాస్‌లో కనిపిస్తాయి.

వారు ఉనికిలో ఉన్న ప్రధాన కారణం: ఇన్‍స్టెన్స్ వేరియబుల్‍లు (`@name`) **ప్రైవేట్ మరియు బాహ్యంగా నేరుగా యాక్సెస్‌కు అందుబాటులో లేనివి**, కాబట్టి వాటిని చదవడానికి లేదా రాయడానికి accessor పద్ధతులు అవసరం — ప్రతి attribute కోసం ఆ getters/setters నిర్వచనలను చేసుకోవడం విసుగుకరమైన బాయిలర్‍ప్లేట్.

ఈ పద్ధతులు **accessor లను స్వయంచాలకంగా ఉత్పత్తి చేస్తాయి** (`attr_reader` read-only కోసం, `attr_writer` write-only కోసం, `attr_accessor` రెండింటి కోసం), అనేక పద్ధతి నిర్వచనాలను ఒక సంక్షిప్త పంక్తితో భర్తీ చేస్తుంది — Ruby యొక్క సొభinitiative మరియు సంక్షిప్తతకు లక్షణం.

ప్రతిదీ ఏమి ఉత్పత్తి చేస్తుందో అర్థం చేసుకోవడం మరియు సరైనదాన్ని **ఎంచుకోవడం** కూడా మంచి **encapsulation** విషయం: బాహ్యం నుండి ఏకపక్షంగా సెట్ చేయకూడని ఫీల్డ్‍ల కోసం `attr_reader` (read-only) ఉపయోగించడం, మరియు `attr_accessor` చదవడం-రాయడం యాక్సెస్ నిజమైనదిగా ఉద్దేశించినచోటు మాత్రమే, ఒక వస్తువు యొక్క స్థితి ఎలా బహిర్గతమైనది (ఉదా. బ్యాంక్ బ్యాలెన్స్‌ను చదవదగినది కానీ నియంత్రిత పద్ధతుల ద్వారా మాత్రమే మార్చదగినది) నియంత్రిస్తుంది.

ఈ accessors Ruby క్లాస్‍లలో (మరియు Rails మోడల్‍లలో) సర్వవ్యాప్తమైనవి కాబట్టి, అవి ఎలా పని చేస్తాయో, ప్రతిదీ ఏమి ఉత్పత్తి చేస్తుందో, మరియు సరైన encapsulation కోసం ఎలా ఎంచుకోవాలో తెలుసుకోవడం Ruby క్లాస్‍లను రాయడం మరియు చదవడం కోసం అవసరమైన, తప్పనిసరిగా తెలుసుకోవలసిన జ్ఞానం — Ruby క్లాస్‍లను నిర్వచించినప్పుడు మీరు మొదటిసారిగా ఎదుర్కొన్న విషయాలలో ఇది ఒకటి మరియు సాధారణ అవసరం (వస్తువు స్థితిలో నియంత్రిత యాక్సెస్) కు భాషయ యొక్క సంక్షిప్త, వ్యక్తీకరణీయ విధానాన్ని ప్రతిబింబిస్తుంది.