These are Ruby methods that automatically generate getter and/or setter methods for instance variables — eliminating boilerplate. Since instance variables (@name) are private and not directly accessible from outside, you need accessor methods to read/write them, and attr_* generates these concisely.
()
= 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 → getter only (read-only access).attr_writer → setter only (write-only).attr_accessor → both getter and setter (read-write).Each takes symbols naming the instance variables, and generates the corresponding methods automatically — one line replaces several manual method definitions.
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
Choosing attr_reader (vs attr_accessor) for fields that shouldn't be set arbitrarily from outside is good encapsulation — exposing only the access you intend.
Understanding attr_accessor/attr_reader/attr_writer is fundamental everyday Ruby knowledge, since they appear in nearly every Ruby class.
The core reason they exist: instance variables (@name) are private and not directly accessible from outside an object, so you need accessor methods to read or write them — and writing those getters/setters manually for every attribute is tedious boilerplate.
These methods generate the accessors automatically (attr_reader for read-only, attr_writer for write-only, attr_accessor for both), replacing several method definitions with a single concise line — a hallmark of Ruby's elegance and conciseness.
Understanding what each generates and choosing the appropriate one is also a matter of good encapsulation: using attr_reader (read-only) for fields that shouldn't be arbitrarily set from outside, and attr_accessor only where read-write access is genuinely intended, controls how an object's state is exposed (e.g. making a bank balance readable but only changeable through controlled methods).
Since these accessors are ubiquitous in Ruby classes (and Rails models), knowing how they work, what each generates, and how to choose for proper encapsulation is essential, must-know knowledge for writing and reading Ruby classes — it's one of the first things you encounter when defining Ruby classes and reflects the language's concise, expressive approach to a common need (controlled access to object state).