JavaScript में सरणी योग: पुनरावृत्ति बनाम फॉर लूप बनाम ES6 मेथड की तुलना

मान लीजिए हमारे पास संख्या प्रविष्टियों की एक बड़ी संख्या वाली सरणी है और पुनरावृत्ति द्वारा लिए गए समय की तुलना एक साधारण लूप द्वारा लिए गए समय और 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);

अब कंसोल मेथड time() और timeEnd() की मदद से इन तीन फ़ंक्शन के प्रदर्शन की तुलना करते हैं:

उदाहरण

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 फ़ंक्शन किसी भी अन्य दृष्टिकोण की तुलना में अधिक कुशल और प्रदर्शनकारी हैं।

नोट - बेहतर परिणामों के लिए, इस कोड को ऑनलाइन IDE में परीक्षण करने से बचें।