अंत में! जब सेट को अतीत में पेश किया गया था तो इसने पहले से ही हमारे जीवन को बेहतर बना दिया था। हम आसानी से अद्वितीय सूचियाँ तैयार करने में सक्षम थे, लेकिन उन सूचियों पर आइटम ढूंढने और सेट करने में भी हमारा प्रदर्शन बेहतर रहा।

यह बहुत अच्छा था, लेकिन हम अभी भी कई चीजें खो रहे थे जो अन्य भाषाओं में थीं। और यह सच है, क्योंकि हम थे। 2024 में सेट में जोड़े गए नए कंपोजिशन तरीकों के साथ, हम अंततः सरल कॉल के साथ यूनियन, इंटरसेक्शन, अंतर और बहुत कुछ करने में सक्षम होंगे।

बिना किसी देरी के, चलिए इस पर आगे बढ़ते हैं।

अंतर

एक नया सेट लौटाता है जिसमें ऐसे तत्व होते हैं जो पहले सेट में मौजूद हैं लेकिन दूसरे में नहीं।

उदाहरण: आप यह देखना चाहते हैं कि इस सप्ताह कौन से उपयोगकर्ता साइट पर गए जो पिछले महीने नहीं आए।

इसका उपयोग कैसे करना है?

const thisWeekUsers = new Set([1, 2, 3, 4]);
const lastMonthUsers = new Set([3, 4, 5, 6]);

const newUsers = thisWeekUsers.difference(lastMonthUsers);

console.log(newUsers); // Set(2) { 1, 2 }

अतीत में हम ऐसा कैसे करते थे?

const thisWeekUsers = [1, 2, 3, 4];
const lastMonthUsers = [3, 4, 5, 6];

let newUsers = thisWeekUsers.filter(x => !lastMonthUsers.includes(x));

console.log(newUsers); // (2) [1,2]

यहां और जानें: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/difference

चौराहा

केवल उन मानों के साथ एक नया सेट लौटाता है जो दोनों सेट में मौजूद हैं।

उदाहरण: आप कार्ट में एक ई-पुस्तक बंडल जोड़ रहे हैं, लेकिन आपके पास उनमें से कुछ किताबें पहले से ही मौजूद थीं।

इसका उपयोग कैसे करना है?

const booksBundle = new Set([1, 2, 3, 4]);
const cart = new Set([3, 4, 5, 6]);

const booksToAdd = booksBundle.intersection(cart);

console.log(booksToAdd); // Set(2) { 3, 4 }

अतीत में हम ऐसा कैसे करते थे?

const booksBundle = [1, 2, 3, 4];
const cart = [3, 4, 5, 6];

const booksToAdd = booksBundle.filter(book => cart.includes(book));

console.log(booksToAdd); // (2) [3, 4]

यहां और जानें: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/intersection

सममित अंतर

उन मानों के साथ एक नया सेट लौटाता है जो किसी भी समूह में दोहराया नहीं जाता है।

उदाहरण: दुकानों के बीच अधिक स्टॉक वाली वस्तुओं की जांच करके यह जांचना कि किन वस्तुओं का आदान-प्रदान किया जा सकता है।

इसका उपयोग कैसे करना है?

const firstStore = new Set([1, 2, 3, 4]);
const secondStore = new Set([3, 4, 5, 6]);

const overstockedItems = firstStore.symmetricDifference(secondStore);

console.log(overstockedItems); // Set(4) { 1, 2, 5, 6 }

अतीत में हम ऐसा कैसे करते थे?

const firstStore = [1, 2, 3, 4];
const secondStore = [3, 4, 5, 6];

const allItems = [firstStore, secondStore].flat();
const overstockedItems = allItems.filter(item => {
  return !firstStore.includes(item) || !secondStore.includes(item);
});

console.log(overstockedItems); // (4) [1, 2, 5, 6]

यहां और जानें: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/symmetricDifference

मिलन

दोनों समूहों के मूल्यों के साथ एक नया सेट लौटाता है, लेकिन कोई भी मूल्य दोहराए बिना।

उदाहरण: आप और आपका मित्र प्लेलिस्ट को मर्ज करना चाहते हैं, लेकिन कुछ संगीत समान हैं।

इसका उपयोग कैसे करना है?

const yourPlaylist = new Set([1, 2, 3, 4]);
const friendPlaylist = new Set([3, 4, 5, 6]);

const mergedPlaylist = yourPlaylist.union(friendPlaylist);

console.log(mergedPlaylist); // Set(6) { 1, 2, 3, 4, 5, 6 }

अतीत में हम ऐसा कैसे करते थे?

const yourPlaylist = [1, 2, 3, 4];
const friendPlaylist = [3, 4, 5, 6];

const mergedPlaylist = new Set([yourPlaylist, friendPlaylist].flat());

console.log(mergedPlaylist); // (6) [1, 2, 3, 4, 5, 6]

यहां और जानें: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/union

से विच्छेद है?

यह एक बूलियन लौटाता है। यह सत्य है यदि दोनों सेटों में कोई मान समान नहीं है, और गलत है यदि उनमें कम से कम एक मान समान है।

उदाहरण: देखें ऐसे उत्पाद हैं जो अन्य समूहों का हिस्सा हैं।

इसका उपयोग कैसे करना है?

const electronics = new Set([1, 2, 3, 4]);
const furniture = new Set([3, 4, 5, 6]);
const groceries = new Set(['apple']);

console.log(electronics.isDisjointFrom(furniture)); // false
console.log(electronics.isDisjointFrom(groceries)); // true

अतीत में हम ऐसा कैसे करते थे?

const electronics = [1, 2, 3, 4];
const furniture = [3, 4, 5, 6];
const groceries = ['apple'];

function isDisjoint(array1, array2) {
  return array1.every(item => !array2.includes(item));
}

console.log(isDisjoint(electronics, furniture)); // false
console.log(isDisjoint(electronics, groceries)); // true

यहां और जानें: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/isDisjointFrom

सुपरसेट/सबसेट का है?

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

मैं उन कार्यों को एक साथ रख रहा हूं क्योंकि उनमें से एक का उत्तर जानना दूसरे को जानने के लिए पर्याप्त है। एक सेट केवल एक सबसेट सेट का सुपरसेट हो सकता है।

उदाहरण: समझें कि क्या उपयोगकर्ता किसी कंपनी समूह का हिस्सा हैं।

इसका उपयोग कैसे करना है?

const itDepartment = new Set([1, 2, 3, 4]);
const genZFromToronto = new Set([3, 4]);

console.log(itDepartment.isSupersetOf(genZFromToronto)); // true
console.log(genZFromToronto.isSubsetOf(itDepartment)); // true

अतीत में हम ऐसा कैसे करते थे?

const itDepartment = [1, 2, 3, 4];
const genZFromToronto = [3, 4];

console.log(genZFromToronto.every(item => itDepartment.includes(item))); // true

यहां और जानें:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/isSupersetOf
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/isSubsetOf

अब आप पूरी तरह तैयार हैं मुझे खेद नहीं है इसे अपने प्रोजेक्ट में उपयोग करने के लिए!

अगर आप भी इसके, किसी अन्य फीचर को लेकर उत्साहित हैं, या कुछ और कवर होते देखना चाहते हैं तो मुझे बताएं। अगली बार तक o/