DEV Community

Cover image for Ruby is pretty neat
Tyler Montobbio
Tyler Montobbio

Posted on

Ruby is pretty neat

OOP is an interesting concept, one that many languages revolve around. During my introduction to JavaScript, OOP was a part of the course I hadn't touched. Needless to say, once I got into Ruby the concept was a little difficult to wrap my head around.

What is OOP?

(almost) Everything in ruby is an object, which is kind of a weird concept. Objects can hold state, react to other methods, and even have a unique identity. You can call .object_id on anything in ruby and get a unique number that is never repeated.

arr = [1, 2, 3, 4]
#=> [1, 2, 3, 4]

#=> 360

#=> Array
Enter fullscreen mode Exit fullscreen mode

Above you can see the .class method as well, every ruby object belongs to a class, but what does that mean?

Classes & Instances

My instructor put it like this, Classes are like little factories responsible for managing and creating instances. We can define a class for anything, and create unique!

Here's a fun example:

class Dog

  def greet
    puts "Woof Woof!"


Bug =

#=> "Woof Woof!"

#=> Dog
Enter fullscreen mode Exit fullscreen mode

Does this make sense? We defined a whole new class of objects called Dog, and were creating a special method for it! Think of it like .map() in JavaScript, we can only call the .map() method on an array and nothing else. While this example isn't quit as strict as that, the idea here is to create instances of dogs and a method to grab some information or interact with that dog object.

What does an instance look like?

Lets create an instance, but lets also give it a little more information. We can do this with instance variables.

class Dog
  def name=(name)
    # @name is an instance variable
    @name = name

  def name

dog1 = Dog.create = "Bug"
#=> "Bug"
Enter fullscreen mode Exit fullscreen mode

Now if we were to grab that instance we named Bug, it would look like this!

# .first is a built in class method that will grab the first 
# instance of a class
#=> <Dog:0x000055ed811b7b90 id: 1, name: "Bug">
Enter fullscreen mode Exit fullscreen mode

You can see that the Dog instance also was assigned a unique ID, this is useful for when we need to store multiple instances, with or without a name. These instances sort of resemble an array, or JavaScript object. We can even access data from them similarly to a JavaScript object.
#=> "Bug"
Enter fullscreen mode Exit fullscreen mode

The Takeaway

I should become pretty clear how this structure could be useful. Instances could be users in a game, you could store them in a database, and have a separate table in that database be that users inventory. We can tie everyone together with ID's, receive a request from a client and build custom methods to interact with our data before sending back the response! The possibilities are pretty expansive, and reading Ruby is very easy compared to other languages. I cant wait to design my first little game in ruby!

Top comments (0)