JS parasitic combinatorial inheritance

Prototype inheritance

child.prototype=new Parent()
function A(x){
    
	this.x=x
}
A.prototype.getX=function(){
    console.log(this.x)}
function B(y){
    
	this.y=y
}
B.prototype.gety=function(){
    console.log(this.y)}
B.prototype=new A()
B.prototype.constructor=B// because B The prototype object of points to A An example of , Then its constructor will point to A, Therefore, we need to change the direction of the constructor in the prototype object 

Let the prototype of the subclass point to the instance of the parent class , The prototype chain of the instance of the parent class will point to the prototype of the class . This method has great shortcomings ： When the subclass instance is modified, the parent instance will also change , Because here is the way of using references , That is, operate in the same memory space

Object.create（）

Create a new object , Using an existing object to provide a newly created object __proto__
That is to provide your object with a __proto__

Inheritance combined inheritance

Yes, it is call Inheritance and Object.create

        function Person(name){
    
            this.name=name
        }
        function A(sex){
    
            Person.call(this,'A extends Person')
            this.sex=sex
        }
        Person.prototype.getName=function(){
    
            console.log(this.name)
        }
        A.prototype=Object.create(Person.prototype)
        A.prototype.constructor=A

call The purpose of inheritance is to Person The private attribute of is inherited as its own private attribute , Each of the following A Instances of will have a private property name=’A extends Person‘, But only call Inheritance is not enough , Here we call the parent constructor as a normal method , But we can't get the properties and methods on the parent prototype object . Therefore, we need to point the child class prototype to the parent class prototype . So give A Of prototype Prototype objects provide Person.prototype, such A Instance __proto__ Point to A Of prototype,A Of prototype Of __proto__ Point to Person Of prototype. This combinatorial inheritance gets the private properties and methods of the parent class and becomes its own private properties and methods , We also got the public properties and methods of the parent class . Is in es6 The best way before inheritance

In the picture A Namely Person Parent class