Understanding prototype in JS_javascript skills

Every constructor has an attribute called prototype. This attribute is very useful for declaring common variables or functions for a specific class.

Definition of prototype

You don’t need to explicitly declare a prototype attribute because it exists in every constructor

This article is based on the following knowledge points:

1 Prototype Design Pattern

You can use clone() to implement the prototype method in .Net

The main idea of ​​the prototype method is that there is now a class A, and I want to create a class B. This class is based on A and can be extended. We call the prototype of B A.

2 JavaScript methods can be divided into three categories:

a class method

b Object methods

c prototype method

Example:

function People(name)
{
 this.name=name;
 //对象方法
 this.Introduce=function(){
 alert("My name is "+this.name);
 }
}
//类方法
People.Run=function(){
 alert("I can run");
}
//原型方法
People.prototype.IntroduceChinese=function(){
 alert("我的名字是"+this.name);
}
 
//测试
var p1=new People("Windking");
p1.Introduce();
People.Run();
p1.IntroduceChinese(); 

3 obj1.func.call(obj) method

It means treating obj as obj1 and calling the func method

Okay, let’s solve the problems one by one:

What does prototype mean?

Every object in JavaScript has a prototype attribute. The explanation of the prototype attribute of an object in Javascript is: return a reference to the prototype of the object type.

A.prototype = new B();

Understanding prototype should not be confused with inheritance. The prototype of A is an instance of B. It can be understood that A has cloned all the methods and properties in B. A can use B's methods and properties. The emphasis here is on cloning rather than inheritance. This situation can occur: A's prototype is an instance of B, and B's prototype is also an instance of A.

Let’s look at an experimental example:

function baseClass()
{
 this.showMsg = function()
 {
  alert("baseClass::showMsg"); 
 }
}
function extendClass()
{
}
extendClass.prototype = new baseClass();
var instance = new extendClass();
instance.showMsg(); // 显示baseClass::showMsg

We first define the baseClass class, and then we define extentClass, but we plan to use an instance of baseClass as the prototype, and the extendedClass to be cloned also contains the showMsg object method.

extendClass.prototype = new baseClass() can be read as: extendClass is created by cloning an instance of baseClass as the prototype.

Then there will be a question, what if extendClass itself contains a method with the same name as the method of baseClass?

The following is extended experiment 2:

function baseClass()
{
 this.showMsg = function()
 {
  alert("baseClass::showMsg"); 
 }
}
function extendClass()
{
 this.showMsg =function ()
 {
  alert("extendClass::showMsg");
 }
}
extendClass.prototype = new baseClass();
var instance = new extendClass();
instance.showMsg();//显示extendClass::showMsg

Experimental proof: When the function is running, it will first look for the function in the ontology. If it is found, it will be run. If it cannot be found, it will look for the function in the prototype. Or it can be understood that the prototype will not clone the function with the same name.

Then there will be a new question:
What if I want to call the object method showMsg of baseClass using an instance of extendClass?

The answer is to use call:

extendClass.prototype = new baseClass();
var instance = new extendClass();

var baseinstance = new baseClass();
baseinstance.showMsg.call(instance);//显示baseClass::showMsg

The baseinstance.showMsg.call(instance); here reads as "Call the instance as baseinstance and call its object method showMsg"
Okay, someone here may ask, why not use baseClass.showMsg.call(instance);

This is the difference between object methods and class methods. What we want to call is the object method of baseClass

Finally, if you understand the following code clearly, then you can understand what this article says:

<script type="text/javascript">
function baseClass()
{
 this.showMsg = function()
 {
  alert("baseClass::showMsg"); 
 }
 this.baseShowMsg = function()
 {
  alert("baseClass::baseShowMsg");
 }
}
baseClass.showMsg = function()
{
 alert("baseClass::showMsg static");
}
function extendClass()
{
 this.showMsg =function ()
 {
  alert("extendClass::showMsg");
 }
}
extendClass.showMsg = function()
{
 alert("extendClass::showMsg static")
}
extendClass.prototype = new baseClass();
var instance = new extendClass();
instance.showMsg(); //显示extendClass::showMsg
instance.baseShowMsg(); //显示baseClass::baseShowMsg
instance.showMsg(); //显示extendClass::showMsg
baseClass.showMsg.call(instance);//显示baseClass::showMsg static
var baseinstance = new baseClass();
baseinstance.showMsg.call(instance);//显示baseClass::showMsg
</script>

The above content is about the understanding of prototype in JS. I hope you like it.