Three ways to implement encapsulation through JavaScript simulation and how to write them

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 methods to implement inheritance in JS. JS is an object-oriented language, and its objects are simulated using the prototype attribute. 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.

//声明一个父类
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 implementing inheritance:

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 shortcomings 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: prototype object of function

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

②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:

php package search class instance

Example details the encapsulation process of mui pull-up to load more pull-down refresh data

PHP function encapsulation of adding commas to every three digits

The above is the detailed content of Three ways to implement encapsulation through JavaScript simulation and how to write them. For more information, please follow other related articles on the PHP Chinese website!