सादे जावास्क्रिप्ट ऑब्जेक्ट्स के बजाय मैप्स का उपयोग कब करें?
सादा जावास्क्रिप्ट ऑब्जेक्ट {key: 'value'} संरचित डेटा रखता है। लेकिन सादे JS ऑब्जेक्ट की अपनी सीमाएँ हैं:
केवल तार और प्रतीकों का उपयोग वस्तुओं की कुंजी के रूप में किया जा सकता है। यदि हम किसी अन्य चीज़ों का उपयोग करते हैं, तो एक वस्तु की कुंजी के रूप में संख्याएँ, फिर उन कुंजियों तक पहुँचने के दौरान हम देखेंगे कि उन कुंजियों को तारों में बदल दिया जाएगा, जिससे हमें प्रकार की निरंतरता खोनी पड़ेगी। const नाम = {1: 'एक', 2: 'दो'}; Object.keys (नाम); // ['1', '2']
जेएस पहचानकर्ताओं को किसी वस्तु के प्रमुख नामों (जैसे, स्ट्रिंग, कंस्ट्रक्टर आदि) के रूप में लिखकर प्रोटोटाइप से विरासत में मिली संपत्तियों को गलती से अधिलेखित करने की संभावना है।
किसी अन्य वस्तु का उपयोग किसी वस्तु की कुंजी के रूप में नहीं किया जा सकता है, इसलिए किसी वस्तु के लिए कोई अतिरिक्त जानकारी नहीं लिखी जा सकती है, उस वस्तु को किसी अन्य वस्तु की कुंजी के रूप में लिखा जा सकता है और किसी अन्य वस्तु के मूल्य में अतिरिक्त जानकारी होगी।
ऑब्जेक्ट पुनरावृत्त नहीं हैं
किसी वस्तु का आकार सीधे निर्धारित नहीं किया जा सकता है
ऑब्जेक्ट्स की ये सीमाएँ मैप्स द्वारा हल की जाती हैं, लेकिन हमें मैप्स को प्रतिस्थापन के बजाय ऑब्जेक्ट्स के पूरक के रूप में समझना चाहिए। मूल रूप से मानचित्र केवल सारणियों का सरणी है, लेकिन हमें मानचित्र ऑब्जेक्ट के लिए सारणियों के सरणी को नए कीवर्ड के साथ तर्क के रूप में पास करना होगा अन्यथा केवल सरणी के सरणी के लिए मानचित्र के उपयोगी गुण और तरीके उपलब्ध नहीं हैं। और याद रखें कि एरे के सरणी के अंदर की-वैल्यू जोड़े या मैप केवल कॉमा द्वारा अलग किए जाने चाहिए, सादे वस्तुओं में कोई कॉलोन की तरह नहीं।
मानचित्र या ऑब्जेक्ट का उपयोग करने के लिए 3 युक्तियां तय करने के लिए:
ऑब्जेक्ट्स पर मैप्स का उपयोग करें जब कुंजियाँ अज्ञात समय तक चलती हैं क्योंकि उपयोगकर्ता इनपुट या अनजाने में बनाई गई कुंजी उस कोड को तोड़ सकती है जो ऑब्जेक्ट का उपयोग करता है यदि वे कुंजी ऑब्जेक्ट के विरासत वाले गुणों को अधिलेखित करते हैं, तो मैप उन मामलों में सुरक्षित है। जब सभी कुंजियाँ एक ही प्रकार की हों और सभी मानचित्र एक ही प्रकार के हों तो भी मानचित्रों का उपयोग करें।
यदि कुंजी के रूप में आदिम मूल्यों को संग्रहीत करने की आवश्यकता है, तो मानचित्रों का उपयोग करें।
यदि हमें व्यक्तिगत तत्वों पर काम करने की आवश्यकता हो तो वस्तुओं का उपयोग करें।
मैप्स का उपयोग करने के लाभ हैं:
1. नक्शा किसी भी कुंजी प्रकार को स्वीकार करता है और कुंजी के प्रकार को संरक्षित करता है:
हम जानते हैं कि यदि वस्तु की कुंजी एक स्ट्रिंग या प्रतीक नहीं है, तो JS संक्षेप में इसे एक स्ट्रिंग में बदल देता है। इसके विपरीत, मानचित्र किसी भी प्रकार की कुंजियों को स्वीकार करता है: स्ट्रिंग, संख्या, बूलियन, प्रतीक आदि और मानचित्र मूल कुंजी प्रकार को संरक्षित करता है। यहां हम मैप के अंदर नंबर का उपयोग कुंजी के रूप में करेंगे और यह एक नंबर रहेगा:
const numbersMap= new Map();
numbersMap.set(1, 'one');
numbersMap.set(2, 'two');
const keysOfMap= [...numbersMap.keys()];
console.log(keysOfMap); // [1, 2]
मानचित्र के अंदर हम एक कुंजी के रूप में एक संपूर्ण वस्तु का उपयोग भी कर सकते हैं। ऐसा समय हो सकता है जब हम किसी वस्तु से संबंधित डेटा को स्टोर करना चाहते हैं, इस डेटा को ऑब्जेक्ट के अंदर संलग्न किए बिना ताकि हम दुबले ऑब्जेक्ट्स के साथ काम कर सकें लेकिन ऑब्जेक्ट के बारे में कुछ जानकारी संग्रहीत करना चाहते हैं। उन मामलों में हमें मानचित्र का उपयोग करने की आवश्यकता होती है ताकि हम वस्तु के प्रमुख और संबंधित डेटा को मूल्य के रूप में बना सकें।
const foo= {name: foo};
const bar= {name: bar};
const kindOfMap= [[foo, 'Foo related data'], [bar, 'Bar related data']];
लेकिन इस दृष्टिकोण का नकारात्मक पक्ष मूल्य द्वारा पहुंच की जटिलता है, क्योंकि हमें वांछित मूल्य प्राप्त करने के लिए पूरे सरणी के माध्यम से लूप करना पड़ता है।
function getBy Key(kindOfMap, key) {
for (const [k, v] of kindOfMap) {
if(key === k) {
return v;
}
}
return undefined;
}
getByKey(kindOfMap, foo); // 'Foo related data'
हम उचित मानचित्र का उपयोग करके मूल्य तक सीधी पहुंच नहीं होने की इस समस्या को हल कर सकते हैं।
const foo= {name: 'foo'};
const bar= {name: 'bar'};
const myMap= new Map();
myMap.set(foo, 'Foo related data');
myMap.set(bar, 'Bar related data');
console.log(myMap.get(foo)); // 'Foo related data'
हम WeakMap का उपयोग करके ऐसा कर सकते थे, बस लिखना होगा, const myMap = new WeakMap ()। मैप और वीकएप के बीच अंतर यह है कि वीकपाइप कुंजी (यहां वस्तुओं) के कचरा संग्रह के लिए अनुमति देता है, इसलिए यह मेमोरी लीक को रोकता है, वीकपाइप केवल ऑब्जेक्ट्स को कुंजी के रूप में स्वीकार करता है, और वीकैप ने तरीकों का सेट कम कर दिया है।
2. मुख्य नामों पर मानचित्र का कोई प्रतिबंध नहीं है:
सादे जेएस वस्तुओं के लिए हम गलती से प्रोटोटाइप से विरासत में मिली संपत्ति को अधिलेखित कर सकते हैं और यह खतरनाक हो सकता है। यहाँ हम अभिनेता की संपत्ति () की संपत्ति को अधिलेखित करेंगे:
const actor= {
name: 'Harrison Ford',
toString: 'Actor: Harrison Ford'
};
अब निर्धारित करते हैं कि एक fn .PlainObject () निर्धारित करता है कि आपूर्ति तर्क एक सादा वस्तु है और यह fn स्ट्रिंग का उपयोग करता है () इसे जांचने की विधि:
function isPlainObject(value) {
return value.toString() === '[object Object]';
}
isPlainObject(actor); // TypeError : value.toString is not a function
// this is because inside actor object toString property is a string instead of inherited method from prototype
मानचित्र में प्रमुख नामों पर कोई प्रतिबंध नहीं है, हम प्रमुख नामों का उपयोग कर सकते हैं जैसे किस्ट्रिंग, कंस्ट्रक्टर आदि। हालांकि एक्टरपॉइंट ऑब्जेक्ट में स्ट्रींग नाम की संपत्ति होती है, लेकिन एस्टरपॉइंट ऑब्जेक्ट के प्रोटोटाइप से विरासत में मिली विधि (toString) विरासत में मिलती है।
const actorMap= new Map();
actorMap.set('name', 'Harrison Ford');
actorMap.set('toString', 'Actor: Harrison Ford');
function isMap(value) {
return value.toString() === '[object Map]';
}
console.log(isMap(actorMap)); // true
यदि हमारे पास एक ऐसी स्थिति है जहां उपयोगकर्ता इनपुट कुंजी बनाता है तो हमें एक सादे वस्तु के बजाय उन कुंजियों को मानचित्र के अंदर ले जाना चाहिए। ऐसा इसलिए है क्योंकि उपयोगकर्ता एक कस्टम फ़ील्ड नाम चुन सकता है, जैसे, स्ट्रींगर, कंस्ट्रक्टर इत्यादि तो एक सादे ऑब्जेक्ट में ऐसे प्रमुख नाम संभवतः उस कोड को तोड़ सकते हैं जो बाद में इस ऑब्जेक्ट का उपयोग करता है। तो सही समाधान उपयोगकर्ता इंटरफ़ेस स्थिति को एक नक्शे से बांधना है, मानचित्र को तोड़ने का कोई तरीका नहीं है:
const userCustomFieldsMap= new Map([['color', 'blue'], ['size', 'medium'], ['toString', 'A blue box']]);
3. नक्शा चलने योग्य है:
एक सादे वस्तु के गुणों को पुनरावृत्त करने के लिए हमें Object.entries () या Object.keys () की आवश्यकता होती है। Object.entries (plainObject) ऑब्जेक्ट से निकाले गए प्रमुख मूल्य जोड़े की एक सरणी देता है, हम तब उन कुंजियों और मूल्यों को नष्ट कर सकते हैं और सामान्य कुंजी और मान आउटपुट प्राप्त कर सकते हैं।
const colorHex= {
'white': '#FFFFFF',
'black': '#000000'
}
for(const [color, hex] of Object.entries(colorHex)) {
console.log(color, hex);
}
//
'white' '#FFFFFF'
'black' '#000000'
जैसा कि मैप्स चलने योग्य हैं, इसीलिए हमें मैप्स पर मैप करने और कुंजी को नष्ट करने के लिए प्रविष्टियों () तरीकों की आवश्यकता नहीं है, मान सरणी को सीधे मैप पर किया जा सकता है क्योंकि मैप के अंदर प्रत्येक तत्व कॉमा द्वारा अलग किए गए प्रमुख मूल्य जोड़े के एक सरणी के रूप में रहता है। ।
const colorHexMap= new Map();
colorHexMap.set('white', '#FFFFFF');
colorHexMap.set('black', '#000000');
for(const [color, hex] of colorHexMap) {
console.log(color, hex);
}
//'white' '#FFFFFF' 'black' '#000000'
इसके अलावा map.keys () कुंजियों के ऊपर एक पुनरावृत्ति देता है और map.values () मानों पर एक पुनरावृत्ति देता है।
4. हम आसानी से एक मानचित्र का आकार जान सकते हैं
हम सीधे सादे ऑब्जेक्ट में गुणों की संख्या निर्धारित नहीं कर सकते हैं। हमें एक सहायक fn की आवश्यकता है जैसे, Object.keys () जो ऑब्जेक्ट की कुंजियों के साथ एक सरणी देता है फिर लंबाई संपत्ति का उपयोग करके हम कुंजियों की संख्या या सादे ऑब्जेक्ट का आकार प्राप्त कर सकते हैं।
const exams= {'John Rambo': '80%', 'James Bond': '60%'};
const sizeOfObj= Object.keys(exams).length;
console.log(sizeOfObj); // 2
लेकिन मैप्स के मामले में हम map.size प्रॉपर्टी का उपयोग करके मैप के आकार तक सीधी पहुंच बना सकते हैं।
const examsMap= new Map([['John Rambo', '80%'], ['James Bond', '60%']]);
console.log(examsMap.size);
