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的prototypeSolution:
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的prototypewhile 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");//falseThere 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
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
