सेट डेटा प्रकार का उपयोग करके जावास्क्रिप्ट को गति देना

सामग्री का लेखक, जिसका अनुवाद आज हम प्रकाशित करते हैं, का कहना है कि वह आश्वस्त है कि कई जावास्क्रिप्ट डेवलपर्स मुख्य रूप से डेटा प्रकारों जैसे Number , String , Object , Array और Boolean । ज्यादातर मामलों में, यह पर्याप्त है। लेकिन अगर आपको कोड को यथासंभव तेज और स्केलेबल बनाने की आवश्यकता है, तो इन डेटा प्रकारों का उपयोग हमेशा उचित नहीं है।



इस लेख में, हम Set डेटा प्रकार का उपयोग करने के तरीके के बारे में बात करेंगे, जो अद्वितीय मूल्यों के संग्रह के साथ काम करने की क्षमता प्रदान करता है, कोड को तेज बनाता है। यह बड़े पैमाने पर परियोजनाओं के कोड के लिए विशेष रूप से सच है। Array और Set प्रकार में बहुत कुछ है, लेकिन Set डेटा प्रकार का उपयोग करने से प्रोग्रामर को ऐसी विशेषताएं मिल सकती हैं जो स्पष्ट रूप से उन कार्यक्रमों के निष्पादन के दौरान प्रकट होती हैं जो Array प्रकार के पास नहीं हैं।

एरे और सेट डेटा प्रकारों में क्या अंतर है?

Array डेटा प्रकार की मुख्य विशेषता (हम इस प्रकार की वस्तुओं को "सरणियाँ" कहेंगे) यह है कि सरणियों को मानों के अनुक्रमित संग्रह हैं। इसका मतलब है कि सरणियों में डेटा इंडेक्स का उपयोग करके संग्रहीत किया जाता है।

 const arr = [A, B, C, D]; console.log(arr.indexOf(A)); // : 0 console.log(arr.indexOf(C)); // : 2 

सरणियों के विपरीत, Set प्रकार की वस्तुएं (हम उन्हें "संग्रह" कहेंगे) कुंजी / मान प्रारूप में डेटा युक्त संग्रह हैं। इंडेक्स का उपयोग करने के बजाय, कुंजियों का उपयोग करके आइटम संग्रह करते हैं। संग्रह में संग्रहीत तत्वों को उस क्रम में क्रमबद्ध किया जा सकता है, जो उन्हें संग्रह में जोड़ा गया था, जबकि संग्रह में समान तत्व संग्रहीत नहीं किए जा सकते हैं। दूसरे शब्दों में, संग्रह के सभी तत्व अद्वितीय होने चाहिए।

संग्रह की मुख्य ताकत क्या हैं?

यदि आप संग्रह और सरणियों की तुलना करते हैं, तो आप सरणियों पर संग्रह पर कुछ लाभ पा सकते हैं, विशेष रूप से उन स्थितियों पर ध्यान देने योग्य है जिनमें कार्यक्रम प्रभावी हैं:

• आइटम के लिए खोजें। सरणी विधियाँ indexOf() और includes() , तत्वों की खोज करने के लिए और यह जांचने के लिए उपयोग किया जाता है कि क्या कोई तत्व तत्व है, धीरे से काम करें।
• वस्तुओं को निकालना। किसी वस्तु को उसके मूल्य के आधार पर संग्रह में हटाया जा सकता है। एक सरणी में, इस तरह की कार्रवाई के बराबर तत्व के सूचकांक के आधार पर splice() विधि का उपयोग करना होगा। आइटम खोज के साथ, अनुक्रमणिका का उपयोग करके आइटम निकालना एक धीमा ऑपरेशन है।
• एक आइटम डालें। एक सरणी में push() और unshift() जैसे तरीकों का उपयोग करके संग्रह में एक तत्व जोड़ना बहुत तेज़ है।
• NaN मान के साथ कार्य करें। indexOf() विधि का उपयोग किसी सरणी में NaN मान को खोजने के लिए नहीं किया जा सकता है, जबकि has() संग्रह विधि का उपयोग करते हुए, आप यह निर्धारित कर सकते हैं कि इसमें NaN है या नहीं।
• डुप्लिकेट आइटम निकाल रहा है। Set ऑब्जेक्ट केवल अनन्य मान संग्रहीत करते हैं। यदि आपको कुछ डेटा संरचना में डुप्लिकेट तत्वों को सहेजने से बचने की आवश्यकता है, तो यह सरणियों पर उनका महत्वपूर्ण लाभ है। डुप्लिकेट तत्वों को हटाने के लिए सरणियों के साथ काम करते समय अतिरिक्त कोड लिखना होगा।

टाइप Set की वस्तुओं की अंतर्निहित विधियों की एक पूरी सूची यहां पाई जा सकती है ।

एल्गोरिदम की समय जटिलता पर

तत्वों के लिए खोज करने के लिए सरणियों का उपयोग करने वाले तरीकों में रैखिक समय जटिलता है - ओ (एन)। दूसरे शब्दों में, तत्व खोज समय सरणी के आकार के लिए आनुपातिक है।

सरणियों के विपरीत, तत्वों को खोजने, हटाने और जोड़ने के लिए संग्रह द्वारा उपयोग की गई विधियों में O (1) समय जटिलता है। इसका मतलब है कि संग्रह के आकार का इस तरह के तरीकों के काम के समय पर कोई प्रभाव नहीं है।

यहां आप एल्गोरिदम के समय की जटिलता के बारे में अधिक पढ़ सकते हैं।

सरणियों की तुलना में संग्रह कितनी तेजी से हैं?

यद्यपि जावास्क्रिप्ट कोड के प्रदर्शन संकेतक विभिन्न कारकों से दृढ़ता से प्रभावित होते हैं, विशेष रूप से, वे उस प्रणाली पर निर्भर करते हैं जिस पर कोड चलाया जाता है, उपयोग किए गए कोड रनटाइम पर, संसाधित डेटा के आकार पर, मुझे आशा है कि मेरे परीक्षणों के परिणाम आपको सरणियों और संग्रह की तुलना करने का अवसर देंगे। व्यावहारिक दृष्टिकोण से, और समझें कि संग्रह सरणियों से अधिक तेज़ कैसे हैं। अब हम तीन सरल परीक्षणों पर विचार करेंगे और उनके परिणामों का विश्लेषण करेंगे।

Preparation सबसे अच्छी तैयारी

कोई भी परीक्षण करने से पहले, आइए एक लाख तत्वों और एक ही संग्रह के साथ एक सरणी बनाएं। सादगी के लिए, हम एक चक्र का उपयोग करेंगे, जिसका पहला काउंटर मूल्य 0 होगा, और अंतिम - 999999:

 let arr = [], set = new Set(), n = 1000000; for (let i = 0; i < n; i++) { arr.push(i); set.add(i); } 

▍Test नंबर 1: एक सरणी में और एक संग्रह में एक तत्व की उपस्थिति के लिए जाँच

सबसे पहले, हम सरणी में और संग्रह में तत्व 123123 की उपस्थिति की जांच करेंगे, अग्रिम में जानते हुए कि इन डेटा संरचनाओं में ऐसा तत्व मौजूद है।

 let result; console.time('Array'); result = arr.indexOf(123123) !== -1; console.timeEnd('Array'); console.time('Set'); result = set.has(123123); console.timeEnd('Set'); 

इस परीक्षण के परिणाम इस प्रकार हैं:

 Array: 0.173ms Set: 0.023ms 

संग्रह सरणी की तुलना में 7.54 गुना तेज है।

▍Test नंबर 2: एक तत्व का सम्मिलन

अब आइए सरणियों और संग्रह में तत्वों को जोड़ने का प्रयास करें।

 console.time('Array'); arr.push(n); console.timeEnd('Array'); console.time('Set'); set.add(n); console.timeEnd('Set'); 

यहाँ क्या हुआ:

 Array: 0.018ms Set: 0.003ms 

संग्रह सरणी से 6.73 गुना तेज है।

EstTest 3: किसी आइटम को हटाएं

अब आइए प्रत्येक डेटा संरचना से आइटम को हटा दें (उदाहरण के लिए, जो पिछले परीक्षण में जोड़ा गया था)। तत्वों को हटाने के लिए एरो के पास बिल्ट-इन विधि नहीं है, इसलिए हम अपने कोड को अच्छा रखने के लिए एक सहायक फ़ंक्शन बनाएंगे:

 const deleteFromArr = (arr, item) => { let index = arr.indexOf(item); return index !== -1 && arr.splice(index, 1); }; 

और यहाँ परीक्षण कोड है:

 console.time('Array'); deleteFromArr(arr, n); console.timeEnd('Array'); console.time('Set'); set.delete(n); console.timeEnd('Set'); 

परिणाम निम्नलिखित है:

 Array: 1.122ms Set: 0.015ms 

इस मामले में, संग्रह सरणी की तुलना में 74.13 गुना तेज था!

सामान्य तौर पर, यह ध्यान दिया जा सकता है कि कोड प्रदर्शन को सरणियों के बजाय संग्रह का उपयोग करके काफी बढ़ाया जा सकता है। कुछ व्यावहारिक उदाहरणों पर विचार करें।

उदाहरण # 1: किसी सरणी से डुप्लिकेट मानों को निकालना

यदि आपको किसी सरणी से डुप्लिकेट मान को जल्दी से हटाने की आवश्यकता है, तो आप इसे संग्रह में बदल सकते हैं। डुप्लिकेट मानों से छुटकारा पाने का यह सबसे आसान तरीका है:

 const duplicateCollection = ['A', 'B', 'B', 'C', 'D', 'B', 'C']; //       let uniqueCollection = new Set(duplicateCollection); console.log(uniqueCollection) // : Set(4) {"A", "B", "C", "D"} //        let uniqueCollection = [...new Set(duplicateCollection)]; console.log(uniqueCollection) // : ["A", "B", "C", "D"] 

उदाहरण 2: Google में साक्षात्कार कार्य

मेरी एक सामग्री में, मैंने Google के एक साक्षात्कारकर्ता द्वारा पूछे गए प्रश्न का उत्तर देने के लिए चार विकल्पों की जांच की। साक्षात्कार C ++ का उपयोग करके आयोजित किया गया था, लेकिन यदि इस भाषा के बजाय जावास्क्रिप्ट का उपयोग किया गया था, तो Set डेटा संरचना का उपयोग समस्या को हल करने में आवश्यक रूप से किया जाएगा।

यदि आप इस प्रश्न के उत्तर को अधिक गहराई से समझना चाहते हैं - उपरोक्त लेख पढ़ें। यहां मैं सिर्फ एक तैयार समाधान दिखाता हूं।

▍ टास्क

पूर्णांक के एक असंबंधित सरणी और एक sum मान को देखते हुए। एक फ़ंक्शन लिखें जो इस सरणी के किसी भी दो तत्वों को जोड़ने के परिणामस्वरूप, अगर यह true है, तो हमें कुल मूल्य मिलता है। यदि सरणी में ऐसे तत्व नहीं हैं, तो फ़ंक्शन को false वापस लौटना चाहिए।

यह पता चला है, उदाहरण के लिए, कि अगर हमें एक सरणी दी जाती है [3, 5, 1, 4] और sum मान 9 , तो फ़ंक्शन को वापस लौटना चाहिए, क्योंकि 4+5=9 ।

▍Reshenie

आप निम्नलिखित विचार का उपयोग करके इस समस्या को प्राप्त कर सकते हैं: आपको सरणी पर पुनरावृति करने की आवश्यकता है, Set डेटा संरचना का निर्माण करें क्योंकि यह इसके माध्यम से जाता है, जिसमें उन मानों को जोड़ा जाएगा जो कि मूल्य मान के लिए पाए गए मानों के पूरक हैं।

आइए उपरोक्त सरणी के उदाहरण का उपयोग करके इस विचार का विश्लेषण करें। जब हम 3 मिलते हैं, तो हम संग्रह में संख्या 6 जोड़ सकते हैं, क्योंकि हम जानते हैं कि हमें दो संख्याओं को खोजने की आवश्यकता है जो कुल 9 । फिर, हर बार जब हम सरणी से एक नए मूल्य पर आते हैं, तो हम संग्रह की जांच कर सकते हैं और देख सकते हैं कि क्या यह वहां है। जब हम संख्या 5 मिलते हैं, तो हम संग्रह में 4 जोड़ देंगे। और जब, अंत में, हम नंबर 4 , हम इसे संग्रह में ढूंढते हैं और true लौटा सकते हैं।

इस समस्या का हल क्या हो सकता है:

 const findSum = (arr, val) => { let searchValues = new Set(); searchValues.add(val - arr[0]); for (let i = 1, length = arr.length; i < length; i++) {   let searchVal = val - arr[i];   if (searchValues.has(arr[i])) {     return true;   } else {     searchValues.add(searchVal);   } }; return false; }; 

और यहाँ एक और अधिक संक्षिप्त समाधान है:

 const findSum = (arr, sum) => arr.some((set => n => set.has(n) || !set.add(sum - n))(new Set)); 

Set.prototype.has() पद्धति की समय जटिलता O (1) के बाद से, Set डेटा संरचना का उपयोग करके उन संख्याओं को संग्रहीत करने के लिए किया जाता है जो किसी दिए गए मान में सरणी में पाई गई संख्याओं को पूरक करते हैं, जिससे आप रैखिक समय (O (N)) में एक समाधान खोज सकते हैं।

यदि समाधान Array.prototype.indexOf() विधि या Array.prototype.indexOf() विधि पर निर्भर करता है, जिसमें से प्रत्येक की समय जटिलता O (N) है, तो एल्गोरिथम की कुल जटिलता O (N ² ) होगी। नतीजतन, वह बहुत धीमा हो जाएगा।

परिणाम

यदि आपने पहले जावास्क्रिप्ट में Set डेटा प्रकार का सामना नहीं किया है, तो हमें उम्मीद है कि अब, इसका एक विचार होने पर, आप अपनी परियोजनाओं में लाभ के साथ इसका उपयोग करने में सक्षम होंगे।

प्रिय पाठकों! आप अपने कोड में Set डेटा संरचना कैसे लागू करेंगे?