prototypal-inheritance

Here are a few examples. // case 1: var obj1 = {msg : 'Hello'}; var obj2 = obj1; obj2.msg = "Hi!"; //overwrites alert(obj1.msg); //=>'Hi!' // case 2: var obj1 = {msg : 'Hello'}; var obj2 = Object.create(obj1); obj2.msg = "Hi!"; //does not overwrite alert(obj1.msg); //=>'Hello' // case 3: var obj1 = {data: { msg : 'Hello'}} var obj2 = Object.create(obj1); obj2.data.msg = "Hi!"; //overwrites, Why? alert(obj1.data.msg); //=>'Hi!' I think Object.create() just gives both makes both point to the same prototype, while assignment makes both object point to same location(not just prototype). But then

Initial Question Yesterday i read about ECMAScript 5 Object.create() And I wanted to start building prototype Chains in my Code with this method instead of setting the prototype and its constructor, I like that you can directly set writable configurable etc.. I tried it like this function printobject(msg, obj) { if (msg) { document.write("<b>" + msg + "</b><br>"); document.write("<hr><br>"); } for (var prop in obj) { if (obj.hasOwnProperty(prop)) { if (obj[prop].toString() !== "[object Object]") { document.write(prop + " : " + obj[prop] + "<br>"); } else { document.write("<b>" + prop + " : " +

I'm not very well aquainted with javascript inheritance, and I'm trying to make one object inherit from another, and define its own methods: function Foo() {} Foo.prototype = { getColor: function () {return this.color;}, }; function FooB() {} FooB.prototype = new Foo(); FooB.prototype = { /* other methods here */ }; var x = new FooB().getColor(); However, the second one overwrites the first one( FooB.prototype = new Foo() is cancelled out ). Is there any way to fix this problem, or am I going in the wrong direction? Thanks in advance, sorry for any bad terminology. Each object can only have

I am looking at this article regarding the node.js events module: http://www.sitepoint.com/nodejs-events-and-eventemitter/ And in it there is this code: Door.prototype.__proto__ = events.EventEmitter.prototype; Which supposedly sets the prototype of the Door object to the prototype of the event.EventEmitter. I believe I know what is the difference between prototype and proto but this code completely confuses me. So my questions is whether instead of using: Door.prototype.__proto__ = events.EventEmitter.prototype; The author of the article did not just use this line of code: Door.prototype=

Let's say I have the following code; var A = {a:10}; var B = {b:20}; B.prototype = A; alert(B.a); I am getting undefined for B.a . Am I doing something wrong? How do I set the prototype for object literal ? I know how to do for Constructor object. So the following code works perfect function A(){this.a=10} function B(){this.b=20} B.prototype = new A(); b = new B; alert(b.a); How do I do it for object literal ? Objects inherit from their constructor's prototype property, not their own. The constructor's prototype is assigned to the internal [[Prototype]] property that is available in some

You know Javascript is a prototype-based programming language . I have read some books about Javascript and its prototypal inheritance concept but: "If you can't explain it to a six-year old, you really don't understand it yourself.”. Well, I tried to explain JavaScript prototype concept to a 22-year old friend and completely failed! How would you explain it to a 6-year old person that is strangely interested in that subject? I have seen some examples given in Stack Overflow, and it did not help. Classical inheritance is about extending types of things. Say you have a class, like Bike . When

There are only 3 lines of code, and yet I'm having trouble fully grasping this: Object.create = function (o) { function F() {} F.prototype = o; return new F(); }; newObject = Object.create(oldObject); (from Prototypal Inheritance ) Object.create() starts out by creating an empty function called F . I'm thinking that a function is a kind of object. Where is this F object being stored? Globally I guess. Next our oldObject , passed in as o , becomes the prototype of function F . Function (i.e., object) F now "inherits" from our oldObject , in the sense that name resolution will route through it.

TL;DR: Do we need factories/constructors in prototypical OO? Can we make a paradigm switch and drop them completely? The BackStory: I've been toying with doing prototypical OO in JavaScript lately and find that 99% of OO done in JavaScript is forcing classical OO patterns into it. My take on prototypical OO is that it involves two things. A static prototype of methods (and static data) and a data binding. We don't need factories or constructors. In JavaScript these are Object literals containing functions and Object.create . This would mean we can model everything as a static blueprint