attr_accessor, attr_reader અને attr_writer શું કરે છે?

Question

Accepted Answer

આ Ruby મેથડ્સ છે જે **આપોઆપ getter અને/અથવા setter મેથડ્સ બનાવે છે** ઇન્સ્ટન્સ વેરિયેબલ્સ માટે — બોઇલરપ્લેટ દૂર કરે છે. કારણ કે ઇન્સ્ટન્સ વેરિયેબલ્સ (`@name`) પ્રાઇવેટ છે અને બહારથી સીધા એક્સેસ કરી શકાતા નથી, તમને તેમને વાંચવા/લખવા માટે એક્સેસર મેથડ્સ જોઇએ છે, અને `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
```

## ત્રણ એક્સેસર જનરેટર્સ

```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 બંને (વાંચન-લેખન).

પ્રત્યેક ઇન્સ્ટન્સ વેરિયેબલ્સના નામ આપતા સંકેત લે છે, અને આપોઆપ અનુરૂપ મેથડ્સ બનાવે છે — એક લીટી ઘણી હાથથી લખેલી મેથડ વ્યાખ્યાઓને બદલે છે.

## યોગ્ય વ્યક્તિને પસંદ કરવું (એનકેપ્સુલેશન)

```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`) સારું એનકેપ્સુલેશન છે — ફક્ત તે એક્સેસ ખોલવાથી જે તમે માનો છો.

## શા માટે તે મહત્વપૂર્ણ છે

`attr_accessor`/`attr_reader`/`attr_writer` સમજવું Ruby નું મૂળ રોજનું જ્ઞાન છે, કારણ કે તે લગભગ દરેક Ruby ક્લાસમાં હાજર છે.

મૂલ કારણ તેઓ અસ્તિત્વમાં છે: ઇન્સ્ટન્સ વેરિયેબલ્સ (`@name`) **પ્રાઇવેટ છે અને બહારથી સીધા એક્સેસ કરી શકાતા નથી**, તેથી તમને તેમને વાંચવા અથવા લખવા માટે એક્સેસર મેથડ્સ જોઇએ છે — અને દરેક વિશેષતા માટે તે getters/setters હાથથી લખવું કંટાળાજનક બોઇલરપ્લેટ છે.

આ મેથડ્સ **એક્સેસર્સ આપોઆપ બનાવે છે** (`attr_reader` માટે પ્રાણ-માત્ર, `attr_writer` માટે લેખન-માત્ર, `attr_accessor` બંને માટે), એક સંક્ષિપ્ત લીટી સાથે ઘણી મેથડ વ્યાખ્યાઓને બદલીને — Ruby ની ઊંચાઈ અને સંક્ષિપ્તતાનું ચિહ્ન.

સમજવું કે દરેક શું બનાવે છે અને **યોગ્ય પસંદ કરવું** સારા **એનકેપ્સુલેશનનો** પણ બાબત છે: `attr_reader` (પ્રાણ-માત્ર) એવી ખેતરો માટે વાપરવું જે બહારથી મનમાણે સેટ કરવી જોઇએ નહીં, અને `attr_accessor` માત્ર જ્યાં વાંચન-લેખન એક્સેસ સાચવાણે માનો છો, નિયંત્રણ કરે છે કે ઑબ્જેક્ટની સ્થિતિ કેવી રીતે ખુલ્લી છે (દા.ત., બેંક બેલેન્સ પઠનીય બનાવવું પણ ફક્ત નિયંત્રિત મેથડ્સ દ્વારા બદલી શકાય).

હોવાથી આ એક્સેસર્સ Ruby ક્લાસેસ (અને Rails મોડલ્સ) માં સર્વવ્યાપી છે, તે જાણવું કે તેઓ કેવી રીતે કામ કરે છે, દરેક શું બનાવે છે, અને યોગ્ય એનકેપ્સુલેશન માટે કેવી રીતે પસંદ કરવું Ruby ક્લાસેસ લખવા અને વાંચવા માટે આવશ્યક, આવશ્યક જ્ઞાન છે — તે એક આવે છે પ્રથમ વસ્તુઓ જે તમે Ruby ક્લાસેસ વ્યાખ્યાયિત કરવાની બેળા મળો છો અને ભાષાના સંક્ષિપ્ત, અભિવ્યક્તિસમૃદ્ધ અભિગમને પ્રતિબિંબિત કરે છે એક સામાન્ય જરૂર માટે (ઑબ્જેક્ટ સ્થિતિ માટે નિયંત્રિત એક્સેસ).