prototypal-inheritance

To implement inheritance in Javascript, one generally does the following 2 steps; Say I have a base class "Animal" var Animal = function(name){ this.name = name; } I now want to derive a sub class "Dog" from the same. So I would say var Dog = function(name) { Animal.call(this,name); } So I am calling my parent class constructor from my derived class constructor. The 2nd step is to set the prototype as follows; Dog.prototype = new Animal(); Now I can access any of the base "Animal" class properties from within my derived class Dog. So my question is why are these 2 steps necessary ? If we just

perf Why do we build a prototype inheritance chain rather then using object composition. Looking up through the prototype for each step in the chain get's expensive. Here is some dummy example code : var lower = { "foo": "bar" }; var upper = { "bar": "foo" }; var chained = Object.create(lower, pd(upper)); var chainedPrototype = Object.create(chained); var combinedPrototype = Object.create(pd.merge(lower, upper)); var o1 = Object.create(chainedPrototypes); var o2 = Object.create(combinedPrototypes); uses pd because property descriptors are verbose as hell. o2.foo is faster then o1.foo since it

I was reading on javascript garden http://bonsaiden.github.com/JavaScript-Garden/ about prototype in javascript and one of its example goes like this: function Foo() { this.value = 42; } Foo.prototype = { method: function() {} }; function Bar() {} // Set Bar's prototype to a new instance of Foo Bar.prototype = new Foo(); Bar.prototype.foo = 'Hello World'; // Make sure to list Bar as the actual constructor <------------------- Bar.prototype.constructor = Bar; Notice the line that reads Make sure to list Bar as the actual constructor. I really am lost about what this does/is. I have tried making

There are lots of articles and posts explaining how JavaScript inheritance works, but why was JavaScript implemented using prototypal inheritance instead of classical inheritance? I love JavaScript, so I'm not saying it's bad thing... I'm just curious. Here's what Brendan Eich has to say about what happened: http://weblogs.mozillazine.org/roadmap/archives/2008/04/popularity.html As I've often said, and as others at Netscape can confirm, I was recruited to Netscape with the promise of "doing Scheme" in the browser. At least client engineering management including Tom Paquin, Michael Toy, and

Everyone seems to generally agree that prototype inheritance is simpler and more flexible than class inheritance. What I have not seen in the literature that I've read is very many examples of things that you can do with prototype inheritance that you cannot with classical. So I pose a simple question: What are some patterns that you can use with prototype inheritance that you cannot with class inheritance and what is the guidance you would give as far when/if to use it? One difference (perhaps at least conceptually) is that class inheritance implies that the child IS-A type of the parent.