Several details of js prototype chain inheritance

1. How to implement only inheriting prototype

First look at the following code:

function A(){
 this.name="李可可";
 this.age=21;
}
A.prototype.eat=function(){ console.log("I can eat") }
function B(){}
B.prototype=new A;//B继承了A
var cc=new B;
cc.eat();//I can eat
cc.name;//"李可可"

What we can see is that A inherits all the attributes of B, then if we only want B to inherit the A.prototype attributes, we don’t want A There are a lot of useless things like name and age above, so what should I do?

Some people may have said, wouldn’t it be enough just like this:

B.prototype=A.prototype;
var cc=new B;
cc.eat();//I can eat
cc.name;//undefined

yo, it seems perfect? Let’s continue to look at

B.prototype.fuck=function(){console.log("I fuck you!")}
var cc=new B,dd=new A;
cc.fuck();//I fuck you!
dd.fuck();//I fuck you!
//哦买噶的，怎么两个人都学会骂人了
//当子类B的prototype发生变化时也会影响到A的prototype(当然反过来也是)，原因也很简单，因为我们让A.prototype指向了B的prototype

Solution:

Build a function, create an empty object in it, and let the prototype of the empty object point to the parent object to be inherited, and finally return the instance of the object. The code is as follows

Object.createPro=function(pro){
  function F(){}
  F.prototype=pro;
  return new F;
}

We can Let’s test it:

Js code

function A(){  
 this.name="李可可";  
 this.age=21;  
}  
A.prototype.eat=function(){ console.log("I can eat") }  
function B(){}  
B.prototype=Object.createPro(A.prototype);//B只继承了A的prototype属性  
  
var cc=new B;  
cc.eat();//I can eat  
cc.name;//  
B.prototype.fuck=function(){console.log("I fuck you!")}//我们现在改变B的prototype  
var dd=new A;  
dd.fuck();//报错TypeError  
//说明B.prototype的改变并没有影响到A的任何属性

But it’s too troublesome to do this. ES5 helps us solve this problem. We can directly use a static method create() that comes with Object:

function A(){
 this.name="李可可";
 this.age=21;
}
A.prototype.eat=function(){ console.log("I can eat") }
function B(){}
B.prototype=Object.create(A.prototype);//只会继承A的prototype

while inheriting You can also add some unique properties to B as follows:

Js code

function A(){  
 this.name="李可可";  
 this.age=21;  
}  
A.prototype.eat=function(){ console.log("I can eat") }  
function B(){}  
B.prototype=Object.create(A.prototype,{   
 p: { value: 42, writable: false, enumerable: true }//添加一个属性p,并且是不可写的，但可枚举  
});  
var pp=new B;  
pp.p;//42  
pp.name;//undefined  
pp.eat();//I can eat  
pp.p=666;  
pp.p;//42 (不可写)

The second parameter is very similar to Object.defineproperties(), where you can configure multiple properties and give some special permission tags

Of course, if you want to pass It is also possible for this method to inherit all properties of A, as shown below

B.prototype=Object.create(new A);

It should be noted that the compatibility of the Object.create method is only possible for browsers compatible with ES5, or we can simulate one ourselves, just like the Object above .createPro method

2. Regarding the problem of constructor pointing and the enumerability of constructor

In the first question, we used the Object.create method to implement inheritance between different classes. However, there is a The problem is as follows:

function A(){
 this.name="李可可";
 this.age=21;
}
A.prototype.eat=function(){ console.log("I can eat") }
function B(){}
B.prototype=Object.create(A.prototype);
var cc=new B;
cc.constructor;//A　　（这里我们期望的值是B,而实际上变成了A）

So how to solve the above problem?

Js code

//我们最容易想到的是手动设置constructor属性，像下面这样  
B.prototype.constructor=B;

Of course we don’t want this to be the case, so what should we do?

Js code

//使用Object.defineProperty或Object.defineProperties方法设置constructor的enumerable为false  
Object.defineProperty(B.prototype,"constructor",{  
 value:B,  
 enumerable:false//不可枚举  
});  
cc.constructor;//B  
B.prototype.propertyIsEnumerable("constructor");//false

There is a similar problem when using object literals to rewrite the prototype of a class, like the following

Js code

function C(){}  
C.prototype={}  
var pp=new C;  
pp.constructor;//Object  (我们期望的是C)  
C.prototype.constructor=C;  
C.prototype.propertyIsEnumerable("constructor");//true　（同样是可枚举的）  
//这里也可以使用上面的方法解决

Of course, another way is that you don’t rewrite it, Just add attributes to it, like this:

Js code

function D(){}  
D.prototype.x=1;  
var gg=new D;  
gg.constructor; //D  
D.prototype.propertyIsEnumerable("constructor");//false