Ruby Getters & Setters Methods
I’ve worked with a few projects with Ruby on Rails, so I thought it would be a good idea to return to the fundamentals of just Ruby. I decided to revisit getter and setter methods. These methods help with retrieving values or creating values for an instance variable. This blog will describe what getters and setters are, their syntax, and an example of how to use them. It’s also assumed that you have an understanding of what a Ruby classes and instances are.
A method that is retrieving a value is getting a value, hence the name getter method. The getter method will display information, but it cannot change, edit, or update anything. A method that is changing or updating a value is setting a value, hence the name setter method. The setter method will not display anything, but can change, edit or update an instance variable’s value.
In order to get or set something, we need to know what what is being get or set. The initialize method will help with that.
The example model for this blog will be creating very basic information for a student. The only concern is a student’s name and major. We start off with a class of Student. Any student instance created from this class will be initialized with a name and a major, as seen in Image A below.
Lines 1 through 6 represent the student class with the initialize method taking the parameters of
major. Line 8 represents the creation of a new instance a student being created with the name of “John” and major of “Math”. Line 9 will
putsout the instance created.
Run the code using
ruby student.rb. Image B is the result of the
puts statement from line 9. Notice the instance is represented as
#<Student>:0x00007ffab989a6f0>. We do not see the the name or major information.
If we would like to know the name of that instance, we can try
Line 9 was updated in attempt to get the name of the instance using
student.name. An error followed as shown in Image D
The error message in Ruby says
undefined method 'name' for .... Notice that the instance does show
@name = "John" and
@major = "Math". This does confirm that our instance has the values we entered, but we need the method to get the values. Since Ruby didn’t find a method called
name to get the name, let’s make one.
def name has now been added. (Note: The method name can be whatever you like, but it should reflect the name should reflect the purpose of the method.
get_name is a more explicit/better method name.)When the method is called using
student.name, Ruby will use the method
def name, then see the
@name instance variable. The information acquired is
@name = "John" as was show in image D. Ruby will share the value of the instance variable which is just
"John". Running the command
ruby student.rb will show the result of the student’s name being sought after as in Image F.
If we try to get the student’s major using
student.major that won’t work since we have not set up a getter method to get the information. Let’s update the code to do exactly that. I encourage you to try it yourself before looking at the example.
The student class now has two getter methods:
def name and
def major. When these methods are called in line 19 and 20 in Image G, the result will be
puts out when running the command
ruby student.rb once again.
Image H shows the result of getting the student’s name and major.
Now let’s say that the student has decided to change their major. All that is possible is getting the major information. There is no way to update, or set the major. This is where a setter method comes in handy.
The method name
set_major can be whatever you like, but it makes sense to title the method reflecting what it will do. The
=(major) is saying that whatever is being passed into the parameter
(major), will be set equal to something shortly. Line 19 shows that whatever was passed into the parameter of
(major) will now be set to the instance variable
@major. This is what allows us to take in a new major and update the value of the instance variable.
The code thus far is in Image J. We have an
initialize method, a getter method called
name, a getter method called
major, and a setter method called
puts statements are in order to see the original major that was initialized and the updated major using
Image K below shows the results of the
Notice the original major was “Math”. Then the
set_major method was used in line 28 of Image J to update or set the major to “Biology”. The the
major method was called again to
puts the update value as seen in Image K.
Those are the basics of setter and getter methods. It does take some time to understand them. I encourage you to make your own example to make setter and getter methods for. Make sure to step away from your code and return to it in a week or two to test your knowledge of what you learned.