The difference between creating an instance of a class in Ruby and an object in JS
I've been using Ruby almost exclusively for the past couple of months. I've written a bunch of console applications, sinatra web apps, and messed around pretty extensively with active record. Almost all of my applications have required setting up classes and those classes have all been used to render instances of themselves. I was just starting to get comfortable with Object Oriented Ruby, the concept of inheritance, and the usefulness of modules (read this http://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330)...then JavaScript came along. Everyone is always boasting about how elegant a language Ruby is, and how it's one of the best languages for beginners because it's syntax is so easy to pick up.
Before learning about Object Oriented Javascript I had learned how to manipulate the DOM, and written basic scripts to activate and deactivate my cool CSS3 animations, but I had been using jQuery almost exclusively. It's methods reminded me of a bulkier Ruby, but I quickly saw it's potential after creating this simple script for changing every image on a page to Miley Cyrus (load in console:Ā $('img').attr('src', 'http://hvngrymag.com/wp-content/uploads/2014/03/Miley-Cyrus-Is-Singing-to-Who1.jpeg')). Coming from Ruby, OOJS can seem kind of daunting. Let me show what convinced me that it's not.
Let's create a Person class in Ruby:
class Person
def initialize(first_name, last_name)
@first_name = first_name
@last_name = last_name
end
def say_hi
"hello there"
end
end
Sweet. We've just created a class with a few instance variables and a say_hi method. Now whenever we create a new person for our application we can just write:
phil = Person.new(āPhilā, āLondonā) #=> #<Person:0x007f863b08e968 @first_name=āPhilā, @last_name=āLondonā&rt
Now that we have a phil, an instance of our Person class, we can try to figure out some information about it:
phil.first_name #=&t;Ā undefined method `first_name' for #<Person:0x007f863b12a408&rt;
Actually, we can't even figure out phil's first_name. The only thing we can do at this point actually is call the say_hi method. Let's do that:
phil.say_hi #=> "hello there"
If we want to figure out the first_name and the last_name attributes of phil, or any of our other objects created from this class, we need to add attr_reader methods before the initialize method. We could also use the attr_accessor method, which would allow us to edit and read the first_name and last_name attributes.
class Person attr_reader :first_name, :last_name
Now we can call say_hi, first_name, and last_name on phil, and any of the other objects that we create in the future.
Let's see what this whole thing would look like in JavaScript:
var createPerson = function(firstName, lastName) { return { firstName: firstName, lastName: lastName, sayHi: function() { return āhello thereā; } } }
We have just created a function that can create an object, which has the properties firstName, lastName, and sayHi. sayHi is a property and it is also a function, pretty cool! If we want to create phil again we just say:
var phil = createPerson(āPhilā, āLondonā) phil > { firstName: 'Phil', lastName: 'London', sayHi: [Function] }
We now have all the same functionality from our OOJS phil object that we do with our phil object that we created in Ruby. Our OOJS method createPerson is known as a factory method. We use factory methods when we know we'll be creating objects with the same interface, i.e, when we know each person will have a first and last name, and they'll be able to say hello!
jbbartram-illu
gummygunk
yousharknotpass
turnnoffyourmind
vaporwave
annaxmalina
kaledo-art
germansingergirl