If you have been following through the tutorials so far then you may have noticed that when I have defined a new method to be added to an object I have defined it using object.prototype.method rather than just as object.method. I have done this (and you should too) not because defining object.method doesn't work (because it does work for creating a new method) but because it makes a difference to what happens when you copy the object.


When you copy an object, all the properties of the first object are copied to the second object and can have different values in them. This is what we want to happen and we specifically chose to use the "this" keyword in a prior tutorial in order to ensure that we create a new set of properties for each object rather than having them share the properties of the object they are derived from. Were multiple objects to share the one copy of the properties between them then we would effectively have only one object with a number of different aliases rather than having separate objects.

The rare cases where we do want a property shared between all similar objects (such as a counter to keep track of how many copies of the object we have taken) are the ones where we'd forgo using the "this" keyword in defining the properties and would reference the object name we are using with our object constructor instead.

So what has all this got to do with "prototype". Well with our methods we generally have the reverse situation to what I have just described for properties.

While we could have a separate copy of the methods for each object this is inefficient since we generally want the same methods to run the same code for each of our objects when those objects are all of the same "type". Our code is therefore much more efficient if when we copy objects we only copy the properties so as to be able to assign them separate values and we share the one copy of the methods between all of those objects.

Now we could define our methods inside the constructor the same way that we define the properties and use the object constructor's name instead of the "this" keyword when defining the methods. This would result in all of the objects created using that constructor sharing the same methods but the methods would be recreated every time we construct a new object. This is still inefficient.

A better way is to create the methods outside of the constructor and to do it in such a way that the methods that we create will be shared with any objects that we copy from the original object rather than being copied to each new object. That's where the "prototype" keyword comes in as this is what tells JavaScript to share the method with any objects copied from this object rather than taking a separate copy of the method. The one copy of a method defined using object.prototype.method will be shared with all of the new objects copied from that object rather than a separate copy of the method being made for each new object. This improves the efficiency of our code and also helps to make sure that you don't accidentally change what a particular method does for one object compared to what it does for similar objects.

All the Object Oriented JavaScript Tutorials

1. What is Object Oriented JavaScript?
2. The Benefits of OO JavaScript
3. JavaScript's Built in Objects
4. Extending Built In Objects
5. Creating Objects from Existing Objects
6. Creating New Objects Without Copying Existing Ones
7. Dot Notation and "this"
8. prototype
9. Inheritance and "constructor"
10. Associative Array Notation
11. Create Method if Doesn't Exist
12. "self" and Multiple Objects
13. Defining Objects with JSON
14. Namespaces
15. Lazy Definition
16. Extending Methods
17. Copying Objects
18. Private Properties and Privileged Methods
19. Public Access to Private Methods
20. Chaining Methods
21. Singletons