The biggest reason not to use the 2nd form is that you’ll end up eliminating anything else that existed in the prototype before you assign it. If that isn’t something you’re concerned with there’s no reason not to declare it the way you’ve demonstrated.
Classical inheritance is about extending types of things. Say you have a class, like Bike. When you want extend the behaviour, you have to design a new type of bike (like MotorBike). It’s like building a factory – you make lots of blueprints, and blueprints that reference those blueprints, but in order to ride one … Read more
Think of it like this. MyConstructor is a function object, so it was created by Function; therefore its [[Prototype]] (or __proto__) is identical to Function.prototype. In the same way, var myObj = new MyConstructor() creates an object myObj with a [[Prototype]] identical to MyConstructor.prototype. To put it another way, functions have a prototype property, and … Read more
One case where the constructor property is handy (or would be if it was reliable) is where a function needs to know the type of argument it has been passed, e.g. function foo(arg) { if ( /* if arg is an array */ ) { // deal with array } else if ( /* if … Read more
The answer to the real question is that you need to do both: Setting the prototype to an instance of the parent initializes the prototype chain (inheritance), this is done only once (since the prototype object is shared). Calling the parent’s constructor initializes the object itself, this is done with every instantiation (you can pass … Read more
This is a very bad idea, for a great number of reasons. A few of which are: Adding methods to the prototype in the constructor will cause the prototype method to be replaced for all instances, everytime you instantiate a new Dog. Calling Dog.prototype.bark() means that this will be Dog.prototype and not your instance of … Read more
Note: It’s considered a bad practice to change the value of __proto__. Doing so is strongly discouraged by Brendan Eich, the creator of JavaScript, amongst others. In fact the __proto__ property has been removed entirely from a few JavaScript engines like Rhino. If you wish to know why then read the following comment by Brendan … Read more
You can actually add another level of privilege via wrapping the whole thing in a self-executing function: var MyObj = (function() { // scoping var privateSharedVar=”foo”; function privateSharedFunction() { // has access to privateSharedVar // may also access publicSharedVar via explicit MyObj.prototype // can’t be called via this } function MyObj() { // constructor var … Read more
Prototypal inheritance is a form of object-oriented code reuse. Javascript is one of the only [mainstream] object-oriented languages to use prototypal inheritance. Almost all other object-oriented languages are classical. In classical inheritance, the programmer writes a class, which defines an object. Multiple objects can be instantiated from the same class, so you have code in … Read more
To add to Norbert Hartl’s answer, SuperCar.prototype.constructor isn’t needed, but some people use it as a convenient way of getting the constructing function of an object (SuperCar objects in this case). Just from the first example, Car.call(this, name) is in the SuperCar constructor function because when you do this: var mySuperCar = new SuperCar(“SuperCar”); This … Read more