`Map` ऑब्जेक्ट

इस लेख में Map ऑब्जेक्ट को समझाया गया है।

हम मूल संचालन से लेकर वास्तविक दुनिया के उपयोगी उदाहरणों तक, चरण दर चरण समझाएंगे।

YouTube Video

Map ऑब्जेक्ट

Map एक संग्रह है जो कुंजी-मूल्य जोड़ों को संग्रहीत करता है। यह एक ऑब्जेक्ट के समान है, लेकिन इसमें अंतर यह है कि किसी भी प्रकार (जैसे ऑब्जेक्ट, फ़ंक्शन या प्रिमिटिव्स) को कुंजी के रूप में इस्तेमाल किया जा सकता है, और डाले गए तत्वों का क्रम सुरक्षित रहता है।

Map की मूल बातें

सबसे पहले, आइए देखें कि Map कैसे बनाएं और उस पर मूल संचालन कैसे करें।

निम्नलिखित कोड एक साधारण उदाहरण है जो एक खाली मैप बनाता है, कुंजियाँ जोड़ता है, और मान प्राप्त करता है।

1// Create an empty Map and add key-value pairs
2const m = new Map();
3m.set('a', 1);
4m.set('b', 2);
5
6console.log(m.get('a')); // 1
7console.log(m.size);     // 2

• इस कोड में, आप set से तत्व जोड़ सकते हैं, get से मान प्राप्त कर सकते हैं और size से तत्वों की संख्या जांच सकते हैं।
• Map सम्मिलन क्रम बनाए रखता है, जिससे यह क्रम-निर्भर प्रसंस्करण के लिए उपयुक्त होता है।

set, get, has, और delete का व्यवहार

यहाँ पढ़ने, लिखने, मौजूदगी जांचने और हटाने के सामान्य उदाहरण दिए गए हैं।

निम्न कोड से, आप प्रत्येक विधि के प्राप्त मान और प्रभाव देख सकते हैं।

 1// Demonstrate set, get, has, and delete
 2const m2 = new Map();
 3m2.set('x', 10);
 4console.log(m2.has('x'));  // true
 5console.log(m2.get('y'));  // undefined
 6
 7m2.delete('x');
 8console.log(m2.has('x'));  // false
 9
10// set returns the map itself, allowing method chaining
11m2.set('a', 1).set('b', 2);
12console.log(m2);  // Map { 'a' => 1, 'b' => 2 }

• अगर कुंजी मौजूद नहीं है तो get undefined लौटाता है। has किसी कुंजी के अस्तित्व की जाँच करता है, और delete किसी कुंजी को हटाता है।
• साथ ही, set स्वयं मैप लौटाता है, जिससे मेथड चेनिंग संभव है।

कोई भी प्रकार कुंजी के रूप में इस्तेमाल किया जा सकता है (ऑब्जेक्ट्स को कुंजी के रूप में उपयोग करना)

Map का एक मुख्य लाभ यह है कि आप ऑब्जेक्ट्स को सीधे कुंजी के रूप में उपयोग कर सकते हैं।

निम्न उदाहरण दिखाता है कि ऑब्जेक्ट्स को कुंजी के रूप में उपयोग कर Map में मान कैसे जोड़ें।

 1// Use objects as keys in a Map
 2const keyObj = { id: 1 };
 3const keyFunc = () => {};
 4const objMap = new Map();
 5
 6// Another object with the same content but a different reference
 7const anotherKeyObj = { id: 1 };
 8
 9objMap.set(keyObj, 'objectValue');
10objMap.set(keyFunc, 'functionValue');
11objMap.set(anotherKeyObj, 'anotherValue');
12
13console.log(objMap.get(keyObj));         // 'objectValue'
14console.log(objMap.get(keyFunc));        // 'functionValue'
15console.log(objMap.get(anotherKeyObj));  // 'anotherValue'

• जब ऑब्जेक्ट्स को कुंजी के रूप में उपयोग करते हैं तो यह जरूरी है कि वे समान संदर्भ हों। भले ही उनकी सामग्री एक जैसी हो, विभिन्न संदर्भ वाले ऑब्जेक्ट्स अलग-अलग माने जाते हैं और एक ही कुंजी नहीं होते।

परावृत्ति (लूपिंग)

Map में सम्मिलन क्रम बना रहता है, इसलिए अक्सर परावृत्ति का उपयोग किया जाता है।

नीचे, हम for...of, forEach, और keys(), values(), तथा entries() विधियों का उपयोग दिखाते हैं।

 1// Iterating a Map with for...of and forEach
 2const iterMap = new Map([['a', 1], ['b', 2], ['c', 3]]);
 3
 4// for...of over entries (default)
 5for (const [key, value] of iterMap) {
 6  console.log(key, value);
 7}
 8
 9// forEach callback
10iterMap.forEach((value, key) => {
11  console.log(key, value);
12});
13
14// keys() and values()
15console.log([...iterMap.keys()]);   // ['a','b','c']
16console.log([...iterMap.values()]); // [1,2,3]

• entries() [key, value] जोड़ों की एक एरे लौटाता है, जिसे स्प्रेड सिंटैक्स से एरे में बदला जा सकता है। ध्यान दें कि forEach के लिए कॉलबैक क्रम में value, key तर्क लेता है।

Map और Object के बीच रूपांतरण

आप एक मौजूद ऑब्जेक्ट को Map में या किसी Map को सादा ऑब्जेक्ट या एरे में बदल सकते हैं।

 1// Convert between Map and Object / Array
 2const obj = { a: 1, b: 2 };
 3const mapFromObj = new Map(Object.entries(obj)); // Object -> Map
 4console.log(mapFromObj.get('a')); // 1
 5
 6const objFromMap = Object.fromEntries(mapFromObj); // Map -> Object
 7console.log(objFromMap); // { a: 1, b: 2 }
 8
 9const arrayFromMap = [...mapFromObj]; // Map -> Array of [key, value]
10console.log(arrayFromMap); // [['a',1], ['b',2]]

• Object.entries और Object.fromEntries का उपयोग रूपांतरण को आसान बनाता है। हालांकि, चूंकि ऑब्जेक्ट कुंजियाँ केवल स्ट्रिंग या सिंबल होती हैं, इसलिए ऑब्जेक्ट में वापस बदलने पर गैर-स्ट्रिंग कुंजियाँ खो जाती हैं।

व्यावहारिक पैटर्न: आवृत्ति गणना (Count Map)

जब किसी ऐरे में तत्वों की आवृत्ति गिनी जाती है, तो Map का उपयोग करना इस प्रक्रिया को सरल बना देता है।

निम्न कोड एक उदाहरण है जिसमें एरे में स्ट्रिंग्स की आवृत्ति गिनने और उन्हें क्रमबद्ध करने के लिए मैप का उपयोग किया गया है।

1// Count frequencies with Map
2const arr = ['apple','banana','apple','orange','banana','apple'];
3const freq = new Map();
4
5for (const item of arr) {
6  freq.set(item, (freq.get(item) || 0) + 1);
7}
8
9console.log([...freq.entries()]); // [['apple',3], ['banana',2], ['orange',1]]

• Map का उपयोग मौजूदगी जांचना और अपडेट करना आसान बनाता है। यह ऑब्जेक्ट्स के साथ भी किया जा सकता है, लेकिन मनमानी कुंजियों के साथ काम करते हुए Map अधिक सहज होता है।

Map और JSON.stringify (सीरियलाइजेशन) पर ध्यान दें

JSON.stringify किसी Map को सीधे सीरियलाइज़ नहीं कर सकता। यदि आपको किसी Map को सहेजना है, तो पहले उसे रूपांतरित करना होगा।

निम्न उदाहरण दिखाता है कि किसी Map को JSON में बदलने से पहले एरे में और फिर पुनर्स्थापित कैसे करें।

1// Serialize and deserialize a Map
2const m3 = new Map([['x', 1], ['y', 2]]);
3const json = JSON.stringify([...m3]); // convert to array first
4console.log(json); // '[["x",1],["y",2]]'
5
6const restored = new Map(JSON.parse(json));
7console.log(restored.get('x')); // 1

• जिन Maps को सहेजना या भेजना हो, उन्हें सीरियलाइजेशन से पहले एरे में बदलना चाहिए। पुनर्स्थापन करते समय, JSON.parse का उपयोग करके एरे में बदलें, फिर उसे Map में बदलें।

WeakMap का परिचय और इसका उपयोग कैसे करें

WeakMap इस मायने में अलग है कि इसकी कुंजियों को कमजोर संदर्भ मिलता है (जो गार्बेज कलेक्शन के अधीन होती हैं)।

यह ऑब्जेक्ट्स को कुंजी के रूप में लेकर कैश या मेटाडेटा रखने में सहायक है, और जब कुंजी ऑब्जेक्ट हटा दी जाती है तो यह स्वतः मुक्त हो जाता है।

1// WeakMap for metadata tied to object lifecycle
2const wm = new WeakMap();
3let obj = {};
4wm.set(obj, { meta: 'info' });
5console.log(wm.get(obj)); // { meta: 'info' }
6
7obj = null; // now the object can be GC'd and its entry removed from WeakMap

• WeakMap को न तो सूचीबद्ध किया जा सकता है, न ही उसका आकार जांचा जा सकता है, लेकिन यह मेमोरी लीकेज से बचाव में सहायक है।

सारांश

Map एक सुविधाजनक संग्रह है जो ऑब्जेक्ट्स के विपरीत, किसी भी प्रकार को कुंजी बनने देता है और सम्मिलन क्रम बनाए रखता है। मूल संचालन से उन्नत उपयोग तक सब कुछ समझकर, आप डेटा को और अधिक लचीले और सहज तरीके से प्रबंधित कर सकते हैं। प्रयोग अनुसार Object और Map का सही उपयोग करके, आप कोड की स्पष्टता और पठनीयता को काफी बढ़ा सकते हैं।

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

YouTube Video