JS inheritance method--case description

1. Prototype chain: Use prototypes to let one reference type inherit the properties and methods of another reference type

Each constructor has a prototype object, and the prototype object contains a pointer to the constructor pointer, and instances contain an internal pointer to the prototype object.

Basic pattern for implementing originality chain:

function SuperType(){
    this.colors =[“red”, “blue”, “green”];
}
function SubType(){
}
SubType.prototype = new SuperType();
var instance1 = new SubType();
instance1.colors.push(“black”);
alert(instance1.colors);  //red, blue, green, black
var instance2 = new SubType();
alert(instance2.colors);   //red, blue, green, black

The final result: intance points to the prototype of SubType, and the prototype of SubType points to the prototype of SuperType, and SuperType inherits Object

The default prototype of all functions is an instance of Object

Problem: There will be problems with reference type values

For example, if an instance of a subclass is created, if If the attributes of a subclass instance are modified, then other subclasses will be affected when creating them. The code is as follows:

function SuperType(){
    this.colors =[“red”, “blue”, “green”];
}
function SubType(){
}
SubType.prototype = new SuperType();
var instance1 = new SubType();
instance1.colors.push(“black”);
alert(instance1.colors);  //red, blue, green, black
var instance2 = new SubType();
alert(instance2.colors);   //red, blue, green, black

The above results indicate that the attribute values ​​​​of other instances will be affected

2. Borrowing the constructor: calling the supertype constructor inside the subtype constructor

function SuperType(){
    this.colors =[“red”, “blue”, “green”];
}
function SubType{}(
   SuperType.call(this);     //继承了SuperType。通过调用SuperType的构造函数，借用其构造结构
}
var instance1 = new SubType();
instance1.colors.push(“black”);
alert(intance1.colors);     //red,blue,green,black
var instance2 = new SubType();
alert(instance2.colors);   //red,blue,green

Use this method to pass parameters to the supertype constructor in the subclass constructor, as follows:

function SuperType(name){
    this.name = name;
}
function SubType(){
SuperType.call(this,“Nicholas”);        //传入参数，利用这个参数初始化父类构造函数中的name
this.age = 29;
}
var instance = new SubType();
alert(instance.name);   //Nicholas
alert(instance.age);   //29

Problem: Inconvenient to reuse

3. Combined inheritance: Use the prototype chain to inherit the prototype properties and methods, and borrow the constructor to implement the instance Inheritance of attributes

Sample code:

function SuperType(name){
this.name = name;
this.colors = [“red”, “blue”,“green”];
}
SuperType.prototype.sayName = function(){   //定义了一个方法，该方法在继承的子类中也可以用
    alert(this.name);
}
function SubType(name, age){
SuperType.call(this, name);    //继承SuperType的一部分，this指SubType，
this.age = age;    //自己新定义的属性age也可以进行赋值
}
SubType.prototype = new SuperType();     //利用原型继承，可以使用父类的方法（见原型链继承）
SubType.prototype.sayAge = function(){   //定义SubType特有的新方法
    alert(this.age);
}
var instance1 = new SubType(“Martin”, 10);
instance1.colors.push(“black”);
alert(instance1.colors);  //red,blue,green,black
instance1.sayName();   //Martin
instance1.sayAge();  //10
var instance2 = new SubType(“Greg”, 27);
alert(instance2.colors);   //red,blue,green
instance2.sayName();  //Greg
instance2.sayAge();  //27

Related recommendations:

Detailed examples of inheritance methods in JS

Several ways to implement inheritance in JS

The above is the detailed content of JS inheritance method--case description. For more information, please follow other related articles on the PHP Chinese website!