Know Thy Self

If you’re working in Ruby you’ve definitely heard the term “self”. Ruby is an arrogant program and likes to talk about itself an awful lot. Unfortunately, we need to indulge our friend Ruby because it makes our life a whole lot easier. What it does essentially is the exact opposite of this gif:

In short, self gives you access to the object you’re currently working in. It is a reference to the code basically asking “Right this moment while this code is running….. who am I?” That’s it! Why does it require a blog post? Because there’s a lot of cool stuff you can do with it.

Here’s a base-level example of how self works.

class BoomBaby
def boom
self
end
BoomBaby.boom == BoomBaby
#=> true

Here we have a class aptly named BoomBaby and an instance method within this class simply called boom that returns self. We can go even simpler than that and keep self at the top-level of your code:

def boom_baby
p self
end
#=> main

What’s happening is we’re defining an instance method without a class. Since we’re not currently couched in a class, self will refer to something called the main object, or simply “main”. All Ruby is object-oriented, so when we’re not referring to an object specifically, we are referring to “main”.

module BoomGoesTheModule  
def self.look_at_me_please
p self
end
end
class BoomGoesTheClass
def self.ok_but_please_look_at_me_now
p self
end
end
BoomGoesTheModule.look_at_me_please. #BoomGoesTheModuleBoomGoesTheClass.ok_but_please_look_at_me_now # BoomGoesTheClass

And look at that! The self here is referring to either the class we defined or the module we defined earlier, depending on what it’s couched in. This is simply showing that self is a versatile little tool and knows what to refer to.

Self is an incredibly useful tool that will do for you the most important thing something can do for a programmer: make your code shorter. You’ll hear this a lot in your coding journey (like…. seriously you’ll hear it a lot): coders are lazy. If there’s an easier way to do something they will do so. And that’s a good thing! Even in the simple examples above, the code would look much more muddled and harder to read if instead of self we wrote out what self is referring to each time.

And we’ve barely scratched the surface of what self can do for you. You can interpolate it into all sorts of things within instance methods and it will always know that it’s talking about the specific instance at hand or if you’re working with a single source of truth you can initialize a class with certain attributes and then shovel those attributes into that source upon initialization. Here’s an example of the latter:

class BoomestOfBabys@@all = []def initiate(name, boom_instance)
@name = name
@boom_instance = boom _instance
@@all << self
end
end

You can come in to clean up other people’s code and they’ll always say :

In conclusion, even though it can be a bit of a confusing concept, I promise it will make your code both more readable and easier to write. If I’m perusing through code I don’t know and my eyeballs pass the word “self”, it’s MUCH easier figuring out what that must be referring to, than seeing a class/instance/module name and having to suss out where that’s coming from.

Self when able. Self responsibly. Self often.

--

--

--

Full time software engineering student at Flatiron School

Love podcasts or audiobooks? Learn on the go with our new app.

Recommended from Medium

Java Online Compiler

Hashmap is a class in java which implements a map interface which helps us to store key and value…

How to do Memory Analysis of Application

When, Why, and How to Go Mobile: The advantages and disadvantages of different approaches

Single Node processing — Spark, Dask, Pandas, Modin, Koalas vol. 1

Effective Data Management

Over the past 48 hours I have proposed this idea to the CEOs

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
Adam Schwartz

Adam Schwartz

Full time software engineering student at Flatiron School

More from Medium

A decorator is a design pattern in Python that allows a user to add new functionality to an…

Jumping the Fence: A Mischievous Approach to learning Decision Analysis

What Product Managers Can Learn about Using Indicators to Achieve Objectives From A Legendary…

At the beginning of each project, the first question I always aim to answer is, “Where is my data…