Introduction to three methods of JavaScript simulation to achieve encapsulation and their differences

Preface

Inheritance is to use a subclass to inherit another parent class, then the subclass can automatically have all 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.

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 implementation is inherited The principle:

Through looping, all attributes and methods of the parent class object are assigned to the 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

Let’s talk about this method before introducing it Two concepts: prototype object 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: The 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. The order of looking up along this line is 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 prototypal 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 the attributes of the subclass itself are member attributes, and the attributes inherited from the parent class are Prototype properties.

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

The third way 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 to by this of func, [func parameter 1, func parameter 2,...]);

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

Summary

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