टाइपस्क्रिप्ट में जनरिक्स

यह लेख टाइपस्क्रिप्ट में जनरिक्स को समझाता है।

YouTube Video

टाइपस्क्रिप्ट में जनरिक्स

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

जनरिक्स की बुनियादी बातें

जनरिक्स टेम्पलेट्स की तरह कार्य करते हैं जो प्रकारों को तर्क के रूप में स्वीकार करते हैं, जिससे फ़ंक्शन्स और क्लासेज़ विभिन्न प्रकारों को संभाल सकते हैं।

जनरिक फ़ंक्शन्स

नीचे दिया गया उदाहरण एक ऐसे फ़ंक्शन का है जिसमें जनरिक्स का उपयोग करते हुए तर्क प्रकारों को निर्दिष्ट किया गया है।

1function identity<T>(value: T): T {
2    return value;
3}
4
5console.log(identity<number>(42));       // 42
6console.log(identity<string>("Hello"));  // Hello

• T एक जनरिक प्रकार तर्क है जो फ़ंक्शन के तर्कों और रिटर्न मान के प्रकारों का प्रतिनिधित्व करता है। वास्तविक प्रकार तब निर्धारित होता है जब फ़ंक्शन को कॉल किया जाता है।
• <number> या <string> को स्पष्ट रूप से निर्दिष्ट करके, आप प्रकार को परिभाषित कर रहे हैं।

जनरिक प्रकार बिना स्पष्ट निर्दिष्ट किए काम करते हैं क्योंकि टाइपस्क्रिप्ट प्रकार अनुमान (type inference) लागू करता है।

1function identity<T>(value: T): T {
2    return value;
3}
4
5console.log(identity(42));       // 42
6console.log(identity("Hello"));  // Hello

• यहां तक कि स्पष्ट रूप से <number> या <string> निर्दिष्ट किए बिना भी, प्रकार अनुमानित किया जाता है। identity(42) को number के रूप में और identity("Hello") को string के रूप में अनुमानित किया जाता है।

जनरिक्स पर प्रतिबंध

जनरिक्स पर प्रतिबंध लगाकर, आप उन्हें केवल विशिष्ट प्रकार स्वीकार करने तक सीमित कर सकते हैं।

1function loggingIdentity<T extends { length: number }>(arg: T): T {
2    console.log(arg.length);
3    return arg;
4}
5
6loggingIdentity("Hello");  // 5
7loggingIdentity([1, 2, 3]);  // 3
8
9// loggingIdentity(42);  // Error: number does not have a length property.

• T extends { length: number } निर्दिष्ट करने का मतलब है कि T एक ऐसा प्रकार होना चाहिए जिसमें length नामक प्रॉपर्टी हो। इसलिए, वे प्रकार जिनमें length प्रॉपर्टी नहीं है, स्वीकार नहीं किए जाएंगे।

keyof के साथ संयोजन

जनरिक्स को keyof के साथ मिलाकर, आप संपत्ति के नामों को प्रकार-सुरक्षित तरीके से प्राप्त कर सकते हैं।

1function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
2  return obj[key];
3}
4
5const person = { name: "Bob", age: 30 };
6const personName = getProperty(person, "name"); // string
7console.log(personName);
8
9// const error = getProperty(person, "unknown"); // Error

• K को keyof T द्वारा सीमित किया गया है, जो यह दर्शाता है कि केवल T में मौजूद कुंजियाँ ही निर्दिष्ट की जा सकती हैं। ऐसी कुंजी निर्दिष्ट करना जो मौजूद नहीं है, संकलन त्रुटि का कारण बनेगा।

जनरिक क्लासेज़

क्लासेज़ को भी जनरिक्स का उपयोग करके परिभाषित किया जा सकता है। जनरिक क्लासेज़ प्रॉपर्टीज़ और मेथड्स के लिए लचीले प्रकार प्रदान करती हैं।

 1class Box<T> {
 2    private _value: T;
 3
 4    constructor(value: T) {
 5        this._value = value;
 6    }
 7
 8    public getValue(): T {
 9        return this._value;
10    }
11
12    public setValue(value: T): void {
13        this._value = value;
14    }
15}
16
17const numberBox = new Box<number>(100);
18console.log(numberBox.getValue());  // 100
19
20const stringBox = new Box<string>("Hello");
21console.log(stringBox.getValue());  // Hello

• Box<T> क्लास के भीतर उपयोग किए गए प्रकार T को एक जनरिक के रूप में घोषित करता है। यह एक ही क्लास को विभिन्न प्रकारों के लिए पुन: उपयोग करने की अनुमति देता है।

जनरिक इंटरफेस

जनरिक्स को इंटरफेस के साथ भी उपयोग किया जा सकता है।

 1interface Pair<T, U> {
 2    first: T;
 3    second: U;
 4}
 5
 6const numberStringPair: Pair<number, string> = { first: 1, second: "One" };
 7console.log(numberStringPair);  // { first: 1, second: 'One' }
 8
 9const booleanArrayPair: Pair<boolean, number[]> = { first: true, second: [1, 2, 3] };
10console.log(booleanArrayPair);  // { first: true, second: [ 1, 2, 3 ] }

• Pair<T, U> के साथ दो जनरिक प्रकार निर्दिष्ट करके, आप विभिन्न प्रकारों के संयोजन के साथ एक ऑब्जेक्ट को परिभाषित कर सकते हैं।

डिफ़ॉल्ट प्रकार के तर्क

यह सामान्य प्रकार के तर्कों के लिए एक डिफ़ॉल्ट प्रकार निर्दिष्ट करना भी संभव है।

1function createArray<T = string>(length: number, value: T): T[] {
2    return Array(length).fill(value);
3}
4
5console.log(createArray(3, "a"));   // ['a', 'a', 'a']
6console.log(createArray(3, 100));   // [100, 100, 100]

• हम <T = string> के साथ डिफ़ॉल्ट प्रकार तर्क को string पर सेट कर रहे हैं। यदि कोई प्रकार स्पष्ट रूप से निर्दिष्ट नहीं किया गया है, तो T का प्रकार string होगा।

जनरिक प्रकार उपनाम (टाइप एलिआस)

जनरिक को प्रकार उपनाम (type) के रूप में भी उपयोग किया जा सकता है।

 1type Result<T> = {
 2    success: boolean;
 3    data: T;
 4};
 5
 6const successResult: Result<number> = { success: true, data: 42 };
 7const errorResult: Result<string> = { success: false, data: "Error occurred" };
 8
 9console.log(successResult);  // { success: true, data: 42 }
10console.log(errorResult);    // { success: false, data: 'Error occurred' }

• Result<T> एक परिणाम वस्तु (ऑब्जेक्ट) को दर्शाता है जो T प्रकार का डेटा समाहित करता है। इस तरह से, आप जनरिक का उपयोग करके लचीले प्रकार उपनाम (फ्लेक्सिबल टाइप एलिआस) बना सकते हैं।

एकाधिक जनरिक प्रकार

एकाधिक जनरिक प्रकारों का उपयोग करके आप और भी बहुमुखी (वर्सेटाइल) फंक्शन्स और कक्षाएं (क्लासेज़) परिभाषित कर सकते हैं।

1function merge<T, U>(obj1: T, obj2: U): T & U {
2    return { ...obj1, ...obj2 };
3}
4
5const person = { name: "Alice" };
6const job = { title: "Engineer" };
7
8const merged = merge(person, job);
9console.log(merged);  // { name: 'Alice', title: 'Engineer' }

• merge फ़ंक्शन दो भिन्न प्रकार T और U लेता है और उन्हें मिलाकर एक नई वस्तु (ऑब्जेक्ट) लौटाता है।

सारांश

• जनरिक प्रकारों को पैरामीटर के रूप में मानते हुए पुन: उपयोग योग्य और प्रकार-सुरक्षित (टाइप-सेफ) कोड सक्षम करते हैं।
• फंक्शन्स, क्लासेज़, और इंटरफेस में जनरिक का उपयोग करके, आप विभिन्न प्रकारों को संभालने के लिए लचीला लॉजिक लिख सकते हैं।
• प्रकार तर्कों पर बाधाएं जोड़कर या डिफ़ॉल्ट प्रकार तर्क सेट करके, आप जनरिक की सीमा को नियंत्रित कर सकते हैं।

जनरिक का उपयोग करके, आप प्रकार-स्वतंत्र (टाइप-इंडिपेंडेंट), सामान्य-उद्देश्य (जनरल पर्पस) कोड लिख सकते हैं, जो TypeScript के शक्तिशाली प्रकार तंत्र (टाइप सिस्टम) का अधिकतम लाभ उठाता है।

आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।

YouTube Video