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 सीखेंगे।
●●●
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 किया जाता है।
Polymorphism का use कर के हम एक method या property को multiple classes में अलग तरीके से define कर सकते हैं।
यह concept inheritance और interfaces के through implement होता है।
इसका advantage यह होता है कि आप same method या object को अलग-अलग classes में अलग-अलग behaviors के साथ use कर सकते हैं, बिना code duplication के।
●●●
TypeScript में polymorphism दो main types का होता है -
इस type के polymorphism में, methods के overloads बनाये जाते हैं जो compile-time
पर decide होते हैं। Same method के अलग-अलग signatures होती हैं।
यह mainly method overloading के through implement होता है।
इस type के polymorphism में, method को runtime पर override किया जाता है , मतलब, parent class का method child class में अपने according से redefine किया जाता है।
यह Inheritance के साथ method overriding का use कर के implement होता है।
अब इन दोनो types को detail में समझते हैं।
●●●
Compile-time polymorphism को Method Overloading के through implement किया जाता है।
इसका मतलब है एक ही method का multiple versions होना, जो different parameter types या counts के साथ काम करे।
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
add()
method के दो overloads हैं — एक numbers के लिए और एक strings के लिए।
Single implementation overloads को handle करती है, और add()
method अलग-अलग types के साथ काम करता है।
इससे Compile-Time Polymorphism कहते हैं क्योंकि overloads compile time पर decide होते हैं।
●●●
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 का।
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.
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 को interfaces के through भी implement किया जा सकता है।
Interfaces
से आप define कर सकते हो कि कोई भी class क्या methods implement करेगी, लेकिन implementation का control हर class पास होता है।
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
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 करता है।
●●●
Code Reusability : Polymorphism से code reusable और modular होता है। आप एक ही method को multiple classes के साथ use कर सकते हैं, बिना code duplication के।
Flexibility : Polymorphism से code flexible ban जाता है। अगर आपको एक new class या behavior add करना हो, तो आप बिना existing code को change किये new objects बना सकते हो।
Maintainability : Polymorphism code को maintainable बनाता है। Parent class के methods को centralize करके, child classes में specific changes करने से आप code complexity को reduce कर सकते हैं।
Polymorphism TypeScript का एक core concept है जो object-oriented programming को powerful बनाता है।
Compile-Time Polymorphism method overloading के through implement होता है, जबकि Runtime Polymorphism method overriding के साथ काम करता है।
इससे code काफी reusable, flexible और maintainable ban जाता है