TypeScript Polymorphism Explained With Examples

If tutorials available on this website are helpful for you, please whitelist this website in your ad blocker😭 or Donate to help us ❤️ pay for the web hosting to keep the website running.

TypeScript एक strongly typed superset है JavaScript का, जो हमें object-oriented programming (OOP) के काफी powerful features provide करता है।

इन features में एक important concept है Polymorphism. Polymorphism से हम एक ही method, property, या object को अलग-अलग तरीके से use कर सकते हैं, depending on the context.

इस topic में हम TypeScript Polymorphism को समझेंगे, इसका meaning, कैसे काम करता है, types क्या हैं, और real-world examples के साथ उसका implementation सीखेंगे।

●●●

What is Polymorphism?

Polymorphism एक ऐसा concept है जो OOP (Object-Oriented Programming) में common है। Polymorphism का मतलब होता है "one interface, many forms".

Polymorphism का अर्थ है many forms , यह यह एक geek भाषा का शब्द है दो शब्दों में मिलकर बना हुआ है poly(many) और morph(forms) . सरल शब्दों में कहें तो , polymorphism का मतलब है many forms।

Polymorphism एक ability है जिसके द्वारा एक तरह के resources को आप different - different तरीके से access कर सकते हैं। इस concept को normally Inheritance में use किया जाता है।

Key Points

• Polymorphism का use कर के हम एक method या property को multiple classes में अलग तरीके से define कर सकते हैं।

• यह concept inheritance और interfaces के through implement होता है।

• इसका advantage यह होता है कि आप same method या object को अलग-अलग classes में अलग-अलग behaviors के साथ use कर सकते हैं, बिना code duplication के।

●●●

Types of Polymorphism in TypeScript

TypeScript में polymorphism दो main types का होता है -

1. Compile-Time Polymorphism (Method Overloading)

• इस type के polymorphism में, methods के overloads बनाये जाते हैं जो compile-time पर decide होते हैं। Same method के अलग-अलग signatures होती हैं।

• यह mainly method overloading के through implement होता है।

2. Runtime Polymorphism (Method Overriding)

• इस type के polymorphism में, method को runtime पर override किया जाता है , मतलब, parent class का method child class में अपने according से redefine किया जाता है।

• यह Inheritance के साथ method overriding का use कर के implement होता है।

अब इन दोनो types को detail में समझते हैं।

●●●

TypeScript Compile-Time Polymorphism

Compile-time polymorphism को Method Overloading के through implement किया जाता है।

इसका मतलब है एक ही method का multiple versions होना, जो different parameter types या counts के साथ काम करे।

TypeScript compile-time polymorphism example

Copy
class Calculator {
    // Method overload signatures
    add(a: number, b: number): number;
    add(a: string, b: string): string;

    // Single implementation that handles both overloads
    add(a: any, b: any): any {
        return a + b;
    }
}

const calc = new Calculator();

console.log(calc.add(10, 20));  // Output: 30
console.log(calc.add("Hello", " World"));  // Output: Hello World

Explanation

• add() method के दो overloads हैं — एक numbers के लिए और एक strings के लिए।

• Single implementation overloads को handle करती है, और add() method अलग-अलग types के साथ काम करता है।

इससे Compile-Time Polymorphism कहते हैं क्योंकि overloads compile time पर decide होते हैं।

●●●

TypeScript Runtime Polymorphism

Runtime polymorphism तब होता है जब एक child class अपने parent class के method को override करती है। इससे dynamic method dispatch भी कहते हैं।

जब हम parent class का reference use करके child class का object create करते हैं, तो runtime पर TypeScript decide करता है कि कौनसा method call होगा — parent का या child का।

TypeScript run-time polymorphism example

Copy
class Animal {
    makeSound(): void {
        console.log("Animal is making a sound.");
    }
}

class Dog extends Animal {
    makeSound(): void {
        console.log("Dog is barking.");
    }
}

class Cat extends Animal {
    makeSound(): void {
        console.log("Cat is meowing.");
    }
}

const animals: Animal[] = [new Dog(), new Cat()];

animals.forEach(animal => {
    animal.makeSound();
});
// Output:
// Dog is barking.
// Cat is meowing.

Explanation

• Animal class का method makeSound() child classes Dog और Cat में override किया गया।

• जब हम Animal type के reference के through child objects को iterate करते हैं, तो runtime पर Dog और Cat के overridden methods call होते हैं। इसे Runtime Polymorphism कहते हैं।

●●●

TypeScript Polymorphism with Interface

TypeScript में polymorphism को interfaces के through भी implement किया जा सकता है।

Interfaces से आप define कर सकते हो कि कोई भी class क्या methods implement करेगी, लेकिन implementation का control हर class पास होता है।

TypeScript polymorphism example

Copy
interface Shape {
    area(): number;
}

class Circle implements Shape {
    constructor(private radius: number) {}

    area(): number {
        return Math.PI * this.radius * this.radius;
    }
}

class Rectangle implements Shape {
    constructor(private width: number, private height: number) {}

    area(): number {
        return this.width * this.height;
    }
}

function calculateArea(shape: Shape): void {
    console.log(`Area: ${shape.area()}`);
}

const circle = new Circle(5);
const rectangle = new Rectangle(10, 5);

calculateArea(circle);     // Output: Area: 78.53981633974483
calculateArea(rectangle);  // Output: Area: 50

Explanation

• Shape interface define करता है कि कोई भी shape area() method implement करेगा।

• Circle और Rectangle classes ने अपना respective area() method implement किया।

• calculateArea() function generic है, जो Shape type को accept करता है, और runtime पर यह respective classes का area() method call करता है।

●●●

Benefits of Polymorphism

1. Code Reusability : Polymorphism से code reusable और modular होता है। आप एक ही method को multiple classes के साथ use कर सकते हैं, बिना code duplication के।

2. Flexibility : Polymorphism से code flexible ban जाता है। अगर आपको एक new class या behavior add करना हो, तो आप बिना existing code को change किये new objects बना सकते हो।

3. Maintainability : Polymorphism code को maintainable बनाता है। Parent class के methods को centralize करके, child classes में specific changes करने से आप code complexity को reduce कर सकते हैं।

Conclusion

Polymorphism TypeScript का एक core concept है जो object-oriented programming को powerful बनाता है।

Compile-Time Polymorphism method overloading के through implement होता है, जबकि Runtime Polymorphism method overriding के साथ काम करता है।

इससे code काफी reusable, flexible और maintainable ban जाता है