2

Normally when we create a new object using "new" keyword, actually the __proto__ property of the created object is pointing to the prototype property of the parent class. We can test this as below : 

function myfunc(){};
myfunc.prototype.name="myfunction";
var child= new myfunc();
child.__proto__=== myfunc.prototype  ---> true

But let's see what happens when I change the prototype of the parent function: 

myfunc.prototype={};
child.__proto__=== myfunc.prototype  ---> false
child.name   ------> "myfunction"

So if child.__proto__ isn't pointing to the myfunc.prototype, so where it is pointing in objects chain? More important if it doesn't point to the myfunc.prototype, then how it has access to the "name" property of myfunc class?

thefourtheye
  • 233,700
  • 52
  • 457
  • 497
Amir Jalilifard
  • 2,027
  • 5
  • 26
  • 38
  • 2
    The `child` is still referencing the original `prototype` object before it was replaced. Instances don't point back to their constructor's `prototype` property; they refer to the object itself with their own `[[Prototype]]` property (which `__proto__` is a getter/setter of). – Jonathan Lonowski Jun 05 '15 at 20:51
  • See this question: http://stackoverflow.com/questions/9959727/proto-vs-prototype-in-javascript – Achrome Jun 05 '15 at 20:52
  • Ok. The where it is pointing now? There should be an object that the child.__proto__ is pointing now. – Amir Jalilifard Jun 05 '15 at 20:53
  • @ Achrome I've read this question millions of time – Amir Jalilifard Jun 05 '15 at 20:54

1 Answers1

3

When you are using new operator to create an Object, a new JavaScript Object will be created and its internal __proto__ property will be set to the prototype of the function.

At this point

console.log(myfunc.prototype);

is referring to the object

{ name: 'myfunction' }

So, when you do

var child = new myfunc();

internally

child.__proto__ = myfunc.prototype;

is happening. Now, the important thing to understand here is, in JavaScript, when you use assignment operator, the left hand side name will be just made to refer the result of the right hand side expression. So, in this case, child.__proto__ is just another name for the object referred by the name myfunc.prototype. Now, both child.__proto__ === myfunc.prototype and are referring to { name: 'myfunction' }. That is why child.__proto__ === myfunc.prototype is returning true.

Now, when you do

myfunc.prototype = {};

you are making myfunc.prototype refer the new object {}, but the child.__proto__ is still referring to the old object { name: 'myfunction' }. That is why child.__proto__ === myfunc.prototype returns false and child.name still says myfunction.

thefourtheye
  • 233,700
  • 52
  • 457
  • 497