Array sum:การเปรียบเทียบการเรียกซ้ำกับวิธีลูปเทียบกับ ES6 ใน JavaScript

สมมติว่า เรามีอาร์เรย์ที่มีรายการ Number จำนวนมาก และจำเป็นต้องเปรียบเทียบการเรียกซ้ำของเวลากับเวลาที่วนรอบอย่างง่ายเทียบกับเวลาที่ฟังก์ชัน 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);

ตอนนี้ เรามาเปรียบเทียบประสิทธิภาพของฟังก์ชันทั้งสามนี้โดยใช้เมธอดของคอนโซลเวลา () และ 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 ออนไลน์