Ruby Basics : The self at the Top Level
In this article, you will learn about the current object,
self at the top level.
What is self?
In Ruby, there is always one object that plays the role of current object at any given instant. The current object provides an execution context for the code.
This current object is the default receiver. When the receiver is not provided, the message is sent to the default receiver. This is the
Self at the Top Level
Let's see the value of self at the top level.
This tells us that Ruby has created an object called
main for us at the top level. And all the code we write at the top level will use
main as the receiver in method calls.
The main Object
main is an object, it must be instance of some class. We can ask Ruby to tell us which class
main is an instance of:
We now know, Ruby did something like this:
main = Object.new
This provides us an object context to execute our code at the top level. Thus, providing us the default receiver
main at the top level. The main is an instance of the Object class.
Hello at the Top Level
Let's print hello to the standard output.
As expected, this prints
Is main a Receiver Object?
Can we use
main, the instance of Object, to call puts?
NameError: undefined local variable or method ‘main’ for main:Object
main as the current object at the top level. But, there is no such variable called
Human Visible main Object
main is the human visible representation of the current object. Let's see this in action in the IRB console.
> self => main > self.inspect => "main" > self.to_s => "main"
Why does Ruby create main object at the top level?
In a OO language like Ruby, there is always a sender and receiver involved in a message send. We did not explicitly create a sender object. Thus, Ruby created a sender object for us. It is implicit, because it is not visible in the code.
In an upcoming article, we will see that both sender and receiver are main at the top level.
If I don't create a receiver object, does Ruby create a receiver object?
No. Ruby does not create a receiver object; it uses the existing value of
self as the default receiver.
In this article, we discussed the default receiver self at the top level context. You learned that we cannot specify an explicit receiver for methods in the top level like
puts(). In such cases, the receiver is implicit and is not specified. We will see why in an upcoming article.
Software Compatibility Best Practices
I spoke to some of the most talented and experienced software developers. I have created a guide that is filled with valuable insights and actionable ideas to boost developer productivity.
You will gain a better understanding of what's working well for other developers and how they address the software compatibility problems.