‘सेट’ ऑब्जेक्ट
यह लेख ‘सेट’ ऑब्जेक्ट की व्याख्या करता है।
हम ‘सेट’ ऑब्जेक्ट को व्यावहारिक उदाहरणों के साथ समझाएंगे।
YouTube Video
‘सेट’ ऑब्जेक्ट
‘सेट’ एक बिल्ट-इन ऑब्जेक्ट है जिसका उपयोग अद्वितीय, गैर-डुप्लिकेट मानों के संग्रह को संभालने के लिए किया जाता है। यह आपको डुप्लिकेट को हटाने और अस्तित्व जांच जैसे कार्यों को ऐरे की तुलना में और अधिक सरलता से लिखने देता है, और यूनियन व इंटरसेक्शन जैसे सेट ऑपरेशन को भी आसान बनाता है।
मूल बातें: सेट बनाना और उपयोग करना
सबसे पहले, आइए देखें कि एक ‘सेट’ कैसे बनाते हैं, उसमें तत्व कैसे जोड़ते/हटाते हैं, अस्तित्व की जांच और उसका आकार (साइज़) कैसे प्राप्त करते हैं।
नीचे एक बेसिक उदाहरण है जिसमें एक नया ‘सेट’ बनाया गया है और ‘add’, ‘has’, ‘delete’, तथा ‘size’ का डेमो दिया गया है।
1// Create a Set and demonstrate add, has, delete, and size
2const s = new Set();
3
4s.add(1);
5s.add(2);
6s.add(2); // duplicate, ignored
7
8console.log(s.has(1)); // true
9console.log(s.has(3)); // false
10
11s.delete(2);
12console.log(s.size); // 1
13
14console.log([...s]); // [1]
- जैसा कि इस कोड में दिखाया गया है,
Setअपने-आप डुप्लिकेट प्राइमिटिव मानों को हटा देता है, और आपsizeका उपयोग करके तत्वों की संख्या प्राप्त कर सकते हैं।
इटरेशन विधियां
Set इटेरेबल है, इसलिए आप इसमें for...of या forEach का उपयोग करके लूप चला सकते हैं। क्रम (order) वही होता है जिसमें मान डाले गए थे।
यहाँ ‘for...of’ और ‘forEach’ के सामान्य उपयोग के तरीके दिए गए हैं।
1// Iterate a Set with for...of and forEach
2const s = new Set(['a', 'b', 'c']);
3
4for (const v of s) {
5 console.log('for...of:', v);
6}
7
8s.forEach((value, sameValue, setRef) => {
9 // Note: second arg is same as first for Set API to match Map signature
10 console.log('forEach:', value);
11});forEachके लिए कॉलबैक के सिग्नेचर हैvalue, value, set(मैप के साथ संगतता हेतु), लेकिन वास्तव में अक्सर केवल पहलाvalueही आवश्यक होता है।
ऐरे और सेट के बीच परिवर्तन (डुप्लिकेट हटाने के लिए उपयोगी)
यहाँ हम ऐरे से डुप्लिकेट हटाने की आसान तकनीक, तथा ‘सेट’ को फिर से ऐरे में बदलने का तरीका दिखाते हैं।
नीचे ऐरे को ‘सेट’ में डालकर डुप्लिकेट हटाने का उदाहरण है।
1// Deduplicate an array using Set
2const arr = [1, 2, 2, 3, 3, 3];
3const deduped = [...new Set(arr)];
4console.log(deduped); // [1, 2, 3]
5
6// Convert a Set to an array using Array.from
7const s = new Set([4, 5, 6]);
8const arrFromSet = Array.from(s);
9console.log(arrFromSet); // [4, 5, 6]
- यह तरीका छोटा और तेज़ है, इसलिए ऐरे से डुप्लिकेट हटाने में अधिकतर इसका प्रयोग होता है। यह प्रिमिटिव मानों के लिए विशेष रूप से प्रभावी है।
ऑब्जेक्ट और रेफरेंस हैंडलिंग
‘सेट’ में ऑब्जेक्ट्स का रेफरेंस से तुलनात्मक मूल्यांकन होता है, इसलिए एक जैसे कंटेंट वाले अलग-अलग ऑब्जेक्ट्स को अलग-अलग तत्व माना जाता है।
निम्न कोड दिखाता है कि ‘सेट’ में ऑब्जेक्ट डालने पर क्या होता है।
1// Objects are compared by reference in a Set
2const obj1 = { x: 1 };
3const obj2 = { x: 1 };
4
5const s = new Set();
6s.add(obj1);
7s.add(obj2);
8
9console.log(s.size); // 2 (different references)
10console.log(s.has(obj1)); // true
11console.log(s.has({ x: 1 })); // false (different object)
- ऑब्जेक्ट्स के लिए डुप्लिकेट की पहचान रेफरेंस आइडेंटिटी पर आधारित होती है, इसलिए यदि आप केवल कंटेंट के आधार पर डुप्लिकेट हटाना चाहते हैं तो आपको उन्हें सीरियलाइज़ या अन्य रूप से प्रोसेस करना पड़ेगा।
विशेष मान: ‘NaN’ और ‘-0’/‘+0’ की हैंडलिंग
‘सेट’ मूल्य समानता निर्धारित करने के लिए सेम-वैल्यू-ज़ीरो तुलना नियम का उपयोग करता है। संख्याओं के सन्दर्भ में इस तुलना विधि के निम्नलिखित गुण हैं:।
- ‘NaN’ को ‘NaN’ के बराबर माना जाता है।
- ‘+0’ और ‘-0’ (हमेशा) अलग नहीं माने जाते, और इन्हें एक ही मान के रूप में माना जाता है।
इसलिए, जब आप इन मानों को ‘सेट’ में जोड़ते हैं तो निम्नलिखित व्यवहार होता है:।
1// NaN and zero behavior in Set
2const s = new Set();
3
4s.add(NaN);
5s.add(NaN);
6console.log(s.size); // 1 (NaN considered the same)
7
8s.add(+0);
9s.add(-0);
10console.log(s.size); // still 2 (NaN + 0)
11console.log([...s]); // [NaN, 0] (order may vary but only one zero)
- सामान्य तुलना (‘NaN === NaN’) में परिणाम ‘false’ होता है, लेकिन ‘सेट’ में सारे ‘NaN’ एक ही मान माने जाते हैं।
- गणितीय दृष्टि से ‘+0’ और ‘-0’ में अंतर किया जा सकता है, लेकिन ‘सेट’ में ये दोनों ‘0’ के रूप में माने जाते हैं।
- नतीजतन, ‘सेट’ में केवल एक ‘NaN’ और एक ‘0’ ही रहते हैं।
- ‘सेट’ का तुलना नियम ‘Object.is’ जैसा है, लेकिन बिल्कुल एक जैसा नहीं है।
Object.is(+0, -0)तो ‘false’ देता है, लेकिन ‘सेट’ में ये दोनों समान माने जाते हैं। कृपया इस अंतर का ध्यान रखें।
सहज उपयोगिता: सेट ऑपरेशन (यूनियन, इंटरसेक्शन, डिफरेंस)
‘सेट’ ऑपरेशन को ‘सेट’ के सहारे और अधिक स्पष्ट रूप से लिखा जा सकता है। नीचे आम इम्प्लीमेंटेशन उदाहरण दिए गए हैं।
यहाँ ‘union’, ‘intersection’ और ‘difference’ के लिए फंक्शन के उदाहरण दिए गए हैं।
1// Set operations: union, intersection, difference
2function union(a, b) {
3 return new Set([...a, ...b]);
4}
5
6function intersection(a, b) {
7 return new Set([...a].filter(x => b.has(x)));
8}
9
10function difference(a, b) {
11 return new Set([...a].filter(x => !b.has(x)));
12}
13
14// Demo
15const A = new Set([1, 2, 3]);
16const B = new Set([3, 4, 5]);
17
18console.log('union', [...union(A, B)]); // [1,2,3,4,5]
19console.log('intersection', [...intersection(A, B)]); // [3]
20console.log('difference A\\B', [...difference(A, B)]); // [1,2]
- ‘सेट’ और ऐरे के संयोजन में फिल्टर का उपयोग करके सेट ऑपरेशन को सरलता से लिखा जा सकता है। बड़े डाटा सेट के साथ काम करते समय ‘has’ का O(1) प्रदर्शन ऑपरेशन को तेज़ बनाता है।
व्यावहारिक उदाहरण: ऐरे की भिन्नता निकालना (जोड़े गए/हटाए गए आइटम पहचानना)
निम्न उदाहरण दिखाता है कि दो ऐरे (पुरानी सूची और नई सूची) के अंतर को ‘सेट’ की मदद से कैसे निकाला जाता है। इससे आप यह पता कर सकते हैं कि कौन-से तत्व जोड़े गए और कौन-से हटाए गए।
1// Find added and removed items between two arrays
2function diffArrays(oldArr, newArr) {
3 const oldSet = new Set(oldArr);
4 const newSet = new Set(newArr);
5
6 const added = [...newSet].filter(x => !oldSet.has(x));
7 const removed = [...oldSet].filter(x => !newSet.has(x));
8
9 return { added, removed };
10}
11
12const oldList = [1, 2, 3];
13const newList = [2, 3, 4, 5];
14
15console.log(diffArrays(oldList, newList));
16// { added: [4,5], removed: [1] }
- यह तरीका आईडी सूची, टैग सूची और इसी तरह की स्थितियों में अंतर जानने के लिए बहुत सुविधाजनक है। प्रिमिटिव मानों के साथ इसका उपयोग सबसे सरल है।
‘WeakSet’ और ‘Set’ के बीच अंतर (मेमोरी प्रबंधन)
WeakSet, Set के समान है, लेकिन यह कमजोर संदर्भों का उपयोग करता है, जिससे इसकी वस्तुएं गारबेज कलेक्ट की जा सकती हैं। निम्नलिखित में ‘WeakSet’ के बुनियादी उपयोग दिखाए गए हैं।
1// WeakSet basics (objects only, not iterable)
2const ws = new WeakSet();
3let obj = { id: 1 };
4ws.add(obj);
5
6console.log(ws.has(obj)); // true
7
8obj = null; // Now the object is eligible for GC; WeakSet won't prevent collection
‘WeakSet’ केवल ऑब्जेक्ट्स को रख सकता है और इसमें इटरेशन नहीं किया जा सकता। ‘WeakSet’ की सीमाओं के उदाहरण नीचे दिए गए हैं—यह केवल ऑब्जेक्ट ही रख सकता है और इसमें इटरेशन संभव नहीं।
1// WeakSet basics (objects only, not iterable)
2const ws = new WeakSet();
3
4// --- Only objects can be added ---
5try {
6 ws.add(1); // number
7} catch (e) {
8 console.log("Error: WeakSet can only store objects. Adding a number is not allowed.");
9}
10
11try {
12 ws.add("text"); // string
13} catch (e) {
14 console.log("Error: WeakSet can only store objects. Adding a string is not allowed.");
15}
16
17// --- WeakSet is not iterable ---
18try {
19 for (const value of ws) {
20 console.log(value);
21 }
22} catch (e) {
23 console.log("Error: WeakSet is not iterable. You cannot use for...of to loop over its elements.");
24}
25
26// --- Cannot convert to array ---
27try {
28 console.log([...ws]);
29} catch (e) {
30 console.log("Error: WeakSet cannot be converted to an array because it does not support iteration.");
31}
32
33// The object becomes eligible for garbage collection
34let obj = { id: 1 };
35ws.add(obj);
36obj = null;- ‘WeakSet’ अस्थायी रूप से किसी ऑब्जेक्ट की उपस्थिति ट्रैक करने में उपयोगी है, लेकिन आप इसके तत्व गिन या एनूमरेट नहीं कर सकते।
प्रदर्शन व उपयोग का चुनाव
यह तय करते समय कि ‘सेट’ का उपयोग करना है या नहीं, उसके प्रदर्शन के गुण और आपके डाटा की प्रकृति को समझना महत्वपूर्ण है।
has,add, औरdeleteऔसतन लगभग O(1) प्रदर्शन पर कार्य करते हैं। जिन परिस्थितियों में आपको बार-बार अनुभूति (existance) जांच या डुप्लिकेट हटाने की आवश्यकता होती है, वहाँ ‘सेट’ ऐरे की तुलना में अधिक लाभदायक है।- यदि आप ऑब्जेक्ट्स को उनके कंटेंट (मान) के आधार पर डुप्लिकेट रहित बनाना चाहते हैं, तो सतर्क रहें। क्योंकि ‘सेट’ रेफरेंस के आधार पर तुलना करता है, इसलिए व्यावहारिक तरीका है कि आईडी या अन्य की का उपयोग करें, या सेट में डालने से पहले ऑब्जेक्ट का सीरियलाइजेशन कर दें अगर आपको मान-आधारित तुलना चाहिए।
- कोड की पठनीयता बढ़ाने के लिए, ‘सेट’ छोटे और मध्यम आकार के संग्रह में विशेष रूप से उपयोगी है। दूसरी ओर, यदि आप बहुत बड़ी संख्या में तत्वों को संभाल रहे हैं या बार-बार ऐरे और सेट में परिवर्तन कर रहे हैं, तो अनुशंसा है कि आप बेंचमार्क और टेस्ट अवश्य करें।
आम गलतियाँ
‘सेट’ सुविधाजनक है, लेकिन यदि आप इसकी विशेषताओं से अवगत नहीं हैं, तो आपको इसके अनपेक्षित बर्ताव से भ्रम हो सकता है। यहाँ कुछ सामान्य सावधानियां दी गई हैं:।
- ऑब्जेक्ट्स की तुलना रेफरेंस से होती है, इसलिए एक जैसा कंटेंट होने के बाद भी अलग-अलग ऑब्जेक्ट्स डुप्लिकेट नहीं माने जाते।
- ‘सेट’ डालने के क्रम को बनाए रखता है, लेकिन आप ऐरे की तरह तत्व तक इन्डेक्स से नहीं पहुँच सकते। यदि आप इन्डेक्स-आधारित पहुँच चाहते हैं, तो पहले ‘सेट’ को ऐरे में कन्वर्ट करें।
- ‘WeakSet’ एन्यूमरेट नहीं किया जा सकता और सिर्फ ऑब्जेक्ट्स ही स्टोर कर सकता है। ध्यान दें कि इसका प्रयोग सीमित है।
- ‘NaN’ को एक ही मान की तरह लिया जाता है और ‘+0’ तथा ‘-0’ में कोई अंतर नहीं किया जाता। यह सेम-वैल्यू-ज़ीरो तुलना नियम के कारण होता है।
सारांश
‘सेट’ एक सुविधाजनक डाटा संरचना है, जिससे आप अद्वितीय मानों के संग्रह को सहज रूप से संभाल सकते हैं। आप इसका उपयोग ऐरे से डुप्लिकेट हटाने, तेज़ अस्तित्व जांच, या यूनियन/इंटरसेक्शन जैसे सेट ऑपरेशन को सरल और पठनीय कोड के साथ करने के लिए कर सकते हैं।
दूसरी ओर, चूँकि ऑब्जेक्ट्स की तुलना रेफरेंस से होती है, अगर आप कंटेंट के आधार पर समानता देखना चाहते हैं तो अतिरिक्त कदम उठाने होंगे।
इन विशेषताओं को समझकर और उचित रूप से उपयोग करके, ‘सेट’ कोड की पठनीयता और रखरखाव को बेहतर बनाने के लिए एक शक्तिशाली विकल्प बन जाता है।
आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।