node.js में मेरे आवेदन के लिए मुझे कुछ संख्यात्मक मान (यानी एक संख्यात्मक रैंक) के आधार पर अवरोही क्रम में किसी सरणी के तत्वों को सॉर्ट करना होगा। चूंकि मेरा एप्लिकेशन प्रदर्शन-महत्वपूर्ण है, इसलिए मैंने अपनी डेटा संरचना बनाने का निर्णय लिया ताकि सॉर्टिंग अनुकूलित हो। मैंने अनुमान लगाया कि मेरे सरणी में प्रति तत्व निहित कम डेटा, तेज़ प्रकार होगा।संख्याओं के सरणी क्यों, ऑब्जेक्ट्स के सरणी से अधिक डेटा सॉर्ट करें, जावास्क्रिप्ट में कम डेटा?
संपादित: दोस्तों, ऐसा लगता है जैसे कि वहाँ कुछ अपने मूल परीक्षण के साथ त्रुटिपूर्ण था मेरी परिकल्पना का परीक्षण करने के लिए, मैं लंबाई 10000 के तीन विभिन्न सरणियों पर निम्नलिखित भाग गया। पहला परीक्षण उन लोगों की तुलना में काफी अधिक समय लेता है जो अनुसरण करते हैं। इस प्रकार, मैंने अपने परीक्षण कोड को वास्तविक प्रकार से पहले 'बफर' सॉर्ट करने के लिए संशोधित किया है। इसके अलावा, मैंने परीक्षणों के क्रम से होने वाली किसी भी पूर्वाग्रह को कम करने के लिए परीक्षणों की एक निश्चित संख्या के लिए अपने परीक्षणों के आदेश को घुमाया। मैंने तदनुसार परिणामों को संशोधित किया है।
यहाँ पूर्ण स्रोत: https://raw.githubusercontent.com/youngrrrr/js-array-sort-bench-test/master/arraySortTest.js
var buffer = [781197, ... ];
var sparseArray = [781197, ... ];
var sparseArray2 = [{'a' : 781197}, ...];
var denseArray = [{'a' : 781197, 'b': ['r', 'a', 'n', 'd', 'o', 'm'] }, ...];
/* buffer : for some reason, the first test always takes significantly longer than the others. I've added this to try to remove whatever bias there was before... */
console.time('buffer');
random.sort(compareSparse);
console.timeEnd('buffer');
console.log(buffer[0]); // prints "58"
/* sparseArray : an array whose elements are numbers */
console.time('sparse');
sparseArray.sort(compareSparse);
console.timeEnd('sparse');
console.log(sparseArray[0]); // prints "58"
/* sparseArray2 (not an accurate name, just got lazy) :
an array whose elements are objects with a single key-value pair mapping
an arbitrary name 'a' to a number (which we sort on) */
console.time('sparse2');
sparseArray2.sort(compareDense);
console.timeEnd('sparse2');
console.log(sparseArray2[0]); // prints "{ a: 58 }"
/* denseArray : an array whose elements are objects with two key-value
pairs mapping an arbitrary key 'a' to a number (which we sort on) and
another arbitrary key 'b' to an array (which is just supposed to be
extra data for the purpose of my hypothesis) */
console.time('dense');
denseArray.sort(compareDense);
console.timeEnd('dense');
console.log(denseArray[0]); // prints "{ a: 58, b: [ 'r', 'a', 'n', 'd', 'o', 'm' ] }"
function compareSparse(a, b) {
if (a < b) {
return -1;
} else if (a > b) {
return 1; }
else {
return 0;
}
}
function compareDense(a, b) {
if (a.a < b.a) {
return -1;
} else if (a.a > b.a) {
return 1; }
else {
return 0;
}
}
}
पुरानी परीक्षण:
25 के बाद परीक्षणों मैं (मुझे पता है, छोटा सा नमूना आकार, लेकिन मैं यह सब मैन्युअल रूप से किया था) औसत क्रम समय के लिए निम्नलिखित बार मिला:
- sparseArray: (24 + 23 + 21 + 23 + 21 + 22 + 22 + 22 + 22 + 22 + 21 + 20 + 22 + 24 + 24 + 21 + 22 + 22 + 25 + 23 + 24 + 23 + 21 + 21 + 23)/25 = 22.32ms
- sparseArray2: (4 + 4 + 4 + 4 + 4 + 5 + 5 + 5 + 5 + 4 + 6 + 5 + 5 + 4 + 5 + 4 + 4 + 4 + 5 + 6 + 4 + 5 + 4 + 4 + 5)/25 = 4.56ms
- denseArray: (5 + 5 + 4 + 5 + 5 + 5 + 5 + 5 + 5 + 6 + 5 + 5 + 4 + 4 + 5 + 5 + 5 + 4 + 5 + 5 + 6 + 5 + 5 + 5 + 4)/25 = 4.8 8ms
नई परीक्षण:
के बाद 25 परीक्षणों (मुझे पता है, छोटा सा नमूना आकार, लेकिन मैं सभी मैन्युअल रूप से ऐसा किया) मैं औसत तरह समय के लिए निम्नलिखित समय मिल गया:
- sparseArray: (4 + 4 + 4 + 4 + 3 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 3 + 4 + 4)/15 = 3.867ms
- sparseArray2: (4 + 4 + 4 + 6 + 5 + 4 + 4 + 4 + 4 + 5 + 5 + 4 + 5 + 5 + 5)/15 = 4.533ms
- घने आरे: (4 + 4 + 4 + 5 + 5 + 4 + 4 + 4 + 4 + 5 + 5 + 4 + 5 + 5 + 5)/15 = 4।466ms
तो मैं निम्नलिखित निष्कर्ष पर आए हैं: संख्याओं की
- सरणी प्रकार वस्तुओं जिसका मान नंबर दिए गए हैं की सरणियों की तुलना में तेजी। यह सहजता से समझ में आता है।
- किसी कारण से, और विरोधाभासी रूप से, किसी विशेष तत्व में अधिक डेटा के परिणामस्वरूप कम डेटा की तुलना में तेज़ सॉर्टिंग होता है (जैसा कि स्पैरएरे 2 बनाम डेंसएरे रनटाइम्स द्वारा प्रमाणित किया गया है)।
क्या मैं जानना चाहता हूँ है:
- इन निष्कर्षों किसी भी प्रलेखन/कुछ मेरी परीक्षण के अलावा अन्य के द्वारा समर्थित हैं? यही है, क्या मैं सही निष्कर्ष तक पहुंचा?
- और क्यों? वस्तुओं के सरणी की तुलना में संख्याओं के सरणी तेजी से क्यों क्रमबद्ध होते हैं (सहजता से समझ में आता है, लेकिन इसके पीछे क्या स्पष्टीकरण है, यदि कोई हो)? इतना ही नहीं, लेकिन अधिक डेटा वाले कम डेटा वाले डेटा को तेज क्यों लगता है?
और ध्यान दें, मैं इन निष्कर्षों या किसी भी चीज़ से शादी नहीं कर रहा हूं। नमूना आकार छोटा है और मेरा परीक्षण पहले त्रुटिपूर्ण साबित हुआ है, इसलिए मेरे परिणाम खराब परीक्षण का परिणाम हो सकते हैं। इसके अलावा, ऐसे कई कारक प्रतीत होते हैं जिनके बारे में मुझे कोई जागरूकता नहीं है जो परिणाम को प्रभावित कर सकती हैं (जैसा कि रयान ओहारा ने मेरी पिछली पोस्ट में बताया था)। इस पोस्ट का बिंदु जावास्क्रिप्ट में व्यवहार को सॉर्ट करने के लिए किसी तथ्य-आधारित स्पष्टीकरण को खोजना है।
पढ़ने के लिए धन्यवाद!
परीक्षणों को पुन: व्यवस्थित करें और आपको बहुत ही महत्वपूर्ण उत्तर मिलेंगे - इन्हें फिर से शुरू करना सबसे अच्छा हो सकता है। – Ryan
@ RyanO'Hara अरे वाह कि शर्मनाक है ... आश्चर्य क्या हो रहा है ... – youngrrrr
@ RyanO'Hara - निर्धारित ... और अब मैं अभी भी बस के रूप में कई सवाल है ... – youngrrrr