कुंजी वाले कलेक्शन

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

मैप

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

मैप बनाने के लिए, Map() कंस्ट्रक्टर का इस्तेमाल करें:

const myMap = new Map();

myMap;
> Map(0)

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

const myMap = new Map([
    [ "myKey", "A string value" ],
    [ "mySecondKey", 500 ],
    [ "myThirdKey", true ]
]);

myMap;
> Map(3) {'myKey' => 'A string value', 'mySecondKey' => 500, 'myThirdKey' => true}

ध्यान दें, मैप ऑब्जेक्ट किसी लिटरल ऑब्जेक्ट से इस तरह अलग होता है कि और कुंजियां, दोनों में कोई भी डेटा टाइप और वैल्यू हो सकती है:

const notAFunction = () => console.log( "function" );
const myMap = new Map([
  [ null, 0 ],
  [ false, "This is false" ],
  [ undefined, "No defined value" ],
  [ NaN, "Not a number" ]
]);

myMap;
> Map(4) {null => 0, false => 'This is false', undefined => 'No defined value', NaN => 'Not a number'}

मैप एलिमेंट पाने, सेट करने या मिटाने के लिए, Map कंस्ट्रक्टर से इनहेरिट किए गए तरीकों का इस्तेमाल करें:

const myMap = new Map();

myMap;
> Map(0)

myMap.set( "myKey", "My value." );

myMap.has( "myKey" );
> true

myMap.get( "myKey" );
"My value."

myMap.delete( "myKey" );

myMap;
> Map(0)

मैप में कुंजियां यूनीक होती हैं. इसका मतलब है कि एक जैसी कुंजी सेट करने से, पहले से सेव किए गए की-वैल्यू पेयर की जगह लागू हो जाती है:

const myMap = new Map([ [ "myKey", "A string value" ] ]);

myMap.set( "myKey", 500 );

myMap;
> Map(1) {'myKey' => 500}

ऑब्जेक्ट की तरह ही, आपके पास const के साथ तय किए गए वैरिएबल को मैप असाइन करने और फिर उस मैप में बदलाव करने का विकल्प होता है. हालांकि, const के इस्तेमाल के अन्य उदाहरणों की तरह ही, यहां भी वैरिएबल को बदला या मिटाया नहीं जा सकता:

const myMap = new Map();
myMap.set( "myKey", "A string value" );

myMap;
> Map(1) {'myKey' => 500}

WeakMap

WeakMap एक ऐसा मैप है जिसमें "कमज़ोर" references होते हैं. ये उन ऑब्जेक्ट या सिंबल के रेफ़रंस होने चाहिए जिन्हें ग्लोबल सिंबल रजिस्ट्री में नहीं जोड़ा गया है.

WeakMap बनाने के लिए, WeakMap() कंस्ट्रक्टर का इस्तेमाल करें:

const myWeakMap = new WeakMap();

myWeakMap;
> WeakMap(0)

WeakMap सिंटैक्स, Maps की तरह ही है, लेकिन WeakMaps को फिर से उपलब्ध नहीं किया जा सकता. ऑब्जेक्ट या सिंबल के अलावा, किसी अन्य वैल्यू का इस्तेमाल कुंजी के तौर पर करने की कोशिश करने से सिंटैक्स में गड़बड़ी हो सकती है. जब WeakMap के बाहर किसी कुंजी का कोई references मौजूद नहीं है, तो वह ऑब्जेक्ट या सिंबल और WeakMaps में उससे जुड़ी वैल्यू, दोनों कचरा इकट्ठा करने की ज़रूरी शर्तें पूरी करते हैं.

यह कुंजी के रूप में ऑब्जेक्ट के रेफ़रंस का इस्तेमाल करके, WeakMap में किसी ऑब्जेक्ट से जुड़े मेटाडेटा को स्टोर करने जैसे इस्तेमाल की अनुमति देता है. अगर इस ऑब्जेक्ट में कोई दूसरा रेफ़रंस मौजूद नहीं है और ऑब्जेक्ट को मेमोरी से हटा दिया जाता है, तो उससे जुड़ा मेटाडेटा भी हटा दिया जाता है.

सेट करें

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

सेट बनाने के लिए, Set() कंस्ट्रक्टर का इस्तेमाल करें:

const mySet = new Set();

mySet;
> Set []

किसी अरे लिटरल वैल्यू से भी सेट बनाया जा सकता है:

const mySet = new Set([ 1, 2, 3 ]);

mySet;
> Set(3) [ 1, 2, 3 ]

सेट में डुप्लीकेट एलिमेंट इस्तेमाल करने की अनुमति नहीं है. इसलिए, जब किसी सेट को ऐसी कैटगरी से बनाया जाता है जिसमें एक ही वैल्यू के एक से ज़्यादा इंस्टेंस होते हैं, तो यह उस वैल्यू का सिर्फ़ पहला इंस्टेंस बनाए रखता है:

const mySet = new Set([ 1, 2, 3, 2 ]);

mySet;
> Set(3) [ 1, 2, 3 ]

किसी सेट में एलिमेंट जोड़ने या हटाने के लिए, Set कंस्ट्रक्टर से इनहेरिट किए गए तरीकों का इस्तेमाल करें. ये तरीके, इंडेक्स को रेफ़र करने के बजाय, खुद ही एलिमेंट की वैल्यू के आधार पर एलिमेंट पर काम करते हैं:

const mySet = new Set();

mySet.add( "My value." );

mySet;
> Set [ "My value." ]

mySet.has( "My value." );
> true

mySet.delete( "My value." );

mySet;
> Set []

सेट, इंडेक्स किए गए कलेक्शन नहीं होते हैं और इनका इस्तेमाल इस तरह से नहीं किया जाना चाहिए. हालांकि, सेट में शामिल एलिमेंट को शामिल करने के लिए दोहराया जाता है. किसी सेट में डुप्लीकेट एलीमेंट मान जोड़ने की कोशिशों को स्किप कर दिया जाता है, जिससे मूल प्रविष्टि क्रम बरकरार रहता है:

const mySet = new Set([ 1, 2, 3 ]);

mySet;
> Set(3) [ 1, 2, 3 ]

mySet.add( 2 );
> Set(3) [ 1, 2, 3 ]

किसी सेट से कोई अरे बनाने के लिए, Array.from() तरीके या स्प्रेड सिंटैक्स का इस्तेमाल करें:

const mySet = new Set([ 1, 2, 3 ]);
const myArray = Array.from( mySet );

myArray;
> Array(3) [ 1, 2, 3 ]

[ ...mySet ];
> Array(3) [ 1, 2, 3 ]

WeakSet

WeakSet एक ऐसा सेट है जिसमें सिर्फ़ ट्रैश में इकट्ठा की जा सकने वाली वैल्यू शामिल होती हैं. जैसे, ऑब्जेक्ट के रेफ़रंस या सिंबल जिन्हें ग्लोबल सिंबल रजिस्ट्री में नहीं जोड़ा गया है.

कमज़ोर सेट बनाने के लिए, WeakSet() कंस्ट्रक्टर का इस्तेमाल करें:

const myWeakSet = new WeakSet();

myWeakSet;
> WeakSet []

WeakSet सिंटैक्स, 'सेट' की तरह ही है. हालांकि, WeakSet का इस्तेमाल नहीं किया जा सकता. साथ ही, किसी ऑब्जेक्ट या सिंबल के अलावा कोई अन्य वैल्यू जोड़ने की कोशिश करने पर, सिंटैक्स में गड़बड़ी हो सकती है. WeakMap की तरह ही, जब WeakSet में दी गई किसी वैल्यू के लिए कोई दूसरा references मौजूद नहीं है, तो वह ट्रैश कलेक्शन की ज़रूरी शर्तों को पूरा करती है.

यह इस तरह के इस्तेमाल की अनुमति देता है जैसे एक ही जगह पर मिलते-जुलते ऑब्जेक्ट का एक और बार-बार डेटा इकट्ठा करना. अगर WeakSet में दिए गए किसी ऑब्जेक्ट के रेफ़रंस के लिए कोई दूसरा रेफ़रंस मौजूद नहीं है, तो उस ऑब्जेक्ट से जुड़े एलिमेंट को WeakSet से भी हटा दिया जाता है.

जांचें कि आपको कितना समझ आया

        const myMap = new Map([ [ "myKey", "My string" ] ]);
        myMap.set( "myKey", 100 );