# What is self in Ruby

Object Oriented Programing introduce a new keyword self. This keyword is used in different context.

## Calling Methods with self

A classic error made when learning to use classes and instance methods is to assign new value to a newly initialized local variable instead of the setter method.

class Obake
def initialize(name, age)
@name = name
@age = age
end

def change_info(name, age)
name = name
age = age
end

private

attr_accessor :name, :age
end

We know we need setter methods (provided by attr_accessor) to modify the @name and @age instance variables. However, in the change_info method we are not calling those two setter methods. Instead, we are initializing new local variable name and age. As thoses are scoped to the method scope (see also Local Variable Scope), they cease to exist when the method returns.

What we really want to do is reassign the instance variables using setter methods. This can be done thanks to self to let Ruby know we’re calling a method:

class Obake
def initialize(name, age)
@name = name
@age = age
end

def change_info(name, age)
self.name = name
self.age = age
end

private

attr_accessor :name, :age
end

It is possible, though not required, to use self on getter methods as well. Rubocop will probably flag it:

C: Style/RedundantSelf: Redundant self detected. (https://github.com/bbatsov/ruby-style-guide#no-self-unless-required)
"My name is #{self.name} and I am #{self.age}!"
^^^^^^^^^
C: Style/RedundantSelf: Redundant self detected. (https://github.com/bbatsov/ruby-style-guide#no-self-unless-required)
"My name is #{self.name} and I am #{self.age}!"
^^^^^^^^

Last but not least, we can use self on any instance method, not just accessor methods.

## Method Definitions with self

self is used to define class methods. See .

Using self inside a class but outside an instance method refers to the class itself.

class Obake
puts "I am a good #{self}."
end

Obake  # => I am a good Obake.

From the example above, we can see how a method defined using self is a class method: def self.my_method is the same as def Obake.my_method.

## Referencing the Calling Object

Imagine a method what_is_self that returns self:

class Obake
attr_accessor :name, :age

def initialize(name, age)
@name = name
@age = age
end

def what_is_self
self
end
end

tommy = Obake.new('Tommy', 204)
arthur = Obake.new('Arthur', 340)

p tommy.what_is_self  # => #<Obake:0x000055f7cf7da3a8 @name="Tommy", @age=204>
p arthur.what_is_self # => #<Obake:0x000055f7cf7da330 @name="Arthur", @age=340>

We can see that from within the class, when an instance method uses self it reference the calling object. In this case it’s the tommy and arthur objects.

This means calling self.name= (name= being the setter method) inside an instance method acts the same as calling tommy.name= from outside the class.

tommy.name= cannot be called inside the class as the object tommy is not in scope.