Detailed explanation of prototype in JS

This article mainly introduces the detailed explanation of prototype in JS, which has certain reference value. Now I share it with you. Friends in need can refer to it.

The phototype in JS is the comparison in JS. A difficult part to understand

This article is based on the following knowledge points:

1 Prototype design pattern

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

The main idea of ​​the prototype method is that now there is a class A, and I want to create a class B. This class is prototyped with 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 method

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

means treating obj as obj1 and calling the func method

Okay, let’s solve the questions 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 first:

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 have to define extentClass, but we plan to use an instance of baseClass as the prototype, and the extendClass to be cloned will 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 happens 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

The experiment proves: When the function is run, it will first go to the function of the ontology to find it. If it is found, it will be run. If it cannot be found, it will be found in the prototype. Find function. 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 use an instance of extendClass to call the object method showMsg of baseClass?

The answer is that you can use call:

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


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

baseinstance.showMsg.call(instance); here reads as "call instance as baseinstance and call its object method showMsg"

Okay, someone may ask here, 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 of baseClass Method

Finally, if you understand the following code clearly, then you will 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 is the entire content of this article, I hope it will be helpful to everyone Learning will be helpful. For more related content, please pay attention to the PHP Chinese website!

Related recommendations:

JS function declaration and function expression analysis

How to convert pseudo array through js For array

The above is the detailed content of Detailed explanation of prototype in JS. For more information, please follow other related articles on the PHP Chinese website!