जेनरिक

जेनेरिक

अगले पाठ में आपका स्वागत है! इस पाठ में आप जेनेरिक के बारे में सीखेंगे, जो TypeScript की एक शक्तिशाली सुविधा है और आपको पुनः उपयोग योग्य तथा टाइप-सुरक्षित घटक बनाने देती है। आइए शुरू करें!

जेनेरिक आपको ऐसा पुनः उपयोग योग्य कोड लिखने देते हैं जो किसी भी टाइप के साथ काम करता है। ये टाइप के लिए स्थानधारक की तरह काम करते हैं, जिन्हें उपयोग करते समय आप निर्दिष्ट कर सकते हैं।

उदाहरण: एक जेनेरिक फ़ंक्शन:

कार्य: ऐसा जेनेरिक फ़ंक्शन लिखिए जो एक आर्ग्युमेंट ले और उसे बिना बदले वापस लौटाए।

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

console.log(identity<string>("Hello")); 
// Output: Hello
console.log(identity<number>(42)); 
// Output: 42

जेनेरिक इन कार्यों में आपकी सहायता करते हैं:

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

सुझाव: अधिक लचीला और आसानी से बनाए रखने योग्य कोड लिखने के लिए जेनेरिक का उपयोग कीजिए।

आप लचीले फ़ंक्शन बनाने के लिए जेनेरिक का उपयोग कर सकते हैं। उदाहरण:

कार्य: ऐसा जेनेरिक फ़ंक्शन लिखिए जो दो ऑब्जेक्ट को मिलाकर परिणाम लौटाए।

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

let merged = merge({ name: "Alice" }, { age: 25 });
console.log(merged); 
// Output: { name: "Alice", age: 25 }

अलग-अलग टाइप के लिए क्लासों को पुनः उपयोग योग्य बनाने हेतु उनमें जेनेरिक का उपयोग किया जा सकता है। उदाहरण:

class Box<T> {
  private contents: T;

  constructor(contents: T) {
    this.contents = contents;
  }

  getContents(): T {
    return this.contents;
  }
}

let stringBox = new Box<string>("Hello");
console.log(stringBox.getContents()); 
// Output: Hello

let numberBox = new Box<number>(42);
console.log(numberBox.getContents()); 
// Output: 42

अलग-अलग टाइप के लिए संरचना लागू करने हेतु इंटरफ़ेस में भी जेनेरिक का उपयोग किया जा सकता है। उदाहरण:

कार्य: एक जेनेरिक इंटरफ़ेस परिभाषित कीजिए और उसे कार्यान्वित करने वाला ऑब्जेक्ट बनाइए।

interface Pair<T, U> {
  first: T;
  second: U;
}

let coordinates: Pair<number, number> = { first: 10, second: 20 };
console.log(coordinates); 
// Output: { first: 10, second: 20 }

जेनेरिक पर सीमाएँ जोड़कर यह सुनिश्चित किया जा सकता है कि वे केवल विशिष्ट टाइप के साथ ही काम करें। उदाहरण:

function printLength<T extends { length: number }>(item: T): void {
  console.log(`Length: ${item.length}`);
}

printLength("Hello"); 
// Output: Length: 5
printLength([1, 2, 3]); 
// Output: Length: 3
// printLength(42); 
// Error: Argument of type 'number' is not assignable to parameter of type '{ length: number }'.

यदि कोई टाइप न दिया जाए, तो आप जेनेरिक के लिए डिफ़ॉल्ट टाइप निर्दिष्ट कर सकते हैं। उदाहरण:

कार्य: डिफ़ॉल्ट टाइप वाला जेनेरिक फ़ंक्शन बनाइए और अलग-अलग टाइप के साथ उसका परीक्षण कीजिए।

function wrap<T = string>(value: T): T[] {
  return [value];
}

console.log(wrap("Hello")); // Output: ["Hello"]
console.log(wrap(42)); // Output: [42]

बधाई हो! आपने TypeScript में पुनः उपयोग योग्य और टाइप-सुरक्षित फ़ंक्शन, क्लास तथा इंटरफ़ेस बनाने के लिए जेनेरिक का उपयोग करना सीख लिया है। लचीला और विस्तार योग्य कोड लिखने के लिए जेनेरिक एक शक्तिशाली साधन हैं। अगले पाठ में हम मैप किए गए और सशर्त टाइप जैसे उन्नत टाइप का अध्ययन करेंगे। कोड लिखते रहिए!