attr_accessor, attr_reader na attr_writer hufanya nini?

Question

IT Interview Practice · Accepted Answer

Hizi ni methods za Ruby ambazo **huzalisha getter na/au setter methods kiotomatiki** kwa instance variables — zikiondoa boilerplate. Kwa kuwa instance variables (`@name`) ni private na hazifikiki moja kwa moja kutoka nje, unahitaji accessor methods kuzisoma/kuziandika, na `attr_*` huzalisha hizi kwa mfupi.

## Tatizo wanalotatua

```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
```

## Wazalishaji watatu wa 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 pekee (ufikiaji wa read-only).
- **`attr_writer`** → setter pekee (write-only).
- **`attr_accessor`** → getter na setter zote (read-write).

Kila moja huchukua symbols zinazotaja instance variables, na huzalisha methods husika kiotomatiki — mstari mmoja unachukua nafasi ya method definitions kadhaa za mkono.

## Kuchagua iliyo sahihi (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
```

Kuchagua `attr_reader` (badala ya `attr_accessor`) kwa fields ambazo hazipaswi kuwekwa kiholela kutoka nje ni encapsulation nzuri — ukiweka wazi ufikiaji unaonuia tu.

## Kwa nini ni muhimu

Kuelewa `attr_accessor`/`attr_reader`/`attr_writer` ni maarifa ya msingi ya kila siku ya Ruby, kwa kuwa zinajitokeza katika takriban kila class ya Ruby.

Sababu kuu wanapokuwepo: instance variables (`@name`) ni **private na hazifikiki moja kwa moja** kutoka nje ya object, hivyo unahitaji accessor methods kuzisoma au kuziandika — na kuandika getters/setters hizo kwa mkono kwa kila attribute ni boilerplate yenye uchovu.

Methods hizi **huzalisha accessors kiotomatiki** (`attr_reader` kwa read-only, `attr_writer` kwa write-only, `attr_accessor` kwa zote), zikibadilisha method definitions kadhaa kwa mstari mmoja mfupi — alama ya uvutio na ufupi wa Ruby.

Kuelewa kila moja huzalisha nini na **kuchagua iliyo sahihi** pia ni suala la **encapsulation** nzuri: kutumia `attr_reader` (read-only) kwa fields ambazo hazipaswi kuwekwa kiholela kutoka nje, na `attr_accessor` tu pale ambapo ufikiaji wa read-write umenuiwa kweli, hudhibiti jinsi hali ya object inavyowekwa wazi (k.m. kufanya balance ya benki isomeke lakini ibadilike tu kupitia controlled methods).

Kwa kuwa accessors hizi zimeenea katika classes za Ruby (na Rails models), kujua jinsi zinavyofanya kazi, kila moja inazalisha nini, na jinsi ya kuchagua kwa encapsulation ifaayo ni maarifa muhimu, ya lazima kujua kwa kuandika na kusoma classes za Ruby — ni mojawapo ya vitu vya kwanza unavyokutana navyo unapofafanua classes za Ruby na inaonyesha mbinu ya mfupi, yenye uwazi ya Ruby kwa hitaji la kawaida (ufikiaji unaodhibitiwa wa hali ya object).

Tatizo wanalotatua

Wazalishaji watatu wa accessor

Kuchagua iliyo sahihi (encapsulation)

Kwa nini ni muhimu

Maswali yanayohusiana