जावास्क्रिप्ट सेट बनाम एरे प्रदर्शन

Question 1

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

Question 2

ठीक है, मैंने एक सरणी और एक सेट से तत्वों को जोड़ने, पुनरावृत्ति और हटाने का परीक्षण किया है। मैंने "छोटा" परीक्षण चलाया, जिसमें 10 000 तत्वों का उपयोग किया गया और 100 000 तत्वों का उपयोग करके "बड़ा" परीक्षण किया गया। यहाँ परिणाम हैं।

तत्वों को एक संग्रह में जोड़ना

ऐसा लगता है कि सेट विधि की .pushतुलना में सरणी विधि लगभग 4 गुना तेज है .add, कोई फर्क नहीं पड़ता कि तत्वों की संख्या जोड़ी जा रही है।

संग्रह में तत्वों को बदलना और संशोधित करना

परीक्षण के इस भाग के लिए मैंने forसरणी पर पुनरावृति करने के लिए एक लूप का उपयोग किया और for ofसेट पर पुनरावृति करने के लिए एक लूप। फिर, सरणी पर पुनरावृति तेज थी। इस बार ऐसा लगेगा कि यह तेजी से बढ़ रहा है, इसलिए इसे "छोटे" परीक्षणों के दौरान दो बार और "बड़े" परीक्षणों के दौरान लगभग चार गुना लंबा समय लगा।

एक संग्रह से तत्वों को निकालना

अब यह वह जगह है जहां यह दिलचस्प हो जाता है। मैंने एक forलूप के संयोजन का उपयोग किया और .spliceकुछ तत्वों को सरणी से हटाने के लिए और मैंने उपयोग किया for ofऔर .deleteकुछ तत्वों को सेट से हटा दिया। "छोटे" परीक्षणों के लिए, सेट से वस्तुओं को हटाने के लिए लगभग तीन गुना तेज था (2.6 एमएस बनाम 7.1 एमएस) लेकिन चीजें "बड़े" परीक्षण के लिए काफी बदल गईं जहां केवल सरणी से आइटम हटाने के लिए 1955.1 एमएस लिया। 83.6 एमएस लिया, उन्हें 23 बार तेजी से सेट से हटाने के लिए।

निष्कर्ष

10k तत्वों पर, दोनों परीक्षण तुलनात्मक समय (सरणी: 16.6 एमएस, सेट: 20.7 एमएस) पर चले गए लेकिन 100k तत्वों के साथ काम करते समय, सेट स्पष्ट विजेता था (सरणी: 1974.8 एमएस, सेट: 83.6 एमएस) लेकिन केवल हटाने के कारण ऑपरेशन। अन्यथा सरणी तेज थी। मैं बिल्कुल नहीं कह सकता कि ऐसा क्यों है।

मैंने कुछ हाइब्रिड परिदृश्यों के साथ खेला, जहाँ एक सरणी बनाई गई थी और आबादी थी और फिर एक सेट में परिवर्तित हो गई जहाँ कुछ तत्वों को हटा दिया जाएगा, फिर सेट को एक सरणी में फिर से जोड़ा जाएगा। हालांकि ऐसा करने से सरणी में तत्वों को हटाने की तुलना में बहुत बेहतर प्रदर्शन मिलेगा, एक सेट के बजाय एक सरणी को पॉप्युलेट करने के लाभों को सेट आउट से स्थानांतरित करने के लिए आवश्यक अतिरिक्त प्रसंस्करण समय। अंत में, यह केवल एक सेट के साथ सौदा करने के लिए तेज़ है। फिर भी, यह एक दिलचस्प विचार है, कि अगर कोई किसी बड़े डेटा के लिए डेटा संग्रह के रूप में एक सरणी का उपयोग करने के लिए चुनता है जिसमें डुप्लिकेट नहीं है, तो यह लाभप्रद प्रदर्शन बुद्धिमान हो सकता है, अगर कभी एक में कई तत्वों को निकालने की आवश्यकता होती है ऑपरेशन, सरणी को सेट में बदलने के लिए, निष्कासन ऑपरेशन करें, और सेट को वापस सरणी में परिवर्तित करें।

सरणी कोड:

var timer = function(name) {
  var start = new Date();
  return {
    stop: function() {
      var end = new Date();
      var time = end.getTime() - start.getTime();
      console.log('Timer:', name, 'finished in', time, 'ms');
    }
  }
};

var getRandom = function(min, max) {
  return Math.random() * (max - min) + min;
};

var lastNames = ['SMITH', 'JOHNSON', 'WILLIAMS', 'JONES', 'BROWN', 'DAVIS', 'MILLER', 'WILSON', 'MOORE', 'TAYLOR', 'ANDERSON', 'THOMAS'];

var genLastName = function() {
  var index = Math.round(getRandom(0, lastNames.length - 1));
  return lastNames[index];
};

var sex = ["Male", "Female"];

var genSex = function() {
  var index = Math.round(getRandom(0, sex.length - 1));
  return sex[index];
};

var Person = function() {
  this.name = genLastName();
  this.age = Math.round(getRandom(0, 100))
  this.sex = "Male"
};

var genPersons = function() {
  for (var i = 0; i < 100000; i++)
    personArray.push(new Person());
};

var changeSex = function() {
  for (var i = 0; i < personArray.length; i++) {
    personArray[i].sex = genSex();
  }
};

var deleteMale = function() {
  for (var i = 0; i < personArray.length; i++) {
    if (personArray[i].sex === "Male") {
      personArray.splice(i, 1)
      i--
    }
  }
};

var t = timer("Array");

var personArray = [];

genPersons();

changeSex();

deleteMale();

t.stop();

console.log("Done! There are " + personArray.length + " persons.")

स्निपेट का विस्तार करें

कोड सेट करें:

var timer = function(name) {
    var start = new Date();
    return {
        stop: function() {
            var end  = new Date();
            var time = end.getTime() - start.getTime();
            console.log('Timer:', name, 'finished in', time, 'ms');
        }
    }
};

var getRandom = function (min, max) {
  return Math.random() * (max - min) + min;
};

var lastNames = ['SMITH','JOHNSON','WILLIAMS','JONES','BROWN','DAVIS','MILLER','WILSON','MOORE','TAYLOR','ANDERSON','THOMAS'];

var genLastName = function() {
    var index = Math.round(getRandom(0, lastNames.length - 1));
    return lastNames[index];
};

var sex = ["Male", "Female"];

var genSex = function() {
    var index = Math.round(getRandom(0, sex.length - 1));
    return sex[index];
};

var Person = function() {
	this.name = genLastName();
	this.age = Math.round(getRandom(0,100))
	this.sex = "Male"
};

var genPersons = function() {
for (var i = 0; i < 100000; i++)
	personSet.add(new Person());
};

var changeSex = function() {
	for (var key of personSet) {
		key.sex = genSex();
	}
};

var deleteMale = function() {
	for (var key of personSet) {
		if (key.sex === "Male") {
			personSet.delete(key)
		}
	}
};

var t = timer("Set");

var personSet = new Set();

genPersons();

changeSex();

deleteMale();

t.stop();

console.log("Done! There are " + personSet.size + " persons.")

स्निपेट का विस्तार करें

Question 3

OBSERVATIONS :

निष्पादन की धारा के भीतर सेट संचालन को स्नैपशॉट के रूप में समझा जा सकता है।

हम एक निश्चित विकल्प से पहले नहीं हैं।

सेट क्लास के तत्वों में कोई सुगम सूचकांक नहीं होता है।

सेट क्लास एक ऐरे क्लास पूरक है, उन परिदृश्यों में उपयोगी है जहां हमें एक संग्रह को संग्रहीत करने की आवश्यकता होती है, जिस पर बुनियादी जोड़, विलोपन, जाँच और पुनरावृत्ति संचालन लागू होते हैं।

मैं प्रदर्शन के कुछ परीक्षण साझा करता हूं। अपना कंसोल खोलने की कोशिश करें और नीचे दिए गए कोड को कॉपी करें।

एक सरणी बनाना (125000)

var n = 125000;
var arr = Array.apply( null, Array( n ) ).map( ( x, i ) => i );
console.info( arr.length ); // 125000

1. एक सूचकांक का पता लगाना

हमने ऐरे इंडेक्सऑफ के साथ सेट की विधि की तुलना की है:

Array / indexOf (0.281ms) | सेट / है (0.053ms)

// Helpers
var checkArr = ( arr, item ) => arr.indexOf( item ) !== -1;
var checkSet = ( set, item ) => set.has( item );

// Vars
var set, result;

console.time( 'timeTest' );
result = checkArr( arr, 123123 );
console.timeEnd( 'timeTest' );

set = new Set( arr );

console.time( 'timeTest' );
checkSet( set, 123123 );
console.timeEnd( 'timeTest' );

2. एक नया तत्व जोड़ना

हम क्रमशः सेट और ऐरे ऑब्जेक्ट्स के ऐड और पुश तरीकों की तुलना करते हैं:

ऐरे / पुश (1.612ms) | सेट / जोड़ें (0.006ms)

console.time( 'timeTest' );
arr.push( n + 1 );
console.timeEnd( 'timeTest' );

set = new Set( arr );

console.time( 'timeTest' );
set.add( n + 1 );
console.timeEnd( 'timeTest' );

console.info( arr.length ); // 125001
console.info( set.size ); // 125001

3. किसी तत्व को हटाना

तत्वों को हटाते समय, हमें यह ध्यान रखना होगा कि एरियर और सेट समान परिस्थितियों में शुरू न हों। ऐरे में मूल विधि नहीं है, इसलिए एक बाहरी कार्य आवश्यक है।

Array / deleteFromArr (0.356ms) | सेट / निकालें (0.019ms)

var deleteFromArr = ( arr, item ) => {
    var i = arr.indexOf( item );
    i !== -1 && arr.splice( i, 1 );
};

console.time( 'timeTest' );
deleteFromArr( arr, 123123 );
console.timeEnd( 'timeTest' );

set = new Set( arr );

console.time( 'timeTest' );
set.delete( 123123 );
console.timeEnd( 'timeTest' );

पूरा लेख यहाँ पढ़ें

Question 4

मेरा अवलोकन यह है कि एक सेट हमेशा दो सरणियों के साथ बेहतर होता है, जो बड़े सरणियों को ध्यान में रखते हैं:

क) forअरैज़ से सेट का निर्माण लूप में एक पूर्व निर्धारित लंबाई के साथ किया जाना चाहिए ।

धीमी गति से (जैसे 18ms) new Set(largeArray)

तेज (जैसे 6ms) const SET = new Set(); const L = largeArray.length; for(var i = 0; i<L; i++) { SET.add(largeArray[i]) }

बी) Iterating उसी तरह से किया जा सकता है क्योंकि यह for ofलूप से भी तेज है ...

देख Https://jsfiddle.net/0j2gkae7/5/

करने के लिए एक वास्तविक जीवन की तुलना के लिए difference(), intersection(), union()और uniq()40.000 तत्वों के साथ (+ उनके iteratee साथियों आदि)

Question 5

आपके प्रश्न के पुनरावृत्ति भाग के लिए, मैंने हाल ही में इस परीक्षण को चलाया और पाया कि सेट ने 10,000 वस्तुओं के एक एरियर को बेहतर बना दिया (लगभग 10x ऑपरेशन एक ही समय सीमा में हो सकते हैं)। और ब्राउजर के आधार पर या तो टेस्ट के लिए एक तरह से Object.hasOwnProperty को हराया या हार गया।

सेट और ऑब्जेक्ट दोनों के पास ओ (1) के लिए परिशोधित होने के लिए उनका "" विधि प्रदर्शन है, लेकिन ब्राउज़र के कार्यान्वयन के आधार पर एकल ऑपरेशन में अधिक या अधिक समय लग सकता है। ऐसा लगता है कि अधिकांश ब्राउज़र सेट.हास () की तुलना में तेजी से ऑब्जेक्ट को लागू करते हैं। यहां तक कि Object.hasOwnProperty जिसमें कुंजी पर एक अतिरिक्त चेक शामिल है, Set.has () से कम से कम क्रोम v86 पर मेरे लिए लगभग 5% तेज है।

https://jsperf.com/set-has-vs-object-hasownproperty-vs-array-includes/1

अपडेट: 11/11/2020: https://jsbench.me/irkhdxnoqa/2

यदि आप विभिन्न ब्राउज़रों / वातावरणों के साथ अपना परीक्षण चलाना चाहते हैं।

इसी तरह मैं एक सरणी बनाम सेट में आइटम जोड़ने और हटाने के लिए एक बेंचमार्क जोड़ूंगा।

Question 6

console.time("set")
var s = new Set()
for(var i = 0; i < 10000; i++)
  s.add(Math.random())
s.forEach(function(e){
  s.delete(e)
})
console.timeEnd("set")
console.time("array")
var s = new Array()
for(var i = 0; i < 10000; i++)
  s.push(Math.random())
s.forEach(function(e,i){
  s.splice(i)
})
console.timeEnd("array")

10K आइटम पर उन तीन आपरेशनों ने मुझे दिया:

set: 7.787ms
array: 2.388ms