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

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

मैप

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

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

const myMap = new Map();

myMap;
> Map(0)

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

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 एक ऐसा मैप होता है जिसमें "कमज़ोर" स्थिति होती है रेफ़रंस, जो ऑब्जेक्ट या प्रतीकों के रेफ़रंस होने चाहिए जिसे ग्लोबल सिंबल रजिस्ट्री में नहीं जोड़ा गया है.

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

const myWeakMap = new WeakMap();

myWeakMap;
> WeakMap(0)

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

इससे, इस्तेमाल के उदाहरण की अनुमति मिलती है, जैसे कि किसी ऑब्जेक्ट से जुड़े मेटाडेटा को सेव करना ऑब्जेक्ट के रेफ़रंस को कुंजी के तौर पर इस्तेमाल करके, 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 बनाने के लिए, WeakSet() कंस्ट्रक्टर का इस्तेमाल करें:

const myWeakSet = new WeakSet();

myWeakSet;
> WeakSet []

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

इससे कई बार इस्तेमाल किए जा सकने वाले यूआरएल इकट्ठा किए जा सकते हैं, संबंधित ऑब्जेक्ट. अगर वीकसेट, संबंधित एलिमेंट को भी वीकसेट से हटा दिया जाता है.

देखें कि आपको कितना समझ आया है

यहां दी गई जानकारी देखें:

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

myMap से क्या नतीजे मिलते हैं?

100

"My string"

undefined