JS simulation method to implement encapsulation

This time I will bring you the method of JS simulation to implement encapsulation. What are the precautions for JS simulation to implement encapsulation? The following is a practical case, let's take a look.

Preface

 Inheritance is to use a subclass to inherit another parent class, then the subclass can automatically have all

attributes 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 principles for 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.

But there are also 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 that extends 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 object and prototype

1. prototype: prototype object of the function

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

②The prototype itself is also an object!

③The 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 the prototype chain.

③ Functions and arrays are both 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 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 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):

Call writing method: 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,...]);

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

I believe you have mastered the method after reading the case in this article. Please pay attention for more exciting information. Other related articles on php Chinese website!

Recommended reading:

The above is the detailed content of JS simulation method to implement encapsulation. For more information, please follow other related articles on the PHP Chinese website!