How to Use attr_accessor, attr_writer & attr_reader

This article is about attribute accessors (attr_accessor) in Ruby.

If you’re in a hurry, scroll down.

Because I would like to start by explaining:

Why we use attribute accessors!

Let’s say that you have a class with instance variables & you want to expose them to the outside world.


You have to define a method.

Only methods can access instance variables.


Because you’ll get an error if you don’t do this.

Here’s an example:

class Food
  def initialize(protein)
    @protein = protein

bacon =

# NoMethodError: undefined method `protein'

NoMethodError is the error you get when you ask for the value of protein without the proper setup.

What’s the solution?

You can define your own method like this:

class Food
  def protein

# 21

In other OOP languages this is known as a “getter” method. You define a method that gets you the value of the instance variable.

You may also want to change the value.

For that, you’ll need another method, like this one:

class Food
  def protein=(value)
    @protein = value

bacon.protein = 25

Imagine you’re opening a portal into the object so that you can change the value.

That’s what this is doing.


Is there a better way to define this kind of method?

Like some kind of shortcut?


There is 🙂

That’s where attr_accessor comes in.

Ruby attr_accessor Examples

You can tell Ruby to create these methods for you with attr_accessor.

Here’s how:

class Food
 attr_accessor :protein

 def initialize(protein)
   @protein = protein

Look at this line:

attr_accessor :protein

This is a Ruby method that creates other methods for you.

What methods?

For this example, it creates:

  • protein
  • protein=

These are the same methods we created before…

But now you don’t have to type them out.

It’s a shortcut!

attr_accessor vs attr_reader

Besides attr_accessor, you also have other kinds of accessors.

Three of them to be exact:

  • attr_accessor
  • attr_reader
  • attr_writer

What are the differences between them?

Well, attr_accessor creates both the READER & WRITER methods.

  • attr_reader creates only the reader.

  • attr_writer creates only the writer.

In other words:

With attr_reader you can only read the value, but not change it. With attr_writer you can only change a value but not read it.

Multiple Instance Variables

Want to define multiple attribute methods?

You can do it.

But you have to use the right syntax.

Like this:

attr_reader :name, :value, :ready?

You can create as many as you want.

Watch Video Tutorial


You have learned about attribute accessors in Ruby! A set of 3 methods (attr_accessor, attr_writer & attr_reader) to access & set instance variables from outside the class.

Now it’s time to practice.

Daniel says last year

Good job, bro! you continue to this way… Easy, basic and simple teaching of “Atrribute accessor”

    Jesus Castello says last year

    Thank you 🙂

Comments are closed