attr_accessor, attr_reader ਅਤੇ attr_writer ਕੀ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

ਇਹ Ruby ਦੇ methods ਹਨ ਜੋ **instance variables ਲਈ getter ਅਤੇ/ਜਾਂ setter methods ਨੂੰ ਸਵਚਲਿਤ ਤਰੀਕੇ ਨਾਲ ਬਣਾਉਂਦੇ ਹਨ** — boilerplate ਨੂੰ ਖ਼ਤਮ ਕਰਦੇ ਹਨ। ਕਿਉਂਕਿ instance variables (`@name`) private ਹਨ ਅਤੇ ਬਾਹਰ ਤੋਂ ਸਿੱਧੇ ਤੌਰ 'ਤੇ accessible ਨਹੀਂ ਹਨ, ਤੁਹਾਨੂੰ ਉਨ੍ਹਾਂ ਨੂੰ ਪੜ੍ਹਨ/ਲਿਖਣ ਲਈ accessor methods ਦੀ ਲੋੜ ਹੈ, ਅਤੇ `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 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 ਨੂੰ ਸਵਚਲਿਤ ਤਰੀਕੇ ਨਾਲ ਬਣਾਉਂਦਾ ਹੈ — ਇੱਕ ਲਾਈਨ ਕਈ 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
```

`attr_reader` ਨੂੰ ਚੁਣਨਾ (vs `attr_accessor`) ਉਹਨਾਂ fields ਲਈ ਜੋ ਬਾਹਰ ਤੋਂ ਮਨਮਾਨੇ ਢੰਗ ਨਾਲ ਸੈਟ ਨਹੀਂ ਹੋਣੀ ਚਾਹੀਦੀ, ਚੰਗਾ encapsulation ਹੈ — ਸਿਰਫ਼ ਅਜਿਹੀ access ਨੂੰ expose ਕਰਦੇ ਹਨ ਜਿਸ ਦਾ ਤੁਹਾਡਾ ਇਰਾਦਾ ਹੈ।

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

`attr_accessor`/`attr_reader`/`attr_writer` ਨੂੰ ਸਮਝਣਾ ਬੁਨਿਆਦੀ ਰੋਜ਼ਾਨਾ Ruby ਗਿਆਨ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਲਗਭਗ ਹਰ Ruby ਕਲਾਸ ਵਿੱਚ ਮਿਲਦਾ ਹੈ।

ਮੁੱਖ ਕਾਰਣ ਕਿ ਉਹ ਮੌਜੂਦ ਹਨ: instance variables (`@name`) **private ਹਨ ਅਤੇ object ਤੋਂ ਬਾਹਰ ਤੋਂ ਸਿੱਧੇ ਤੌਰ 'ਤੇ accessible ਨਹੀਂ ਹਨ**, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਉਨ੍ਹਾਂ ਨੂੰ ਪੜ੍ਹਨ ਜਾਂ ਲਿਖਣ ਲਈ accessor methods ਦੀ ਲੋੜ ਹੈ — ਅਤੇ ਹਰ attribute ਲਈ ਮੈਨੁਅਲ ਤਰੀਕੇ ਨਾਲ getters/setters ਲਿਖਣਾ tedious boilerplate ਹੈ।

ਇਹ methods **accessors ਨੂੰ ਸਵਚਲਿਤ ਤਰੀਕੇ ਨਾਲ ਬਣਾਉਂਦੇ ਹਨ** (`attr_reader` read-only ਲਈ, `attr_writer` write-only ਲਈ, `attr_accessor` ਦੋਵਿਆਂ ਲਈ), ਕਈ method definitions ਨੂੰ ਇੱਕ ਸੰਖੇਪ ਲਾਈਨ ਨਾਲ ਬਦਲ ਦਿੰਦੇ ਹਨ — Ruby ਦੀ elegance ਅਤੇ conciseness ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ।
aph ਹਰ ਇੱਕ ਕੀ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ **ਢੁਕਵੀਂ ਨੂੰ ਚੁਣਨਾ** ਭਾਲ ਕਰਨਾ ਵੀ ਚੰਗੇ **encapsulation** ਦਾ ਮਾਮਲਾ ਹੈ: `attr_reader` (read-only) ਨੂੰ ਉਹਨਾਂ fields ਲਈ ਵਰਤਣਾ ਜੋ ਬਾਹਰ ਤੋਂ ਮਨਮਾਨੇ ਢੰਗ ਨਾਲ ਸੈਟ ਨਹੀਂ ਹੋਣੀ ਚਾਹੀਦੀ, ਅਤੇ `attr_accessor` ਸਿਰਫ਼ ਜਿੱਥੇ read-write access ਸੱਚੀ ਤਰ੍ਹਾਂ ਤੋਂ ਇਰਾਦਾ ਹੈ, ਇੱਕ object ਦੀ state ਕਿਵੇਂ expose ਹੈ ਇਸ ਨੂੰ ਕੰਟਰੋਲ ਕਰਦਾ ਹੈ (ਜਿਵੇਂ ਬੈਂਕ ਬੈਲੈਂਸ ਨੂੰ readable ਲੇਕਿਨ ਸਿਰਫ਼ controlled methods ਦੁਆਰਾ changeable ਬਣਾਉਣਾ)।

ਕਿਉਂਕਿ ਇਹ accessors Ruby ਕਲਾਸਾਂ (ਅਤੇ Rails models) ਵਿੱਚ ubiquitous ਹਨ, ਕਿਵੇਂ ਕਾਮ ਕਰਦੇ ਹਨ, ਹਰ ਇੱਕ ਕੀ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ ਚੰਗੇ encapsulation ਲਈ ਕਿਵੇਂ ਚੁਣਿਆ ਜਾਵੇ ਇਹ ਜਾਣਨਾ ਜ਼ਰੂਰੀ, must-know ਗਿਆਨ ਹੈ Ruby classes ਨੂੰ ਲਿਖਣ ਅਤੇ ਪੜ੍ਹਣ ਲਈ — ਇਹ ਸਭ ਕੁਝ ਹੈ ਜੋ ਤੁਸੀਂ ਪਹਿਲੀ ਵਾਰ ਆਉਂਦਾ ਹੈ Ruby classes ਨੂੰ define ਕਰਦੇ ਸਮੇਂ ਅਤੇ language ਦੀ concise, expressive approach ਨੂੰ ਇੱਕ common need ਲਈ reflect ਕਰਦਾ ਹੈ (object state ਨੂੰ controlled access)।