Attr_reader, attr_writer, attr_accessor in Ruby - Step-by-Step Execution

Concept Flow - Attr_reader, attr_writer, attr_accessor

Define class with attr_*

↓

Create object instance

↓

Access or modify attribute

↓

attr_reader

↓

Read value

↓

attr_accessor

↓

Read and write value

This flow shows how Ruby's attr_reader, attr_writer, and attr_accessor create methods to read, write, or both read and write object attributes.

Execution Sample

Ruby

class Person
  attr_reader :name
  attr_writer :age
  attr_accessor :city
end

p = Person.new
p.city = "NY"

Defines a Person class with different attribute accessors and sets the city attribute.

Execution Table

Step	Action	Attribute	Method Created	Operation	Result/Value
1	Define attr_reader :name	name	def name; @name; end	Read	Method to get @name created
2	Define attr_writer :age	age	def age=(val); @age = val; end	Write	Method to set @age created
3	Define attr_accessor :city	city	def city; @city; end and def city=(val); @city = val; end	Read & Write	Methods to get and set @city created
4	Create Person instance	-	-	-	Object p created
5	Set p.city = "NY"	city	city= method called	Write	@city set to "NY"
6	Try to read p.name	name	name method called	Read	Returns nil (not set)
7	Try to set p.age = 30	age	age= method called	Write	@age set to 30
8	Try to read p.age	age	No method created	Read	Error: undefined method 'age'
9	Try to read p.city	city	city method called	Read	Returns "NY"

💡 Execution stops after demonstrating read/write methods created and used for attributes.

Variable Tracker

Variable	Start	After Step 5	After Step 7	After Step 9
@name	nil	nil	nil	nil
@age	nil	nil	30	30
@city	nil	"NY"	"NY"	"NY"

Key Moments - 3 Insights

Why can we read p.name but not p.age?

Because attr_reader creates a method to read @name (see step 1 and 6), but attr_writer only creates a method to write @age (step 2 and 7). There is no method to read @age, so reading it causes an error (step 8).

What does attr_accessor do differently?

attr_accessor creates both read and write methods for the attribute (step 3). So for :city, we can both read and write its value (steps 5 and 9).

Why does p.city return "NY" after setting it?

Because attr_accessor created a getter method that returns the current value of @city, which was set to "NY" in step 5 and read in step 9.

Visual Quiz - 3 Questions

Look at the execution table, what happens when we try to read p.age at step 8?

A It returns the value 30

B It causes an error because no read method exists

C It returns nil

D It sets @age to 30

💡 Hint

Check step 8 in the execution_table where reading p.age fails due to missing method.

At which step is the write method for :city created?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at step 3 where attr_accessor creates both read and write methods for city.

If we add attr_reader :age, what would change in the execution table?

A Step 5 would fail to set city

B Step 7 would cause an error

C Step 8 would return 30 instead of error

D No change at all

💡 Hint

Adding attr_reader :age creates a read method, so reading p.age at step 8 would succeed.

Concept Snapshot

attr_reader :symbol  # creates getter method to read attribute
attr_writer :symbol  # creates setter method to write attribute
attr_accessor :symbol # creates both getter and setter
Use to avoid writing simple methods manually.
attr_reader allows reading only, attr_writer writing only, attr_accessor both.

Full Transcript

This visual execution shows how Ruby's attr_reader, attr_writer, and attr_accessor work. First, attr_reader creates a method to read an attribute's value. attr_writer creates a method to write or change the attribute's value. attr_accessor creates both read and write methods. We define a Person class with these attributes. When we create an instance and try to read or write attributes, only the methods created by attr_* work. For example, reading p.name works because of attr_reader, but reading p.age fails because only attr_writer was defined. Setting and reading p.city works because attr_accessor was used. This helps avoid writing simple getter and setter methods manually.