attr_accessor, attr_reader மற்றும் attr_writer என்பவை என்ன செய்கின்றன?

Question

Accepted Answer

இவை Ruby முறைகள் ஆகும், இவை **instance variables க்கு getter மற்றும்/அல்லது setter முறைகளை தானாகவே உருவாக்குகின்றன** — boilerplate ஐ நீக்குகின்றன. Instance variables (`@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 variables பெயரிடும் symbols எடுத்துக்கொள்கிறது, மற்றும் தொடர்புடைய முறைகளை தானாகவே உருவாக்குகிறது — ஒரு வரி பல manual முறை வரையறைகளை மாற்றுகிறது.

## சரியான ஒன்றைத் தேர்ந்தெடுப்பது (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` (vs `attr_accessor`) வெளியிலிருந்து தன்னிச்சையாக அமைக்கக் கூடாத fields க்கு தேர்ந்தெடுப்பது நல்ல encapsulation ஆகும் — நீங்கள் நோக்கம் கொண்ட அணுகலை மட்டுமே வெளிக்கொணர்கிறீர்கள்.

## இது ஏன் முக்கியம்

`attr_accessor`/`attr_reader`/`attr_writer` ஐ புரிந்துகொள்வது அடிப்படை அன்றாட Ruby அறிவு ஆகும், ஏனெனில் அவை கிட்டத்தட்ட ஒவ்வொரு Ruby வகுப்பிலும் தோன்றுகின்றன.

அவை இருப்பதற்கான முக்கிய காரணம்: instance variables (`@name`) **private ஆகும் மற்றும் object வெளியிலிருந்து நேரடியாக அணுக முடியாது**, எனவே நீங்கள் அவற்றை படிக்க அல்லது எழுத accessor முறைகள் தேவை — மற்றும் ஒவ்வொரு attribute க்கும் அந்த getters/setters ஐ manual ஆக எழுதுவது tedious boilerplate ஆகும்.

இந்த முறைகள் **accessor களை தானாகவே உருவாக்குகின்றன** (`attr_reader` படிக்க மட்டுமே, `attr_writer` எழுத மட்டுமே, `attr_accessor` இரண்டுக்குமே), பல முறை வரையறைகளை ஒரு சுருக்கமான வரிய்ுடன் மாற்றுகின்றன — Ruby இன் elegance மற்றும் conciseness இன் ஒரு hallmark.

ஒவ்வொன்று என்ன உருவாக்குகிறது என்பதை புரிந்துகொள்வது மற்றும் **பொருத்தமான ஒன்றைத் தேர்ந்தெடுப்பது** நல்ல **encapsulation** இன் விடயம் ஆகும்: வெளியிலிருந்து தன்னிச்சையாக அமைக்கக் கூடாத fields க்கு `attr_reader` (படிக்க மட்டுமே) பயன்படுத்துவது, மற்றும் `attr_accessor` படிக்க-எழுத அணுகல் உண்மையாக நோக்கம் கொண்ட இடங்களில் மட்டுமே, object வன்மை எவ்வாறு வெளிக்கொணரப்படுகிறது என்பதை கட்டுப்படுத்துகிறது (எ.கா. ஒரு வங்கி balance படிக்கக் கூடியதாக ஆனால் controlled முறைகளின் மூலமாக மட்டுமே மாற்ற முடியும்).

இந்த accessors Ruby வகுப்புகளில் (மற்றும் Rails models) எங்கும் உள்ளன என்பதால், அவை எவ்வாறு செயல்படுகின்றன, ஒவ்வொன்று என்ன உருவாக்குகிறது, மற்றும் சரியான encapsulation க்கு எவ்வாறு தேர்ந்தெடுப்பது என்பதை தெரிந்துகொள்வது essential, must-know அறிவு ஆகும் Ruby வகுப்புகளை எழுத மற்றும் படிக்க — இது Ruby வகுப்புகளை வரையறுக்கும் போது நீங்கள் முதலில் சந்திக்கும் விஷயங்களிலொன்றாகும் மற்றும் ஒரு பொதுவான தேவையை (object state இன் controlled அணுகல்) common need க்கு மொழியின் concise, expressive அணுகுமுறையை பிரதிபலிக்கிறது.