A brief discussion on JS inheritance_borrow constructor & combination inheritance

2. Borrow constructor

To solve the problem caused by including reference type values ​​in the prototype, we use a technique called borrow constructor stealing (also called forged objects or classical inheritance).

The basic idea of ​​this technique: call the supertype constructor inside the subclass constructor.

The constructor can be executed on the newly created subclass object by using the apply() and call() methods.

function SuperType(){
   = ["red", "blue", "green"];
}

function SubType(){
  //Inherited SuperType  (this);
}

var instance1 = new SubType();
("black");
alert();  //red,blue,green,black

var instance2 = new SubType();
alert();  //red,blue,green

In the above example, the SuperType constructor is actually called in the environment of the newly created SubType instance (instance1 instance2). This way, all object initialization codes defined in the SuperType() function will be executed on the new SubType object. So each instance of Subtype will have its own copy of the colors attribute.

Pass parameters

For prototype chains, borrowing constructors has a great advantage, that is, you can pass parameters in supertype constructors in subtype constructors.

function SuperType(name){
   = name;
}

function SubType(){
  (this, "Bob");
   = 18;
}

var instance1 = new SubType();
alert();  //18
alert();  //Bob

Problem of borrowing constructors:

Methods are all defined in the constructor, so there is no way to talk about function reuse. Moreover, methods defined in supertype prototypes are also invisible to subtypes.

3. Combination inheritance

Combination inheritance, sometimes called pseudo-classical inheritance, refers to combining prototype chains and borrowing constructor techniques together. This is a mode of inheritance that plays the strengths of both.

Use prototype chains to implement inheritance of prototype properties and methods;

Inheritance of instance properties is achieved by borrowing constructors.

In this way, function reuse is achieved by defining methods on the prototype, and it can also ensure that each instance has its own attributes.

function SuperType(name){
   = name;
   = ["red", "blue", "green"];
}
 = function(){
  alert();
}

function SubType(name, age){
//Inheritance attributes  (this, name);
   = age;
}

//Inheritance method = new SuperType();
 = function(){
  alert();
}

var instance1 = new SubType("Bob", 22);
("black");
alert();   //red,blue,green,black
();     //Bob
();     //22

var instance2 = new SubType("Alice", 21);
alert();  //red,blue,green
();    //Alice
();     //21

In this example, the SuperType constructor defines two properties: name and colors. The prototype of SuperType defines a method saysName().

The SubType constructor passes in the name parameter when calling the SuperType constructor and defines its own attribute age. Then assign the instance of SuperType to the prototype of SubType. The method saysAge() is defined on this prototype.

This allows two different SubType instances to have their own properties - including colors attributes, and use the same method.

The above article briefly talks about JS inheritance_borrow constructor & combination inheritance is all the content I share with you. I hope you can give you a reference and I hope you can support me more.