Prototypical inheritance without creating a parent object

Question

So I was reading the book Head First Javascript Programming, which is a great book btw, learned me a lot, when I stumbled into the subject of multiple inheritance.

The book taught me that to achieve multiple inheritance you should set the prototype of your constructor to a new object of your parent.

As an example:

    //Parent
    function Dog (name){
       this.name = name; 
    };



   //Child
   function AwesomeDog(name){
      Dog.call(this, name);
   };
   AwesomeDog.prototype = new Dog();
   AwesomeDog.prototype.constructor = AwesomeDog;
   AwesomeDog.prototype.isAwesome = true;

Now I don't agree that this is the best way to do it, you call the Dog constructor only for its prototype property, but you also get the name property with it, that you will typically never use and therefore always be undefined.

Why not just do this:

 AwesomeDog.prototype = Dog.prototype;

You're only interested in the prototype anyway so why not?

In my opinion this is better because of 2 reasons:

The overhead of creating a new object is left out (insignificant, but it's something)
You don't have useless properties floating around in your child's prototype, that will probably always remain undefined.

Now this book has been brilliant in every way so that led me to believe that I perhaps missed something crucial, but I can not see what. I can not imagine any use cases where having double properties (one in the child object and the undefined version in your prototype) can be useful.

Is my way of thinking correct and can I stick with my method?

[Benefits of using `Object.create` for inheritance](http://stackoverflow.com/q/17392857/218196) should answer your question(s). Also this is normal inheritance, not "multiple inheritance". — Felix Kling, Mar 06 '15 at 18:08
`AwesomeDog.prototype.constructor = AwesomeDog.constructor` is a bit strange. By default, functions have no own `constructor` property, so it will be inherited from `Function.prototype.constructor`, which is `Function`. — Oriol, Mar 06 '15 at 18:08
Its because its constructor property will be set to Dog's constructor property by assigning new Dog to prototype — Robin-Hoodie, Mar 06 '15 at 18:10
@RobinHellemans: No, it will be set to the constructor property of an **instance** of `Dog`, i.e. `Dog.prototype.constructor`, which is `Dog`. As Orial mentioned, `AwesomeDog.constructor` is `Function` because `AwesomeDog` is a function. What you want is `AwesomeDog.prototype.constructor = AwesomeDog;` — Felix Kling, Mar 06 '15 at 18:11

score 1 · Answer 1 · answered Mar 06 '15 at 18:04

Object inheritance in JavaScript is also the basis of constructor inheritance. Every function has a prototype property that can be modified or replaced. That prototype property is automatically assigned to be a new generic object that inherits from Object.prototype and has a single own property called constructor. In effect, the JavaScript engine does the following for you:

// you write this
function YourConstructor() {
    // initialization
}

// JavaScript engine does this for you behind the scenes
YourConstructor.prototype = Object.create(Object.prototype, {
    constructor: {
        configurable: true,
        enumerable: true,
        value: YourConstructor
        writable: true
    }
});

So without doing anything extra, this code sets the constructor’s prototype property to an object that inherits from Object.prototype, which means any instances of YourConstructor also inherit from Object .prototype. YourConstructor is a subtype of Object, and Object is a supertype of YourConstructor.

score 0 · Accepted Answer · answered Mar 06 '15 at 18:05

Now I don't agree that this is the best way to do it, you call the Dog constructor only for its prototype property, but you also get the name property with it, that you will typically never use and therefore always be undefined.

You are completely right. Using new has these problems, and thus is discouraged.

Why not just do this:
AwesomeDog.prototype = Dog.prototype;

This has a problem: both AwesomeDog and Dog instances share the same prototype. Therefore, they will inherit the same properties and methods, so there is no point in subclassing. And which should the constructor be, AwesomeDog or Dog?

Instead, the proper way is assigning AwesomeDog.prototype to an object which inherits from Dog.prototype, but without calling Dog. You can do this with Object.create:

AwesomeDog.prototype = Object.create(Dog.prototype);
AwesomeDog.prototype.constructor = AwesomeDog;

You're right, I didn't realize my error in time, I will also take a look at the question you provided — Robin-Hoodie, Mar 06 '15 at 18:11

Prototypical inheritance without creating a parent object

2 Answers2