मान लीजिए, हमारे पास संख्या प्रविष्टियों की एक बड़ी संख्या के साथ एक सरणी है और समय की तुलना करने के लिए आवश्यक है रिकर्सन में लगने वाला समय बनाम एक साधारण लूप में लगने वाला समय बनाम ES6 फ़ंक्शन सरणी की सभी प्रविष्टियों को समेटने में लगता है यानी रिकर्सन बनाम लूप बनाम ES6 फ़ंक्शन ।
यहां, एक बड़े सरणी का अनुकरण करने के लिए हम अपेक्षाकृत छोटी सरणी पर बड़ी संख्या में (10000000 के क्रम में) पुनरावृति करेंगे। हमारा मुख्य उद्देश्य सरणी को सारांशित करने में प्रत्येक विधि द्वारा लिए जाने वाले समय का एक मोटा अनुपात रखना है।
भाग 1:पुनरावर्ती दृष्टिकोण
const recursiveSum = (arr, len = 0, sum = 0) => {
if(len < arr.length){
return recursiveSum(arr, len+1, sum + arr[len]);
};
return sum;
}; भाग 2:लूपिंग दृष्टिकोण
const loopingSum = arr => {
let sum = 0;
for(let i = 0; i < arr.length; i++){
sum += arr[i];
};
return sum;
}; भाग 3:ES6 दृष्टिकोण
const ES6Sum = arr => arr.reduce((acc, val) => acc+val);
आइए अब कंसोल मेथड्सटाइम () और टाइमएंड () -
की मदद से इन तीन फंक्शन के प्रदर्शन की तुलना करें।उदाहरण
const ITERATIONS = 100000000;
const arr = [12, 65, 87, 2, 23, 87, 4, 66, 34, 89, 89, 32, 4];
const recursiveSum = (arr, len = 0, sum = 0) => {
if(len < arr.length){
return recursiveSum(arr, len+1, sum + arr[len]);
};
return sum;
};
const loopingSum = arr => {
let sum = 0;
for(let i = 0; i < arr.length; i++){
sum += arr[i];
};
return sum;
};
const ES6Sum = arr => arr.reduce((acc, val) => acc+val);
console.time('recursive approach');
for(let k = 0; k < ITERATIONS; k++){
recursiveSum(arr);
};
console.timeEnd('recursive approach');
console.time('looping approach');
for(let l = 0; l < ITERATIONS; l++){
loopingSum(arr);
};
console.timeEnd('looping approach');
console.time('ES6 approach');
for(let m = 0; m < ITERATIONS; m++){
loopingSum(arr);
};
console.timeEnd('ES6 approach'); अब संभावित कंसोल आउटपुट पर एक नज़र डालते हैं -
नोट - यह केवल एक संभावित कंसोल आउटपुट है, क्योंकि कोड के किसी भी भाग का प्रदर्शन सिस्टम पर बहुत अधिक निर्भर करता है। लेकिन इन तीन कार्यों द्वारा लिए गए समय का अनुपात कमोबेश सभी प्रणालियों में समान होगा।
recursive approach: 13.774s looping approach: 3.138s ES6 approach: 2.493s
तो, यहां हम एक विशेष मशीन पर देख सकते हैं, बड़ी संख्या में पुनरावृत्तियों के लिए तीन दृष्टिकोणों द्वारा लिया गया समय। इससे पता चलता है कि किसी सरणी पर छोटी और बुनियादी गणनाओं के लिए, ES6 फ़ंक्शन किसी भी अन्य दृष्टिकोण की तुलना में अधिक कुशल और प्रदर्शनकारी हैं।
नोट − बेहतर परिणामों के लिए, ऑनलाइन आईडीई में इस कोड का परीक्षण करने से बचें।