Sharing the differences between three JavaScript simulation implementation encapsulation methods and their writing methods

Inheritance is to use a subclass to inherit another parent class, then the subclass can automatically have all the properties and methods in the parent class. This process is called inheritance! There are many ways to implement inheritance in JS. Today I will introduce three of them to you. Let’s use this article to learn about the three methods of encapsulation through js simulation. Friends who need it can refer to it. I hope it can help everyone.

1. Add an extension method to the Object class

//声明一个父类
function Person(name){
 this.name=name;
 this.age=age;
 this.say=function(){
   alert("我叫"+this.name);
 }
}
//声明一个子类 
function Student(){
 this.no=no;
 this.study=function(){
  alert("我在学习！");
 }
}
// 通过循坏，将父类对象的所有属性和方法，全部赋给子类对象
Object.prototype.extend=function(parent){
 for(var i in parent){
   this[i].parent[i];
 }
}
var p=new Person("张三",12);
var s=new Student("1234567");
//子类对象调用这个扩展方法
s.extend()
console.log(s);

The above-mentioned principle of inheritance:

Through looping, all properties and methods of the parent class object are Assigned to subclass object. The key point is the for-in loop. Even without extending Object, the operation can be implemented through a simple loop.

However, there are some disadvantages in using this method to implement inheritance:

① You cannot directly get the complete subclass object through one instantiation. You need to get the parent class object and the subclass object first, and then merge them manually;

②The inheritance method of extending Object will also be retained on the object of the subclass.

Let’s take a look at the second method of implementing inheritance~

2. Use prototypal inheritance

Before introducing this method, let’s talk about two concepts: prototype objects And prototype

1. prototype: the prototype object of the function

①Only functions have prototypes, and all functions must have prototypes

②The prototype itself is also an object!

③prototype points to the reference address where the current function is located!

2. __proto__: prototype of the object!

①Only objects have __proto__, and all objects must have __proto__

②__proto__ is also an object, so it also has its own __proto__. Follow this line in the order of upwards. It's the prototype chain.

③ Functions and arrays are objects and have their own __proto__

//声明父类
function Person(name,age){
   this.name=name;
   this.age=age;
   this.say=function(){
    alert("我叫"+this.name);
   }
}
//声明子类   
function Student(no){
   this.no=no;
   this.study=function(){
    alert("我在学习！我叫"+this.name+"今年"+this.age");
   }
}
//将父类对象赋给子类的prototype  
Student.prototype=new Person("张三",14);
//拿到子类对象时，就会将父类对象的所有属性和方法，添加到__proto__
var s=new Student(); 
s.study();

The principle of using prototype inheritance:

Assign the parent class object to the prototype of the subclass , then the attributes and methods of the parent class object will appear in the prototype of the subclass. Then, when instantiating a subclass, the prototype of the subclass will be in the __proto__ of the subclass object. Finally, the attributes and methods of the parent class object will appear in the __proto__ of the subclass object.

Characteristics of this kind of inheritance:

①All properties of the subclass itself are member properties, and properties inherited from the parent class are prototype properties.

② Still cannot get the completed subclass object through one-step instantiation.

The third method to implement inheritance:

call(), apply() and bind(), these three methods are very similar, only different in passing parameters.

function Person(name,age){
  this.name=name;
  this.age=age;
  this.say=function(){
    alert("我叫"+this.name);
    }
}
function Student(no,name,age){
  this.no=no;
  this.study=function(){
    alert("我在学习！");
  }
//将父类函数的this,指向为子类函数的this
Person.call(this,name,age);
}
var s=new Student(12,"张三",24);
console.log(s);

The only difference between the three functions is the way they accept the parameter list of func. Other than that, there is no difference in functionality!

How to write the three functions (difference):

How to write call: func.call(obj pointed to by this of func, func parameter 1, func parameter 2,...);

Apply writing method: func.apply(obj pointed by this of func, [func parameter 1, func parameter 2,...]);

Bind writing method: func.bind(this pointed by func obj)(func parameter 1, func parameter 2,...);

Related recommendations:

Detailed explanation of a Vue plug-in from encapsulation to release

The encapsulation function in jquery passes the current element

jquery and ajax realize three-level linkage encapsulation and non-encapsulation of provinces and municipalities

The above is the detailed content of Sharing the differences between three JavaScript simulation implementation encapsulation methods and their writing methods. For more information, please follow other related articles on the PHP Chinese website!