Is there polymorphism in javascript?

Polymorphism in JavaScript; polymorphism means that the same operation can produce different interpretations and execution results when applied to different objects. Polymorphism in JavaScript is reflected in subclasses and can be directly implemented with the same name. Functions can override parent class functions, and parent class functions in JavaScript can be overridden directly.

The operating environment of this tutorial: Windows 10 system, JavaScript version 1.8.5, Dell G3 computer.

Polymorphism in javascript

Meaning

The same operation acts on different objects, which can produce different interpretations and different execution results

For example, I have a cat and a dog. If I give them the same command "bark", the cat will meow and the dog will bark, so asking them to bark is the same. Operation, and different calls have different execution results.

The pseudo code implementation is like this:

function getVoice(animals) {
    if(animals instanceof Cat){
        console.log('喵～');
        
    }
    if(animals instanceof Dog){
        console.log('汪～');
    }
}
class Cat {}
class Dog {}
getVoice(new Cat()); // '喵～'
getVoice(new Dog()); // '汪～'

So what if we want to add an animal? Add one more judgment? Then every time I want to add an animal sound, I have to modify getVoice? Isn’t it a bit cumbersome?

So we have to think about how to solve this problem~

Polymorphism of objects

In fact, the most fundamental function of polymorphism is to convert procedural conditional statements into Object polymorphism, thereby eliminating these conditional branch statements.

In layman terms, it means to separate "what to do" from "who does it and how to do it". Abstract summary is to separate "things that don't change" from "things that may change".

The example we gave at the beginning can be broken down and understood as follows:

The things that remain unchanged are: the sounds made by animals. The things that may change are: what animals make what sounds Sound

Then we can distribute the action of "animals make noises" to various classes (encapsulate them in each class), and then call the action of "calling" in the getVoice function that makes sounds. .

The above example can be modified like this~

function getVoice (animals) {
    if (animals.sound instanceof Function) {
        // 判断是否有animal.sound且该属性为函数
        animals.sound();
    }
}
class Cat {
    sound () {
        console.log('喵～');
    }
}
class Dog {
    sound () {
        console.log('汪～');
    }
}
getVoice(new Cat()); // '喵～'
getVoice(new Dog()); // '汪～'

Practical application of polymorphism

Polymorphism is widely used in design patterns, such as combination pattern/strategy modes and so on. ~~

Although we don’t use it in daily development, polymorphism is still very useful once we involve some design patterns

JS encapsulation and Polymorphism

In addition to inheritance, encapsulation and polymorphism are also components of object-oriented thinking. The encapsulation and polymorphism of JS are also realized through the flexible application of attributes "simulation".

Encapsulation can be simulated by setting public properties in the class and implementing them in subclasses.

The embodiment of polymorphism is simpler. Directly implementing the function of the same name in the subclass can override the parent class function. There is no virtualde keyword in JS similar to that in C#, and all parent class functions can be directly overridden.

Example:

function calc(value1,value2){
this.data1=value1;
this.data2=value2; 
this.GetResult;
this.toString=function(){
if(this.GetResult)
return this.GetResult()+"";
return "0";
}
}
 
function sumCalc(value1,value2){
calc.call(this,value1,value2)
this.GetResult=function(){ 
return this.data1+this.data2;
}
}
function productCalc(value1,value2){
calc.call(this,value1,value2)
this.GetResult=function(){ 
return this.data1*this.data2;
}
}
var s=new sumCalc(2,3);
alert(s.toString());  //弹框5
var p=new productCalc(2,3);
alert(p.toString());  //弹框6

As above, the sumCalc class and productCalc class both inherit and implement the calc class, and implement the "abstract function" GetResult(). This is how JS encapsulation is implemented.

In addition, all classes in JS inherit from Object, and Object has its own toString() function. Therefore, the toString() function of the calc class above actually covers the original function-a manifestation of polymorphism.

【Related recommendations: javascript video tutorial, web front-end】

The above is the detailed content of Is there polymorphism in javascript?. For more information, please follow other related articles on the PHP Chinese website!