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
There are several things that you can’t emulate from the ECMAScript 5 Object.create method on an ECMAScript 3 environment. As you saw, the properties argument will give you problems since in E3-based implementations there is no way to change the property attributes. The Object.defineProperty method as @Raynos mentioned, works on IE8, but partially, it can … Read more
When using constructor functions for inheritance in JavaScript, you: Make the prototype property of the “derived” constructor an object whose prototype is the prototype property of the “base” constructor. Set the constructor property on the “derived” constructor’s prototype property to point to the “derived” constructor. Call the “base” constructor from the “derived” constructor with the … Read more
I’m not sure this will answer your question but may give you some insight. Consider the following example: var Person = (function () { var Person = function (name) { this.name = name; } Person.greet = function () { console.log(“Hello!”); } Person.prototype = { greet: function () { console.log(‘Hello, my name is ‘ + this.name); … 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
__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
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 you will break that other code. When it comes adding … Read more
There is no inconsistency. Just don’t think of nested objects: a direct property of an object is always either on its prototype or an own property. It’s irrelevant wheter the property value a primitive or an object. So, when you do var parent = { x: {a:0} }; var child = Object.create(parent); child.x will be … Read more
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