Prototypal Object-Oriented Programming utilizing JavaScript – A Record Aside

Douglas Crockford precisely described JavaScript because the world’s most misunderstood language. Plenty of programmers have a tendency to consider it as not a “correct” language as a result of it lacks the widespread object-oriented programming ideas. I personally developed the identical opinion after my first JavaScript mission ended up a hodgepodge, as I couldn’t discover a technique to manage code into lessons. However as we’ll see, JavaScript comes full of a wealthy system of object-oriented programming that many programmers don’t learn about.

Article Continues Beneath

Again within the time of the First Browser Warfare, executives at Netscape employed a sensible man known as Brendan Eich to place collectively a language that might run within the browser. Not like class-based languages like C++ and Java, this language, which was sooner or later known as LiveScript, was designed to implement a prototype-based inheritance mannequin. Prototypal OOP, which is conceptually completely different from the class-based methods, had been invented only a few years earlier than to unravel some issues that class-based OOP introduced and it match very properly with LiveScript’s dynamic nature.

Sadly, this new language needed to “seem like Java” for advertising and marketing causes. Java was the cool new factor within the tech world and Netscape’s executives wished to market their shiny new language as “Java’s little brother.” This appears to be why its identify was modified to JavaScript. The prototype-based OOP system, nevertheless, didn’t look something like Java’s lessons. To make this prototype-based system seem like a class-based system, JavaScript’s designers got here up with the key phrase new and a novel method to make use of constructor capabilities. The existence of this sample and the power to jot down “pseudo class-based” code has led to quite a lot of confusion amongst builders.

Understanding the rationale behind prototype-based programming was my “aha” second with JavaScript and resolved many of the gripes I had with the language. I hope studying about prototype-based OOP brings you an identical peace of thoughts it introduced me. And I hope that exploring a method that has not been absolutely explored excites you as a lot because it excites me.

Prototype-based OOP#section2

Conceptually, in class-based OOP, we first create a category to function a “blueprint” for objects, after which create objects based mostly on this blueprint. To construct extra particular forms of objects, we create “youngster” lessons; i.e., we make some modifications to the blueprint and use the ensuing new blueprint to assemble the extra particular objects.

For a real-world analogy, in case you have been to construct a chair, you’ll first create a blueprint on paper after which manufacture chairs based mostly on this blueprint. The blueprint right here is the category, and chairs are the objects. In case you wished to construct a rocking chair, you’ll take the blueprint, make some modifications, and manufacture rocking chairs utilizing the brand new blueprint.

Now take this instance into the world of prototypes: you don’t create blueprints or lessons right here, you simply create the thing. You’re taking some wooden and hack collectively a chair. This chair, an precise object, can operate absolutely as a chair and in addition function a prototype for future chairs. On this planet of prototypes, you construct a chair and easily create “clones” of it. If you wish to construct a rocking chair, all you must do is decide a chair you’ve manufactured earlier, connect two rockers to it, and voilà! You may have a rocking chair. You didn’t really want a blueprint for that. Now you possibly can simply use this rocking chair for your self, or maybe use it as a prototype to create extra rocking chairs.

JavaScript and prototype-based OOP#section3

Following is an instance that demonstrates this sort of OOP in JavaScript. We begin by creating an animal object:

var genericAnimal = Object.create(null);

Object.create(null) creates a brand new empty object. (We are going to focus on Object.create() in additional element later.) Subsequent, we add some properties and capabilities to our new object:

genericAnimal.description = operate() {
	return 'Gender: ' + this.gender + '; Identify: ' + this.identify;

genericAnimal is a correct object and can be utilized like one:

//Gender: feminine; Identify: Animal

We will create different, extra particular animals by utilizing our pattern object as a prototype. Consider this as cloning the thing, identical to we took a chair and created a clone in the actual world.

var cat = Object.create(genericAnimal);

We simply created a cat as a clone of the generic animal. We will add properties and capabilities to this:

cat.purr = operate() {
	return 'Purrrr!';

We will use our cat as a prototype and create a couple of extra cats:

var colonel = Object.create(cat);
colonel.identify="Colonel Meow";

var puff = Object.create(cat);

You can too observe that properties/strategies from dad and mom have been correctly carried over:

//Gender: feminine; Identify: Puffy

The new key phrase and the constructor operate#section4

JavaScript has the idea of a new key phrase used together with constructor capabilities. This function was constructed into JavaScript to make it look acquainted to folks educated in class-based programming. You might have seen JavaScript OOP code that appears like this:

operate Individual(identify) {
	this.identify = identify;
	this.sayName = operate() {
		return "Hello, I am " + this.identify;
var adam = new Individual('Adam');

Implementing inheritance utilizing JavaScript’s default technique seems extra difficult. We outline Ninja as a sub-class of Individual. Ninjas can have a reputation as they’re an individual, they usually also can have a major weapon, comparable to shuriken.

operate Ninja(identify, weapon) {, identify);
  this.weapon = weapon;
Ninja.prototype = Object.create(Individual.prototype);
Ninja.prototype.constructor = Ninja;

Whereas the constructor sample would possibly look extra engaging to an eye fixed that’s accustomed to class-based OOP, it’s thought-about problematic by many. What’s taking place behind the scenes is prototypal OOP, and the constructor operate obfuscates the language’s pure implementation of OOP. This simply seems like an odd method of doing class-based OOP with out actual lessons, and leaves the programmer questioning why they didn’t implement correct class-based OOP.

Because it’s not likely a category, it’s necessary to know what a name to a constructor does. It first creates an empty object, then units the prototype of this object to the prototype property of the constructor, then calls the constructor operate with this pointing to the newly-created object, and eventually returns the thing. It’s an oblique method of doing prototype-based OOP that appears like class-based OOP.

The issue with JavaScript’s constructor sample is succinctly summed up by Douglas Crockford:

JavaScript’s constructor sample didn’t enchantment to the classical crowd. It additionally obscured JavaScript’s true prototypal nature. In consequence, there are only a few programmers who know how you can use the language successfully.

The best technique to work with OOP in JavaScript is to know prototypal OOP, whether or not the constructor sample is used or not.

Understanding delegation and the implementation of prototypes#section5

To date, we’ve seen how prototypal OOP differs from conventional OOP in that there are not any lessons—solely objects that may inherit from different objects.

Each object in JavaScript holds a reference to its mother or father (prototype) object. When an object is created by means of Object.create, the handed object—meant to be the prototype for the brand new object—is about as the brand new object’s prototype. For the aim of understanding, let’s assume that this reference known as __proto__1. Some examples from the earlier code can illustrate this level:

The road under creates a brand new empty object with __proto__ as null.

var genericAnimal = Object.create(null); 

The code under then creates a brand new empty object with __proto__ set to the genericAnimal object, i.e. rodent.__proto__ factors to genericAnimal.

var rodent = Object.create(genericAnimal);

The next line will create an empty object with __proto__ pointing to rodent.

var capybara = Object.create(rodent);
//capybara.__proto__ factors to rodent
//capybara.__proto__.__proto__ factors to genericAnimal
//capybara.__proto__.__proto__.__proto__ is null

As we will see, each object holds a reference to its prototype. Object.create with out understanding what precisely it does, it’d seem like the operate truly “clones” from the mother or father object, and that properties of the mother or father are copied over to the kid, however this isn’t true. When capybara is created from rodent, capybara is an empty object with solely a reference to rodent.

However then—if we have been to name capybara.dimension proper after creation, we’d get S, which was the scale we had set within the mother or father object. What blood-magic is that? capybara doesn’t have a dimension property but. However nonetheless, once we write capybara.dimension, we one way or the other handle to see the prototype’s dimension property.

The reply is in JavaScript’s technique of implementing inheritance: delegation. After we name capybara.dimension, JavaScript first seems for that property within the capybara object. If not discovered, it seems for the property in capybara.__proto__. If it didn’t discover it in capybara.__proto__, it might look in capybara.__proto__.__proto__. This is called the prototype chain.

If we known as capybara.description(), the JavaScript engine would begin looking out up the prototype chain for the description operate and eventually uncover it in capybara.__proto__.__proto__ because it was outlined in genericAnimal. The operate would then be known as with this pointing to capybara.

Setting a property is just a little completely different. After we set capybara.dimension="XXL", a brand new property known as dimension is created within the capybara object. Subsequent time we attempt to entry capybara.dimension, we discover it instantly within the object, set to 'XXL'.

Because the prototype property is a reference, altering the prototype object’s properties at runtime will have an effect on all objects utilizing the prototype. For instance, if we rewrote the description operate or added a brand new operate in genericAnimal after creating rodent and capybara, they’d be instantly accessible to be used in rodent and capybara, due to delegation.

Creating Object.create#section6

When JavaScript was developed, its default method of making objects was the key phrase new. Then many notable JavaScript builders campaigned for Object.create, and finally it was included in the usual. Nonetheless, some browsers don’t assist Object.create (you already know the one I imply). For that cause, Douglas Crockford recommends together with the next code in your JavaScript purposes to make sure that Object.create is created if it isn’t there:

if (typeof Object.create !== 'operate') {
	Object.create = operate (o) {
		operate F() {}
		F.prototype = o;
		return new F();

Object.create in motion#section7

In case you wished to increase JavaScript’s Math object, how would you do it? Suppose that we wish to redefine the random operate with out modifying the unique Math object, as different scripts is perhaps utilizing it. JavaScript’s flexibility offers many choices. However I discover utilizing Object.create a breeze:

var myMath = Object.create(Math);

Couldn’t probably get any easier than that. You would, in case you choose, write a brand new constructor, set its prototype to a clone of Math, increase the prototype with the capabilities you want, after which assemble the precise object. However why undergo all that ache to make it seem like a category, when prototypes are so easy?

We will now redefine the random operate in our myMath object. On this case, I wrote a operate that returns random complete numbers inside a spread if the consumer specifies one. In any other case, it simply calls the mother or father’s random operate.

myMath.random = operate() {
	var uber = Object.getPrototypeOf(this);
if (typeof(arguments[0]) === 'quantity' && typeof(arguments[1]) === 'quantity' && arguments[0] < arguments[1]) {
		var rand = uber.random();
		var min = Math.ground(arguments[0]);
		var max = Math.ceil(arguments[1]);
		return this.spherical(rand * (max - min)) + min;
	return uber.random();

There! Now myMath.random(-5,5) will get you a random complete quantity between −5 and 5, whereas myMath.random() will get the same old. And since myMath has Math as its prototype, it has all of the performance of the Math object constructed into it.

Class-based OOP vs. prototype-based OOP#section8

Prototype-based OOP and class-based OOP are each nice methods of doing OOP; each approaches have professionals and cons. Each have been researched and debated within the educational world since earlier than I used to be born. Is one higher than the opposite? There isn’t any consensus on that. However the important thing factors everybody can agree on are that prototypal OOP is easier to know, extra versatile, and extra dynamic.

To get a glimpse of its dynamic nature, take the next instance: you write code that extensively makes use of the indexOf operate in arrays. After writing all of it down and testing in an excellent browser, you grudgingly try it out in Web Explorer 8. As anticipated, you face issues. This time it’s as a result of indexOf is just not outlined in IE8.

So what do you do? Within the class-based world, you possibly can resolve this by defining the operate, maybe in one other “helper” class which takes an array or Record or ArrayList or no matter as enter, and changing all of the calls in your code. Or maybe you possibly can sub-class the Record or ArrayList and outline the operate within the sub-class, and use your new sub-class as a substitute of the ArrayList.

However JavaScript and prototype-based OOP’s dynamic nature makes it easy. Each array is an object and factors to a mother or father prototype object. If we will outline the operate within the prototype, then our code will work as is with none modification!

if (!Array.prototype.indexOf) {
	Array.prototype.indexOf = operate(elem) {
		//Your magical repair code goes right here.

You are able to do many cool issues when you ditch lessons and objects for JavaScript’s prototypes and dynamic objects. You may prolong present prototypes so as to add new performance—extending prototypes like we did above is how the well-known and aptly named library Prototype.js provides its magic to JavaScript’s built-in objects. You may create all types of attention-grabbing inheritance schemes, comparable to one which inherits selectively from a number of objects. Its dynamic nature means you don’t even run into the issues with inheritance that the Gang of 4 e book famously warns about. (Actually, fixing these issues with inheritance was what prompted researchers to invent prototype-based OOP—however all that’s past our scope for this text.)

Class-based OOP emulation can go fallacious#section9

Take into account the next quite simple instance written with pseudo-classes:

operate Animal(){

Animal.prototype.makeBaby = operate(){ 
    var child = new Animal();
    return child;

//create Cat as a sub-class of Animal
operate Cat() {

//Inherit from Animal
Cat.prototype = new Animal();

var puff = new Cat();
var colonel = new Cat();

The instance seems harmless sufficient. That is an inheritance sample that you will note in lots of locations all around the web. Nonetheless, one thing humorous is occurring right here—in case you test colonel.offspring and puff.offspring, you’ll discover that every of them accommodates the identical two infants! That’s most likely not what you supposed—until you’re coding a quantum physics thought experiment.

JavaScript tried to make our lives simpler by making it seem like we have now good previous class-based OOP happening. Nevertheless it seems it’s not that straightforward. Simulating class-based OOP with out utterly understanding prototype-based OOP can result in sudden outcomes. To know why this drawback occurred, it’s essential to perceive prototypes and the way constructors are only one technique to construct objects from different objects.

What occurred within the above code could be very clear in case you suppose when it comes to prototypes. The variable offspring is created when the Animal constructor known as—and it’s created within the Cat.prototype object. All particular person objects created with the Cat constructor use Cat.prototype as their prototype, and Cat.prototype is the place offspring resides. After we name makeBaby, the JavaScript engine searches for the offspring property within the Cat object and fails to seek out it. It then finds the property in Cat.prototype—and provides the brand new child within the shared object that each particular person Cat objects inherit from.

So now that we perceive what the issue is, due to our information of the prototype-based system, how can we resolve it? The answer is that the offspring property must be created within the object itself somewhat than someplace within the prototype chain. There are numerous methods to unravel it. A method is that makeBaby ensures that the thing on which the operate known as has its personal offspring property:

	var child=new Animal(); 
		this.offspring=[]; }
	return child;

Spine.js runs into an identical lure. In Spine.js, you construct views by extending the bottom Spine.View “class.” You then instantiate views utilizing the constructor sample. This mannequin is superb at emulating class-based OOP in JavaScript:

//Create a HideableView "sub-class" of Spine.View
var HideableView = Spine.View.prolong({
    el: '#hideable', //the view will bind to this selector
    occasions : {
        'click on .cover': 'cover'
    //this operate was referenced within the click on handler above
    cover: operate() {
      //cover the complete view

var hideable = new HideableView();

This seems like easy class-based OOP. We inherited from the bottom Spine.View class to create a HideableView youngster class. Subsequent, we created an object of sort HideableView.

Since this seems like easy class-based OOP, we will use this performance to conveniently construct inheritance hierarchies, as proven within the following instance:

var HideableTableView = HideableView.prolong({
    //Some view that's hideable and rendered as a desk.

var HideableExpandableView = HideableView.prolong({
    initialize: operate() {
        //add an develop click on handler. We didn’t create a separate
        //occasions object as a result of we have to add to the
        //inherited occasions.
        this.occasions['click .expand'] = 'develop';
    develop: operate () {
    	//deal with develop

var desk = new HideableTableView();
var expandable = new HideableExpandableView();

This all seems good when you’re pondering in class-based OOP. However in case you attempt desk.occasions['click .expand'] within the console, you will note “develop”! In some way, HideableTableView has an develop click on handler, regardless that it was by no means outlined on this class.

You may see the issue in motion right here:

The issue above occurred due to the identical cause outlined within the earlier instance. In Spine.js, you might want to work in opposition to the indirection created by attempting to make it seem like lessons, to see the prototype chain hidden within the background. When you comprehend how the prototype chain could be structured, it is possible for you to to discover a easy repair for the issue.

Regardless of prototypal OOP underpinning probably the most well-liked languages on the market at the moment, programmers are largely unfamiliar with what precisely prototype-based OOP is. JavaScript itself could also be partly accountable due to its makes an attempt to masquerade as a class-based language.

This wants to alter. To work successfully with JavaScript, builders want to know the how and why of prototype-based programming—and there’s far more to it than this text. Past mastering JavaScript, in studying about prototype-based programming you may as well study quite a lot of issues about class-based programming as you get to match and distinction the 2 completely different strategies.

Douglas Crockford’s word on protoypal programming was written earlier than Object.create was added to the usual.

An article on IBM’s developerWorks reinforces the identical level on prototypal OOP. This text was the prototypal “aha” second for me.

The next three texts might be attention-grabbing reads in case you’re keen to dive into the educational roots of prototype-based programming:

Henry Lieberman of MIT Media Labs compares class-based inheritance with prototype-based delegation and argues that prototype-based delegation is the extra versatile of the 2 ideas.

Lessons versus Prototypes in Object-Oriented Languages is a proposal to make use of prototypes as a substitute of lessons by the College of Washington’s Alan Borning.

Lieberman’s and Borning’s work within the Eighties seems to have influenced the work that David Ungar and Randall Smith did to create the primary prototype-based programming language: Self. Self went on to grow to be the premise for the prototype-based system in JavaScript. This paper describes their language and the way it omits lessons in favor of prototypes.

Leave a Comment