What’s self?

Ruby newcomers usually are confused about the use of self , whether it’s a completely new concept for them or not.

First, let’s define self:

self is the current object

The definition may seem a little too dry, but that’s exactly what self is. In your code, at any time, there’s always a self object, and its value depends on the code context.

IRB and self

When practicing with ruby, irb is your best friend. For those who want to get fancy you can replace it with pry. Let’s see some examples, first start the irb session with the irb command, then let’s see what irb has to say about self :

$ irb 2.1.0 :001 > self => main > self.inspect => "main" self.class => Object

There’s always a self when executing ruby code: at startup irb creates a top level object called main, which is actually just an instance of the Object class. That’s your default self .

self at class definition

Time to move on. Let’s see what self is when defining a class:

class Person self end => Person

It’s the class itself, and it makes perfect sense. Do you know about class methods? When you’re out of the context of the class, you can define them like this:

def Person.show_self self.inspect end Person.show_self => "Person"

But when you’re in the context of the class, you can define class methods in both these ways:

class Person

def Person.show_self

self.inspect

end

def self.show_self self.inspect end end Person.show_self => "Person"

They are equivalent, but the latter is preferable. Why? Because if you decide to change the name of the class, you don’t have to change the name in the signature method as well.

self in instance methods

What about instance methods? Inside instance method definitions, self is the actual instance:

class Person def show_self self.inspect end end Person.new.show_self => #<Person:0x00000101939098>

Most of the times, inside method body definitions, self is redundant and we can avoid it:

class Person def self.show_self # class method, self is the class inspect end def show_self # instance method, self is the instance inspect end end



Person.show_self => "Person"



Person.new.show_self

=> #<Person:0x00000101939098>

When self is required

There are some cases when you need an explicit self , namely when inside the method body there’s a local variable with the same name of the method you’re willing to call on self . If you omit self you’re going get some unexpected results for sure:

class Person def show_self inspect = 'boo!' inspect end end Person.new.show_self => "boo!" class Person def show_self inspect = 'boo!' self.inspect end end Person.new.show_self => #<Person:0x00000101939098>

Another very common scenario when self is always required is when using writer methods:

class Person attr_accessor :name def set_name(person_name) self.name = person_name end end me = Person.new me.set_name 'Andrea' me.name => "Andrea"

If we had written

def set_name(person_name) name = person_name end

then the code would have created a local variable named name.

The last important case when self is required is when you call the class method of an instance:

class Person def show_class self.class end end Person.new.show_class => Person

In this case self is required because class is a reserved keyword, so we need to make sure the parser undestands we’re referencing to the instance class object.

When self cannot be used

Sometimes on the other hand you cannot use the explicit self : that’s the case with private methods:

class Person attr_accessor :name private :name def show_name name end def buggy_show_name self.name end end me.show_name => "Andrea" me.name NoMethodError: private method `name' called for #<Person:0x00000101939098& @name="Andrea"> me.buggy_show_name NoMethodError: private method `name' called for #<Person:0x00000101939098& @name="Andrea">

Wrapping up

In order to write idiomatic ruby, the rule of thumb is to avoid the explicit self whenever it’s not required.