Attr_reader, attr_writer, attr_accessor in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does attr_reader do in Ruby?

attr_reader creates a getter method for an instance variable. It lets you read the value but not change it directly.

beginner

What is the purpose of attr_writer in Ruby?

attr_writer creates a setter method for an instance variable. It lets you change the value but not read it directly.

beginner

Explain attr_accessor in Ruby.

attr_accessor creates both getter and setter methods for an instance variable. You can read and change the value.

intermediate

Why use attr_reader, attr_writer, or attr_accessor instead of writing methods manually?

They save time and make code cleaner by automatically creating simple getter and setter methods.

beginner

Given attr_reader :name, can you change the @name variable directly from outside the class?

No, attr_reader only allows reading the value. To change it, you need a setter method like attr_writer or attr_accessor.

Which Ruby attribute method allows both reading and writing an instance variable?

A attr_accessor

B attr_reader

C attr_writer

D attr_mutator

attr_accessor creates both getter and setter methods, allowing reading and writing.

What does attr_writer :age provide?

A A method to read @age

B A method to write @age

C Both read and write methods for @age

D No methods for @age

attr_writer creates a setter method to change the value of @age.

If a class has only attr_reader :title, what happens if you try to assign obj.title = 'New'?

A Raises an error

B It works fine

C Ignores the assignment

D Creates a new variable

Without a setter method, assigning to title raises a NoMethodError.

Which of these is NOT a reason to use attr_accessor?

A To reduce boilerplate code

B To automatically create getter and setter

C To make variables private

D To simplify class design

attr_accessor does not make variables private; it creates public getter and setter methods.

What is the default visibility of methods created by attr_reader, attr_writer, and attr_accessor?

A Module

B Protected

C Private

D Public

These methods are public by default, accessible from outside the class.

Describe the differences between attr_reader, attr_writer, and attr_accessor in Ruby.

Think about what each method lets you do with an instance variable.

Explain why using attr_accessor can make your Ruby class code cleaner and easier to maintain.

Consider how much code you save by not writing simple getter and setter methods.

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