The problem is that Inventory.prototype.defaults and Extended.prototype.defaults has the same reference, because you have not override the reference. So you can do this in 2 ways, maybe more but i only found this 2: Edit: The first example is incorrect (see comments); please refer to the second. var ExtendedInventory = Inventory.extend({ defaults: { rabit:25 } … Read more
You are messing with the SubClass‘s prototype with the SuperClass‘s object, in this line SubClass.prototype = new SuperClass(); the child’s prototype should depend on the Parent’s prototype. So, you can inherit like this SubClass.prototype = Object.create(SuperClass.prototype); Also, it is quite normal to change the constructor to the actual function, like this SubClass.prototype.constructor = SubClass; To … Read more
I don’t think the constructor/factory logic is necessary at all, as long as you change how you think about Object-Oriented Programming. In my recent exploration of the topic, I’ve discovered that Prototypical inheritance lends itself more to defining a set of functions that use particular data. This isn’t a foreign concept to those trained in … Read more
I hope that I’m understanding this right. I believe you want a functor that’s both an instance of a predefined prototype (yes, a class, just not a classic class) as well as directly callable? Right? If so, then this makes perfect sense and is very powerful and flexible (especially in a highly asynchronous environment like … Read more
var f = function(); var instance = new f(); If you know name of instance class function, you can simply access prototype as: var prototype = f.prototype; prototype.someMember = someValue; If you don’t: 1) var prototype = Object.getPrototypeOf(instance); prototype.someMember = someValue; 2) or var prototype = instance.__proto__; prototype.someMember = someValue; 3) or var prototype = … Read more
As mentioned, the movies by Douglas Crockford give a good explanation about the why and it covers the how. But to put it in a couple of lines of JavaScript: // Declaring our Animal object var Animal = function () { this.name=”unknown”; this.getName = function () { return this.name; } return this; }; // Declaring … Read more
Is there any practical difference [between my examples]? The user may have a JavaScript object created with Object.create(null), which will have a null [[Prototype]] chain, and therefore won’t have hasOwnProperty() available on it. Using your second form would fail to work for this reason. It’s also a safer reference to Object.prototype.hasOwnProperty() (and also shorter). You … Read more
When you extend an object, you change its behaviour. Changing the behaviour of an object that will only be used by your own code is fine. But when you change the behaviour of something that is also used by other code there is a risk that you will break that other code. When method are … Read more
__proto__ is the actual object that is used in the lookup chain to resolve methods, etc. prototype is the object that is used to build __proto__ when you create an object with new: ( new Foo ).__proto__ === Foo.prototype ( new Foo ).prototype === undefined
Quick answer: A child scope normally prototypically inherits from its parent scope, but not always. One exception to this rule is a directive with scope: { … } — this creates an “isolate” scope that does not prototypically inherit. This construct is often used when creating a “reusable component” directive. As for the nuances, scope … Read more