Estos son métodos de Ruby que generan automáticamente métodos getter y/o setter para variables de instancia — eliminando código repetitivo. Dado que las variables de instancia (@name) son privadas y no están directamente accesibles desde fuera, necesitas métodos de acceso para leer/escribir en ellas, y attr_* genera estos de forma concisa.
()
= name
()
= value
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 → solo getter (acceso de solo lectura).attr_writer → solo setter (acceso de solo escritura).attr_accessor → ambos, getter y setter (lectura-escritura).Cada uno toma símbolos que nombran las variables de instancia y genera los métodos correspondientes automáticamente — una línea reemplaza varias definiciones de métodos manuales.
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
Elegir attr_reader (en lugar de attr_accessor) para campos que no deberían ser modificados arbitrariamente desde fuera es buena encapsulación — exponiendo solo el acceso que pretendes.
Entender attr_accessor/attr_reader/attr_writer es conocimiento fundamental cotidiano de Ruby, ya que aparecen en casi todas las clases de Ruby.
La razón principal de su existencia: las variables de instancia (@name) son privadas y no están directamente accesibles desde fuera de un objeto, por lo que necesitas métodos de acceso para leer o escribir en ellas — y escribir esos getters/setters manualmente para cada atributo es código repetitivo tedioso.
Estos métodos generan los accesadores automáticamente (attr_reader para solo lectura, attr_writer para solo escritura, attr_accessor para ambos), reemplazando varias definiciones de métodos con una única línea concisa — un distintivo de la elegancia y concisión de Ruby.
Entender qué genera cada uno y elegir el apropiado también es una cuestión de buena encapsulación: usar attr_reader (solo lectura) para campos que no deberían ser arbitrariamente modificados desde fuera, y attr_accessor solo donde el acceso de lectura-escritura es genuinamente pretendido, controla cómo se expone el estado de un objeto (por ejemplo, hacer un saldo bancario legible pero solo modificable a través de métodos controlados).
Ya que estos accesadores son omnipresentes en clases de Ruby (y modelos de Rails), saber cómo funcionan, qué genera cada uno, y cómo elegir para la encapsulación adecuada es esencial, conocimiento imprescindible para escribir y leer clases de Ruby — es una de las primeras cosas que encuentras al definir clases de Ruby y refleja el enfoque conciso y expresivo del lenguaje hacia una necesidad común (acceso controlado al estado de un objeto).