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
$ 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 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:
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"
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">
In order to write idiomatic ruby, the rule of thumb is to avoid the explicit self whenever it’s not required.