Attr_reader, attr_writer, attr_accessor in Ruby - Time & Space Complexity

Time Complexity: Attr_reader, attr_writer, attr_accessor

O(1)

Understanding Time Complexity

Let's see how using attr_reader, attr_writer, and attr_accessor affects the speed of our Ruby code.

We want to know how the time to access or change object properties grows as we use these shortcuts.

Scenario Under Consideration

Analyze the time complexity of the following Ruby class using these attribute helpers.

class Person
  attr_accessor :name
  attr_reader :age
  attr_writer :email

  def initialize(name, age, email)
    @name = name
    @age = age
    @email = email
  end
end

person = Person.new("Alice", 30, "[e-mail]")
person.name = "Bob"
puts person.age
person.email = "[e-mail]"
    

This code defines a class with automatic getter and setter methods for its properties.

Identify Repeating Operations

Look for operations that happen multiple times or grow with input.

• Primary operation: Accessing or setting instance variables via generated methods.
• How many times: Each access or set is a single direct operation, no loops or recursion.

How Execution Grows With Input

Each time you get or set a property, it takes the same small amount of time, no matter how many properties or objects you have.

Input Size (n)	Approx. Operations
10	10 simple property accesses or sets
100	100 simple property accesses or sets
1000	1000 simple property accesses or sets

Pattern observation: The time grows directly with how many times you access or set properties, but each is quick and does not depend on other factors.

Final Time Complexity

Time Complexity: O(1)

This means each property access or change takes the same small amount of time, no matter how many objects or properties exist.

Common Mistake

[X] Wrong: "Using attr_accessor makes property access slower because it adds extra code."

[OK] Correct: These helpers just create simple methods that run very fast, so they do not slow down your program noticeably.

Interview Connect

Understanding how these shortcuts work and their speed helps you write clean and efficient Ruby code, a skill useful in many coding situations.

Self-Check

"What if we replaced attr_accessor with manual getter and setter methods? How would the time complexity change?"

Practice

1. What does attr_reader do in a Ruby class?

easy

A. Creates a method to read an attribute value

B. Creates a method to write an attribute value

C. Creates methods to both read and write an attribute

D. Deletes an attribute from the class

Solution

1. Step 1: Understand attr_reader purpose

   attr_reader defines a getter method for an instance variable, allowing you to read its value.

2. Step 2: Compare with other attr methods

   attr_writer creates a setter (write) method, and attr_accessor creates both getter and setter methods.

3. Final Answer:

   Creates a method to read an attribute value -> Option A

4. Quick Check:

   attr_reader = read method [OK]

Hint: attr_reader = read only method [OK]

Common Mistakes:

• Confusing attr_reader with attr_writer
• Thinking attr_reader allows writing values
• Mixing attr_accessor with attr_reader

2. Which of the following is the correct syntax to create both getter and setter methods for @name in Ruby?

easy

A. attr_writer :name

B. attr_accessor :name

C. attr_reader :name

D. attr_both :name

Solution

1. Step 1: Recall attr_accessor usage

   attr_accessor creates both getter and setter methods for the given symbol.

2. Step 2: Check other options

   attr_reader only creates getter, attr_writer only setter, and attr_both is invalid syntax.

3. Final Answer:

   attr_accessor :name -> Option B

4. Quick Check:

   attr_accessor = read + write [OK]

Hint: Use attr_accessor for read and write [OK]

Common Mistakes:

• Using attr_reader when write is needed
• Using invalid method names like attr_both
• Confusing attr_writer with attr_accessor

3. What will be the output of this Ruby code?

class Person
  attr_writer :age
  def initialize(age)
    @age = age
  end
  def show_age
    @age
  end
end

p = Person.new(30)
puts p.show_age
p.age = 40
puts p.show_age

medium

A. 30\n40

B. 30\n30

C. Error: undefined method `age='

D. Error: undefined method `show_age'

Solution

1. Step 1: Understand attr_writer effect

   attr_writer :age creates a setter method age=, but no getter method is created.

2. Step 2: Analyze method calls

   p.show_age returns @age which is 30 initially. Then p.age = 40 sets @age to 40. But p.show_age returns @age which is now 40.

3. Step 3: Check output

   Actually, p.show_age is called twice, before and after setting age. So outputs are 30 then 40.

4. Final Answer:

   30\n40 -> Option A

5. Quick Check:

   attr_writer allows setting, show_age reads @age [OK]

Hint: attr_writer only sets; custom getter needed [OK]

Common Mistakes:

• Assuming attr_writer creates getter method
• Expecting error on p.age= assignment
• Confusing show_age method with attr_reader

4. Identify the error in this Ruby class:

class Car
  attr_reader :model
  def initialize(model)
    @model = model
  end
  def model=(value)
    @model = value
  end
end

car = Car.new('Sedan')
car.model = 'SUV'
puts car.model

medium

A. Error: attr_reader conflicts with manual setter method

B. Error: undefined method 'model='

C. Error: attr_reader does not create setter method

D. No error, code runs and prints 'SUV'

Solution

1. Step 1: Check attr_reader and setter method

   attr_reader :model creates a getter method. The setter method model= is manually defined.

2. Step 2: Analyze method calls

   car.model = 'SUV' calls the manual setter, updating @model. puts car.model calls the getter from attr_reader, printing 'SUV'.

3. Final Answer:

   No error, code runs and prints 'SUV' -> Option D

4. Quick Check:

   attr_reader + manual setter works [OK]

Hint: attr_reader + manual setter is valid [OK]

Common Mistakes:

• Assuming attr_reader creates setter method
• Thinking attr_reader conflicts with manual setter
• Expecting error on model= assignment

5. You want a Ruby class Book where the title can be read but not changed, and the author can be both read and changed. Which attribute methods should you use?

hard

A. attr_writer :title
attr_writer :author

B. attr_writer :title
attr_reader :author

C. attr_reader :title
attr_accessor :author

D. attr_accessor :title
attr_writer :author

Solution

1. Step 1: Determine access for title

   Title should be readable but not writable, so use attr_reader :title.

2. Step 2: Determine access for author

   Author should be readable and writable, so use attr_accessor :author.

3. Final Answer:

   attr_reader :title attr_accessor :author -> Option C

4. Quick Check:

   Read-only + read-write = attr_reader + attr_accessor [OK]

Hint: Use attr_reader for read-only, attr_accessor for read-write [OK]

Common Mistakes:

• Using attr_writer for read-only attribute
• Using attr_accessor for read-only attribute
• Mixing up read and write access