What happens when you change an object's prototype?

Question

What happens when we do:

Cat.prototype = new Mammal();

My guess is that, besides changing __proto__, nothing really happens, and Cat.prototype is not changed. Or if it is, then properties are copied to it, and it's not replaced by the new object we just created.

Any ideas?

this is it: the mistake was using myCat.prototype which is undefined... when you check Cat.prototype you can see that it is replaced too

var myCat = new Cat();    
alert(myCat.__proto__ instanceof Mammal); // true
alert(myCat.__proto__ instanceof Cat);    // false

alert(Cat.prototype instanceof Mammal); // true 
alert(Cat.prototype instanceof Cat);    // false

we don't want to call new here, you are right, cause that will cause object members of Mammal instance to be prototype members of Cat. (the constructor of Mammal is called and create its members as the prototype members where they are shared by all Cat objects)

If you set the prototype of one constructor to an instance of another you may not fully understand the role of the constructor function and the prototype. More info here: http://stackoverflow.com/a/16063711/1641941 — HMR, Dec 29 '14 at 08:11
This can be a bit confusing, but the `Cat.prototype` property doesn't point to the prototype of `Cat`. It points to an object which will be the prototype of objects created by invoking `new Cat()` — Ismail Badawi, Dec 29 '14 at 08:11
this is an example from "javascript the good parts". im new to this language and env. how can i check this by myself ? — yael alfasi, Dec 29 '14 at 11:48
Try the link I put in the other reply. "the good parts" is by Douglass Crockford, I have never seen this man correctly show how to use constructor functions and prototype so maybe not a good reference to start learning. When you understand the link I've posted then the following is a good reference too: https://github.com/getify/You-Dont-Know-JS — HMR, Dec 29 '14 at 12:04
After setting Cat.prototype you can do `Cat.prototype.constructor = Cat;` then myCat would be both an instance of Mammal and Cat. — HMR, Dec 29 '14 at 13:55

Ry- · Accepted Answer · 2014-12-29T08:20:22.870

4

my guess is that besides changing proto nothing really happens and Cat.prototype is not changed or if it is then properties are copied to it and its not replaced by the new object we just created

No, it is definitely completely replaced.

function Mammal() {
}

function Cat() {
}

Cat.prototype.meow = function () {
    console.log('Meow!');
};

Cat.prototype = new Mammal();

new Cat().meow(); // “TypeError: undefined is not a function” or equivalent

(Cat.prototype = Object.create(Mammal); would be the better way to inherit Mammal, by the way.)

edited Dec 29 '14 at 08:20

answered Dec 29 '14 at 08:10

Ry-

218,210
55
464
476

@yaelalfasi: I suppose I’m not sure what your question is, then. `myCat.prototype` doesn’t exist at all, by the way. Did you mean `myCat.constructor`? (And yes, it replaces the prototype with a `Mammal` completely; that’s why `myCat.constructor === Mammal` and not `Cat`. You need to assign `Cat.prototype.constructor = Cat;` after making the replacement.) – Ry- Dec 30 '14 at 17:08
1

@yaelalfasi: `myCat.prototype === undefined`. Only functions have a `prototype`. – Ry- Dec 30 '14 at 20:17

score 0 · Answer 2 · edited May 23 '17 at 10:33

Object instances do not have a member called prototype unless they are functions (var f = new Function() is a Function instance). It is explained in the link I posted in the comment and this answer.

Instanceof can depend on when you replace the prototype and the __proto__ for instances created by the same constructor function can be different.

var pr = {
  speak:function(){
    console.log('I am the original');
  }
};

var Animal = function(){};
Animal.prototype = pr;

var original = new Animal();
//Now we de reference the prototype of Animal
//  this will cause instances already created to
//  still use original but new instances will use the copy
Animal.prototype = {
  speak:function(){
    console.log('I am changed');
  }
};
var changed = new Animal();
console.log(original.speak());//=I am the original
console.log(changed.speak());//=I am changed

A much simpler example (without using prototype) shows what is going on here:

var org = {name:'org'};
var copy = org;//org and copy point to the same object
console.log(copy === org);//true
copy.name='first change';//mutating copy will affect org 
  //because they point to the same object
console.log(org.name);//=first change
copy = {name:'de reference'};//re assigning copy will de reference copy
  //copy no longer points to the same object as org
console.log(copy === org);//=false
console.log(org.name);//=first change

So when prototype is involved something similar happens.

The Animal instance stored in original uses pr as it's prototype but the Animal instance changed does not, the reason why original still uses pr is because we de referenced the prototype. When you mutate the prototype something different happens. Based on the simpler example above you may guess what that is.

It is not advisable to re assign the prototype after creating instances as this could negatively affect optimization and confuse anyone trying to maintain your code.

More info on prototype and inheritance patterns can be found here:

https://stackoverflow.com/a/16063711/1641941

in your link they still change the prototype only using a different method. i don't see how you can use inheritance without changing the prototype — yael alfasi, Dec 30 '14 at 16:20
they do this {RussionMini.prototype=Object.create(Hamster.prototype); RussionMini.prototype.constructor=RussionMini;} — yael alfasi, Dec 30 '14 at 16:21
@yaelalfasi Yes, you need to re assign and mutate the prototype during the declaration of the type but it is better not do re assigning after creating instances as I am doing in the example. Updated the answer a little. — HMR, Dec 30 '14 at 23:09

What happens when you change an object's prototype?

2 Answers2