Quick Javascript inheritance: Understanding __prot

Question

Given the following constructor,

Dog = function(name, age, ...){
    Animal.call(this, name, age, ...);
    // And some other stuff that dogs do
}

I use the following line of code to copy my methods and properties across from the Animal class,

Dog.prototype = new Animal();

Could you enlighten me as to how that differs from

Dog.prototype.__proto__ = Animal.prototype;

since they seem to have the same effect.

Answer 1

__proto__ lets you access the internal [[Prototype]] attribute of an object. It can be used to get or set the prototype of an already existing object.

protoype is a property of a function to set the prototype of objects that will be created by that function.

Afaik, only Firefox lets you use __proto__. It is not standard and deprecated.

---

Worth reading:

• MDC - Inheritance and the constructor's prototype
• MDC - Inheritance revisited

Answer 2

__proto__ is a non-standard extension to JavaScript (common in various interpreters, but non-standard) that gives you direct access to the prototype behind an object. The prototype property of function objects is the object that will be assigned as the prototype behind an object created by calling the function via new. So when you assign to prototype.__proto__, you're assigning to the prototype behind the object that will be set as the prototype on new objects created by the function.

Since the way the prototype chain works is that properties on a prototype show up as inherited properties on an object (and this continues in a chain), if you assign to Dog.prototype.__proto__, the objects created by Dog will have access to those properties indirectly through the chain:

+-----------------+      +----------------+      +-------------------------+
| instance of Dog |----->| Dog.prototype  |----->| Dog.prototype.__proto__ |
|                 |      |                |      | `foo` property          |
|                 |      |                |      | `bar` property          |
+-----------------+      +----------------+      +-------------------------+

When you assign directly to Dog.prototype, the instances have a more direct reference:

+-----------------+      +----------------+
| instance of Dog |----->| Dog.prototype  |
|                 |      | `foo` property |
|                 |      | `bar` property |
+-----------------+      +----------------+

(Note that the above is slightly misleading by referring to Dog.prototype like that. Instances of Dog will get a direct reference to the object on Dog.prototype as of when new Dog is called; if you assign a completely different object to Dog.prototype later, instances that already exist will have the old prototype and new instances will get the new one. But that's a side-point.)