Ruby ‘self’ Class

What is self in Ruby?

In Ruby, the keyword self holds a special significance as it serves as a reference to the current object or class when a method is invoked. Its behavior depends on the context in which it is used, allowing us to represent different entities and exhibit varying behavior.

The behavior of self is contextual and serves as a mechanism for Ruby to track and identify the current object or class that our code is working with at any given moment. By leveraging self, we gain the ability to access and modify the properties and behaviors of the current object or class, empowering us to write dynamic and adaptable Ruby code.

Thus, self is a reserved keyword in Ruby that always represents the current object or class. Its value and behavior adapt to the context we employ it, enabling us to interact seamlessly with the properties and behaviors associated with that particular object or class. A comprehensive understanding and proper utilization of self are fundamental in crafting efficient and object-oriented Ruby code.

self Contexts

The Ruby self keyword specifies the context or current object at any given time during the execution of the code. It serves as a mechanism to identify the object that the code is now working with. Self can represent a variety of things depending on the situation, including a class instance, the class itself, or a module.

In an instance method, self refers to the instance of the class on which the process is called. This allows the method to access and manipulate the instance variables and invoke other instance methods of that particular object.

In the case of a class method, self refers to the class itself rather than an instance of the class. Class methods can be invoked directly on the class itself without needing an instance because they are declared at the class level. We may access class-level variables and call other class methods by using self inside a class method.

In a class or module definition, self refers to the class or module itself. This allows us to define methods and access class-level variables directly without the need for a method call. It provides a convenient way to define behavior and properties specific to the class or module.

Additionally, when a method is called without an explicit recipient, the self is implicitly utilized as the receiver. This allows methods to be invoked without explicitly identifying the object. In this situation, self refers to the object on which the method is being called. It's important to note that self always refers to one and only one object at any given time. Its value changes depending on the context and where it is used within the code.

What class << self Actually Does?

The class << self-construct is a syntactic sugar in Ruby that allows us to define class methods within a block. It provides a way to open up the singleton class of an object and define methods that are specific to that object. By using class << self, we can define multiple class methods within a single block, providing a concise and readable way to organize and encapsulate related class-level behavior.

Let's see an example:

Explanation

In this example, the class << self syntax is used. Inside it, the func method is defined which becomes a class method. Thus the method is accessible without creating any instance of the class.

self Inside of a Class Method

When the keyword self is used within a class method, it refers to the class as a whole rather than an instance of the class. Class methods are specified at the class level and may be invoked directly on the class without using an instance. We may access class-level variables and launch other class methods by calling self from within a class method.

Here's an illustration of this concept:

Explanation

In the above code, self refers to the Example class within the func class method. The output of the code will be Example, indicating that the self represents the class itself.

self Inside of an Instance Method

Inside an instance method, the self refers to the instance of the class on which the process is called. Instance methods are defined within a class and can only be invoked on instances of that class. By using the self within an instance method, we can access instance variables and invoke other instance methods.

Consider the following example:

Explanation

In this example, we have a func method inside the class Example. The self keyword here inside the method refers to the object from which the method is being called. Thus, the output will be the object's class name.

self Inside of a Class or Module Definition

Within a class or module definition, self refers to the class or module itself. It allows us to define methods and access class-level variables directly without the need for a method call.

Explanation

In the code above, self refers to the module when it is used inside the module. The self maintains the hierarchy when it is called from within the module's class.

self Inside of a Singleton Method

A method that is specified on a particular object rather than its class is known as a singleton method. Self always refers to the singleton object when it is used inside a singleton method. A singleton object is a class instance with special behavior that is specified specifically for that particular instance.

Here's an example:

Explanation

This example contains a singleton method. Only the object obj is capable of using the func method. The self keyword inside it refers to the object itself.