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

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

JavaScript और Node.js पर आधुनिक विकास के लिए न केवल तेज़ कोड लिखना आवश्यक है, बल्कि उसकी विश्वसनीयता भी महत्वपूर्ण है। टाइपों में लचीलापन और सुरक्षा प्रदान करने वाले प्रमुख उपकरणों में से एक हैं जेनेरिक्स (Generics)। इस लेख में हम समझेंगे कि जेनेरिक्स क्या हैं, JavaScript इकोसिस्टम में इनकी आवश्यकता क्यों है, और व्यवहार में इनका प्रभावी ढंग से उपयोग कैसे करें। यह सामग्री शुरुआती और अनुभवी डेवलपर्स दोनों के लिए उपयोगी होगी जो अपने ज्ञान को गहरा करना चाहते हैं।

Generics क्या हैं और इनकी आवश्यकता क्यों है?

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

इसकी आवश्यकता क्यों है? कल्पना करें कि आप एक फ़ंक्शन लिख रहे हैं जो किसी सरणी का पहला तत्व लौटाता है। जेनेरिक्स के बिना, आपको any प्रकार का उपयोग करना होगा, जो आपको IDE से संकेतों से वंचित करता है और त्रुटियों के जोखिम को बढ़ाता है। Generics के साथ, आप सार्वभौमिक कोड लिख सकते हैं जो संख्याओं, स्ट्रिंग्स, ऑब्जेक्ट्स और किसी भी अन्य प्रकार के साथ सुरक्षित रूप से काम करेगा।

// जेनेरिक्स के बिना (खतरनाक)function getFirst(arr: any[]): any {  return arr[0];}

// जेनेरिक्स के साथ (सुरक्षित)function getFirst<T>(arr: T[]): T | undefined {  return arr[0];}

const num = getFirst([1, 2, 3]); // प्रकार numberconst str = getFirst(['a', 'b']); // प्रकार string

इस प्रकार, जेनेरिक्स कोड को अधिक पुन: प्रयोज्य और टाइप-सुरक्षित बनाते हैं, जो विशेष रूप से Node.js पर बड़े प्रोजेक्ट्स में महत्वपूर्ण है।

TypeScript (प्रकारों के साथ JavaScript) में Generics का उपयोग कैसे करें

हालाँकि शुद्ध JavaScript जेनेरिक्स का समर्थन नहीं करता है, TypeScript पूरी तरह से Node.js इकोसिस्टम के साथ एकीकृत होता है। आइए उपयोग के मुख्य परिदृश्यों पर विचार करें।

1. सामान्यीकृत फ़ंक्शन

सबसे आसान तरीका है किसी फ़ंक्शन को एक या अधिक प्रकारों के साथ पैरामीटराइज़ करना। यह संग्रह के साथ काम करने वाली उपयोगिताओं के लिए उपयोगी है।

// दो सरणियों को मर्ज करने का फ़ंक्शनfunction mergeArrays<T>(arr1: T[], arr2: T[]): T[] {  return [...arr1, ...arr2];}

const numbers = mergeArrays([1, 2], [3, 4]); // number[]const strings = mergeArrays(['hello'], ['world']); // string[]

यहाँ <T> एक प्रकार पैरामीटर है जो फ़ंक्शन को कॉल करने पर स्वचालित रूप से प्रतिस्थापित हो जाता है। आप स्पष्ट रूप से प्रकार भी निर्दिष्ट कर सकते हैं:

const mixed = mergeArrays<number | string>([1], ['a']); // (number | string)[]

2. सामान्यीकृत क्लास

जेनेरिक्स डेटा संरचनाएँ जैसे स्टैक, क्यू या कैश बनाने के लिए उपयुक्त हैं।

class Stack<T> {  private items: T[] = [];

  push(item: T): void {    this.items.push(item);  }

  pop(): T | undefined {    return this.items.pop();  }

  peek(): T | undefined {    return this.items[this.items.length - 1];  }}

// उपयोगconst numberStack = new Stack<number>();numberStack.push(10);numberStack.push(20);console.log(numberStack.pop()); // 20

const stringStack = new Stack<string>();stringStack.push('TypeScript');console.log(stringStack.peek()); // 'TypeScript'

3. प्रकारों की सीमाएँ (Constraints)

कभी-कभी जेनेरिक को एक निश्चित प्रकार के सेट तक सीमित करने की आवश्यकता होती है। उदाहरण के लिए, यह सुनिश्चित करना कि ऑब्जेक्ट में length गुण है।

// T को उन प्रकारों तक सीमित करें जिनमें length हैfunction logLength<T extends { length: number }>(item: T): void {  console.log(`लंबाई: ${item.length}`);}

logLength('नमस्ते'); // 6logLength([1, 2, 3]); // 3// logLength(123); // त्रुटि: number में length नहीं है

कीवर्ड exten