If you’re learning Ruby you may find the use of the “self” keyword very confusing.
How does it work?
What is self, exactly?
It’s a Ruby keyword that gives you access to the current object.
If you don’t know what objects are, watch this video I made for you. It’s related to Object-Oriented Programming.
This “current object” depends on the context.
Context?
Yes, the context is where your code is at any given moment.
Here’s an example:
If your code is inside an instance method, self is an instance of that class. In other words, self is an object.
You can see this in action yourself.
Run this code:
def coffee
puts self
end
coffee
# main
This code defines & calls a coffee method which prints the value of self.
Why does it print main?
Because it’s the name of the top-level object, it’s an object where you’ll find all the methods defined outside a class.
Like our coffee method here.
But if you define a method inside a class named Cat, then self would be a Cat object.
As seen here:
class Cat
def meow
puts self
end
end
Cat.new.meow
# <Cat:0x7a14c5>
From these examples, we can tell that the value of self changes depending on where you use it.
Now:
I believe you can understand anything better by understanding its purpose.
Why is self useful?
Let’s look at some examples.
Using Self For Disambiguation
One practical use for self is to be able to tell the difference between a method & a local variable.
It’s not a great idea to name a variable & a method the same. But if you have to work with that situation, then you’ll be able to call the method with self.method_name.
Here’s what I mean:
class Example
def do_something
banana = "variable"
puts banana
puts self.banana
end
def banana
"method"
end
end
Example.new.do_something
# "variable" => puts banana
# "method" => puts self.banana
Here we have a banana local variable, inside the do_something method, but we also have a banana method.
A local variable takes priority.
That’s why we need to use self here if we want to call the banana method, instead of printing the value of the banana variable.
Next:
Let’s look at a more common use case… Defining class methods!
Using Self To Define Class-Level Methods
Number ONE use for self, without a doubt, is to define class-level methods.
I’m sure you’ve seen them.
These def self.method_name method definitions.
Like this one:
class Salad
def self.buy_olive_oil
# ...
end
end
Salad.buy_olive_oil
This self here is equivalent to Salad, the class name.
Why is this useful?
Because we don’t have to use the class name for each method definition, making our code easier to change if we change the class.
It also makes the code less noisy & better to read.
That’s why we do def self.buy_olive_oil instead of def Salad.buy_olive_oil.
Other Uses For Self
Yes!
There are even more uses for self, so it’s a helpful thing to be familiar with.
For example:
You can use it in a method to compare the current object with another object.
Something like this:
def ==(other)
self == other
end
You can also use self for debugging purposes, to find out which object you’re working with.
Like this:
p self
Or you can use it as a return value, to implement design patterns like the Builder Design Pattern.
Example:
class Salad
def initialize
@ingredients = []
end
def add_nuts
@ingredients << :nuts
self
end
end
my_salad = Salad.new.add_nuts
In summary, here's a list of helpful uses for self:
- Define class-level methods
- Use an instance method when you have a local variable of the same name
- Returning Self (builder pattern)
- Debugging
- Comparing objects (==)
- Default receiver of method calls
Self vs Itself
One more thing we should look at before we are done with this topic.
The Kernel#itself method.
It's a method that you can call on an object & the object will return itself.
Example:
[1,2,3,nil].select(&:itself)
# [1, 2 ,3]
This example filters nil & false values.
Understanding the difference:
self is a keyword. It's value depends on where you use ititself is a method. It's value depends on what object you use it on (in 1.itself, 1 is the object)
Hope that's helpful.
Conclusion
You have learned about Ruby self keyword, exactly what it is, why it's useful & how to use it.
Now it's your turn to give it a try.
Thanks for reading! 🙂
