Ruby self Keyword

last modified April 27, 2025

This tutorial explains how to use Ruby’s self keyword. The self keyword is fundamental to Ruby’s object-oriented nature.

The self keyword refers to the current object, the default receiver of method calls. It changes context depending on where it’s used in the code.

Understanding self is crucial for writing idiomatic Ruby code. It affects method definitions, class methods, and instance variable access.

Basic self in Instance Methods

In instance methods, self refers to the instance of the class. This example shows how to use self to access instance variables.

basic_instance.rb

class Person def initialize(name) @name = name end

def introduce puts “Hello, my name is #{self.name}” end

def name @name end end

person = Person.new(“Alice”) person.introduce

Here self.name calls the name getter method on the current instance. The self keyword makes it explicit we’re calling a method.

self in Class Methods

In class method definitions, self refers to the class itself. This is how Ruby defines class-level methods.

class_methods.rb

class Logger def self.info(message) puts “[INFO] #{message}” end

def self.error(message) puts “[ERROR] #{message}” end end

Logger.info(“Application started”) Logger.error(“Something went wrong”)

The self. prefix defines methods on the class itself rather than instances. These are called directly on the class.

self for Method Chaining

Returning self from methods enables method chaining. This creates a fluent interface where methods can be called in sequence.

method_chaining.rb

class Calculator def initialize(value = 0) @value = value end

def add(num) @value += num self end

def subtract(num) @value -= num self end

def result @value end end

calc = Calculator.new puts calc.add(5).subtract(2).add(10).result

Each method returns self, allowing calls to be chained together. The final result call returns the computed value.

self in Module Definitions

Inside modules, self refers to the module itself. This is used to define module-level methods and constants.

module_self.rb

module MathUtils def self.square(x) x * x end

def self.cube(x) x * x * x end end

puts MathUtils.square(5) puts MathUtils.cube(3)

Module methods defined with self are called directly on the module. They don’t require mixing the module into a class.

self for Explicit Receiver

Using self as an explicit receiver clarifies method calls and distinguishes between local variables and method calls.

explicit_receiver.rb

class BankAccount attr_accessor :balance

def initialize(balance = 0) @balance = balance end

def deposit(amount) self.balance += amount end

def withdraw(amount) self.balance -= amount end end

account = BankAccount.new(100) account.deposit(50) account.withdraw(30) puts account.balance

Here self.balance calls the setter method, while balance alone would reference a local variable. The explicit receiver avoids ambiguity.

self in Singleton Methods

self is used to define singleton methods on individual objects. These methods exist only for that specific instance.

singleton_methods.rb

greeting = “Hello, world”

def greeting.shout self.upcase + “!” end

puts greeting.shout puts greeting.upcase

begin “Another string”.shout rescue => e puts “Error: #{e.message}” end

The shout method is only available on the greeting object. Other strings don’t have this method, as shown by the error.

self in Class Definitions

Inside a class definition but outside methods, self refers to the class being defined. This is used for metaprogramming.

class_definition.rb

class Animal puts “In Animal class definition, self is #{self}”

def self.species puts “Species method called on #{self}” end

def initialize puts “In instance method, self is #{self}” end end

Animal.species animal = Animal.new

The output shows how self changes context. Inside the class definition, it’s the class itself, while in instance methods it’s the instance.

Source

Ruby Keywords Documentation

This tutorial covered Ruby’s self keyword with practical examples showing instance methods, class methods, method chaining, and more.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Ruby tutorials.