Tổng mảng:So sánh phương thức đệ quy, vòng lặp for và ES6 trong JavaScript

Giả sử, chúng ta có một mảng với một số lượng lớn các mục nhập Số và được yêu cầu để so sánh thời gian đệ quy so với thời gian của một vòng lặp đơn giản so với thời gian hàm ES6 tính tổng tất cả các mục của mảng tức là đệ quy so với vòng lặp for vs hàm ES6 .

Ở đây, để mô phỏng một mảng lớn, chúng ta sẽ lặp qua một mảng tương đối nhỏ hơn với số lần lớn (theo thứ tự 10000000). Mục đích chính của chúng tôi là chỉ có một tỷ lệ sơ bộ về thời gian mỗi phương thức tính để tính tổng mảng.

Phần 1:Phương pháp tiếp cận đệ quy

const recursiveSum = (arr, len = 0, sum = 0) => {
   if(len < arr.length){
      return recursiveSum(arr, len+1, sum + arr[len]);
   };
   return sum;
};

Phần 2:Phương pháp tiếp cận vòng lặp

const loopingSum = arr => {
   let sum = 0;
   for(let i = 0; i < arr.length; i++){
      sum += arr[i];
   };
   return sum;
};

Phần 3:Phương pháp tiếp cận ES6

const ES6Sum = arr => arr.reduce((acc, val) => acc+val);

Bây giờ, hãy so sánh hiệu suất của ba hàm này với sự trợ giúp của console methodtime () và timeEnd () -

Ví dụ

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');

Bây giờ chúng ta hãy xem xét đầu ra bảng điều khiển có thể có -

Lưu ý - Đây chỉ là một đầu ra console khả thi, vì hiệu suất của bất kỳ đoạn mã nào phụ thuộc rất nhiều vào hệ thống. Nhưng tỷ lệ thời gian thực hiện bởi ba chức năng này ít nhiều sẽ giống nhau trên tất cả các hệ thống.

recursive approach: 13.774s
looping approach: 3.138s
ES6 approach: 2.493s

Vì vậy, ở đây chúng ta có thể thấy trên một máy cụ thể, thời gian được thực hiện bởi ba cách tiếp cận cho một số lượng lớn các lần lặp. Điều này cho thấy rằng đối với các phép tính nhỏ hơn và cơ bản trên một mảng, các hàm ES6 hiệu quả hơn và hoạt động hiệu quả hơn bất kỳ cách tiếp cận nào khác.

Lưu ý - Để có kết quả tốt hơn, tránh kiểm tra mã này trong IDE trực tuyến.