JS inheritance notes_js object-oriented

JS Inheritance
There is no concept of classes in JavaScript, and the concept of inheritance related to classes is out of the question, but we can

simulate inheritance in object-oriented languages ​​through special syntax.
There are many ways to simulate inheritance in JS, among which the parasitic combination mode is a relatively easy and simple simulation inheritance mode. Let's

introduce the use of parasitic combination mode to simulate inheritance.
JS inheritance includes attribute inheritance and method inheritance, which are implemented through different methods.
1 Inheritance of attributes
Inheritance of attributes is achieved by changing the execution environment of the function. Changing the execution environment of the function can be achieved using the two

methods: call() and apply().
We first create an Animal "class" (because there is no concept of a class in JS, here is just a simulation, it is actually just a

Function function object).

Copy code The code is as follows:

Function Animal(name){
this.name =name;
　}

Create another Lion "class" and "inherit" from Animal

Copy code The code is as follows:

Function Lion(){
Animal.apply(this, ["Lion"]);
}

Animal's apply method is used here to change the execution environment of Animal to the execution environment when Lion is called.
I would like to explain here that if we want to use the "class" of Lion, we usually need a new Lion. Such as:
　var l = new Lion();
The new keyword is very great. In the above code, the new keyword has completed the following tasks:
1) Open up the heap space to Prepare to store the Lion object
2) Modify the execution environment of the Lion object itself so that this of the Lion function points to the Lion function object itself.
3) Call the "constructor" of the Lion "class" to create a Lion object
4) Assign the heap address of the Lion function object to the variable l. At this time, l points to the Lion function object
so After the new keyword, this in Animal.apply(this, ["Lion"]) already points to the Lion function object itself, so

this code changes the execution environment of the Animal function to In the Lion function, it is equivalent to the following code:

Copy the code The code is as follows:

　function Lion( ){
Function Animal(name){
this.name=name;
}
}

At this time, this is already a Lion function object, so the above paragraph The code is further equivalent to:

Copy code The code is as follows:

Function Lion(){
　 this.name=name;
　}

This adds the name attribute to the Lion function object, and also simulates the effect of the Lion function inheriting from the Animal function.
2 Method Inheritance
Every "class" (i.e. function, note not a function object) in JS has a prototype attribute. prototype represents the prototype of the function

and also represents a class A collection of members (usually a collection of methods). We can realize the inheritance of method

through the prototype attribute of the function.
We also first create an Animal "class":

Copy the code The code is as follows:

Function Animal(name){
this.name=name;
}

Add an eat method to the prototype of Animal:

Copy code The code is as follows:

　Animal.prototype.eat=function(){
　alter("I can eat!~") ;
　}

Create a Lion "class" and complete the inheritance of the properties of the Animal "class"

Copy code The code is as follows:

Function Lion(){
Animal.apply(this, ["Lion"]);
　}

Pay attention to the following code, we are about to complete the inheritance of the method
Lion.prototype=new Animal();
In this way, an Animal function object is stored in the prototype of Lion, and Lion is Contains methods in Animal (actually

also includes attributes). This simulates the inheritance of Lion function from Animal.