TypeScript में Generics: शुरुआती लोगों के लिए पूरी गाइड

TypeScript में Generics: क्यों ज़रूरी हैं और कैसे उपयोग करें

TypeScript एक शक्तिशाली उपकरण है जो JavaScript में स्थैतिक टाइपिंग जोड़ता है। हालाँकि, यदि आप अभी TypeScript सीखना शुरू कर रहे हैं, तो आपको ऐसी स्थिति का सामना करना पड़ सकता है जहाँ आपको विभिन्न डेटा प्रकारों के लिए एक ही कोड लिखना पड़ता है। यहीं पर Generics (सामान्यीकृत प्रकार या जेनेरिक्स) मददगार होते हैं। इस लेख में, हम समझेंगे कि Generics क्या हैं, उनकी क्यों ज़रूरत है, और व्यवहार में उनका उपयोग कैसे करें।

Generics क्या हैं और वे क्यों महत्वपूर्ण हैं?

Generics TypeScript का एक तंत्र है जो आपको ऐसे घटक (फ़ंक्शन, क्लास, इंटरफ़ेस) बनाने की अनुमति देता है जो किसी एक विशिष्ट प्रकार के बजाय विभिन्न डेटा प्रकारों के साथ काम करते हैं। कल्पना करें कि आप एक फ़ंक्शन लिख रहे हैं जिसे संख्याओं, स्ट्रिंग्स और ऐरे के साथ काम करना है। जेनेरिक्स के बिना, आपको या तो any प्रकार का उपयोग करना होगा (जो TypeScript के पूरे सार को खत्म कर देता है) या एक ही फ़ंक्शन की कई प्रतियाँ बनानी होंगी।

Generics के मुख्य लाभ:

• टाइप सुरक्षा — आप सख्त टाइपिंग बनाए रखते हैं, लेकिन कोड लचीला रहता है।
• कोड का पुन: उपयोग — एक फ़ंक्शन या क्लास विभिन्न प्रकारों के साथ काम कर सकता है।
• पठनीयता — कोड अधिक समझने योग्य और स्व-दस्तावेज़ीकरण बन जाता है।

Generics का मूल सिंटैक्स

आइए सबसे सरल उदाहरण से शुरू करते हैं। मान लीजिए, हमें एक फ़ंक्शन चाहिए जो दिए गए आर्गुमेंट को वापस करे। Generics के बिना, हम इसे इस तरह लिखेंगे:

function identity(arg: number): number {    return arg;}

लेकिन क्या होगा अगर हमें एक स्ट्रिंग पास करनी हो? एक नया फ़ंक्शन बनाना होगा। Generics के साथ, हम इसे इस तरह करते हैं:

function identity<T>(arg: T): T {    return arg;}

// उपयोग:let output1 = identity<string>("नमस्ते");let output2 = identity<number>(42);let output3 = identity<boolean>(true);

यहाँ <T> एक प्रकार पैरामीटर (या प्रकार चर) है। जब हम फ़ंक्शन को कॉल करते हैं, TypeScript स्वचालित रूप से आवश्यक प्रकार को प्रतिस्थापित करता है। आप कोई भी अक्षर उपयोग कर सकते हैं: T, U, V या Type जैसे सार्थक नाम भी।

वैसे, TypeScript स्वयं प्रकार का अनुमान लगा सकता है, इसलिए अक्सर स्पष्ट रूप से निर्दिष्ट किए बिना लिखा जा सकता है:

let output = identity("नमस्ते"); // TypeScript स्वयं समझ जाएगा कि T = string

ऐरे और एकाधिक प्रकारों के साथ काम करना

Generics के सबसे सामान्य उपयोगों में से एक ऐरे के साथ काम करना है। मान लीजिए, हम एक फ़ंक्शन लिखना चाहते हैं जो एक ऐरे लेता है और पहला एलिमेंट लौटाता है:

function getFirstElement<T>(arr: T[]): T | undefined {    return arr[0];}

const numbers = [1, 2, 3];const firstNumber = getFirstElement(numbers); // प्रकार number | undefined

const strings = ["a", "b", "c"];const firstString = getFirstElement(strings); // प्रकार string | undefined

ध्यान दें: हमने T[] का उपयोग किया है — यह Array<T> के समान है। और अगर फ़ंक्शन दो अलग-अलग प्रकार लेता है? आसान है!

function merge<T, U>(obj1: T, obj2: U): T & U {    return { ...obj1, ...obj2 };}

const result = merge({ name: "अन्ना" }, { age: 25 });// result का प्रकार है { name: string; } & { age: number; }// वास्तव में: { name: string; age: number; }

Generics की सीमाएँ (Constraints)

कभी-कभी ज़रूरत होती है कि जेनेरिक किसी भी प्रकार के साथ नहीं, बल्कि केवल उन प्रकारों के साथ काम करे जिनमें कुछ विशेष गुण हों। इसके लिए extends कीवर्ड के साथ सीमाओं का उपयोग किया जाता है।

उदाहरण के लिए, हम एक फ़ंक्शन लिखना चाहते हैं जो किसी ऑब्जेक्ट की लंबाई प्राप्त करता है। जाहिर है, सभी प्रकारों में length गुण नहीं होता। आइए इसे जाँचें:

function getLength<T extends { length: number