Benchmark: recursion vs iteration bench

Script Preparation code:

  var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  
  function sum_recurse(arr, i=0, acc=0) {
   if (i > arr.length)
     return acc;
  acc += i[i];  
  return sum_recurse(arr, i + 1, acc);
  }
  
  function sum_while(arr) {
   var total = 0,
       i = 0,
       len = arr.length;
  
   while (i < len) {
    total += arr[i++];
   }
  
   return total;
  }
  
  function sum_for(arr) {
   var total = 0,
       len = arr.length;
  
   for (var i = 0; i < len; i++) {
    total += arr[i];
   }
  
   return total;
  }

Tests:

recursion
sum_recurse(nums)
while loop
sum_while(nums)
for loop
sum_for(nums)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
recursion
while loop
for loop

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Overview**

The benchmark measures the performance difference between three different approaches for summing up an array of numbers: Recursion, While Loop, and For Loop.

**Options Compared**

The three options being compared are:

1. **Recursion**: A function calls itself to solve a problem. In this case, the `sum_recurse` function calls itself until it reaches the end of the array.
2. **While Loop**: A loop that continues as long as a certain condition is true. The `sum_while` function uses a while loop to iterate through the array and sum up its elements.
3. **For Loop**: A loop that iterates over a sequence (like an array) using a counter variable. The `sum_for` function uses a for loop to iterate through the array and sum up its elements.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Recursion**:
	+ Pros: Can be elegant and concise, easy to implement.
	+ Cons: Can be slower due to the overhead of function calls, can lead to stack overflows for large inputs.
* **While Loop**:
	+ Pros: Efficient use of CPU cycles, less overhead than recursion.
	+ Cons: Can be harder to read and understand, requires more manual control.
* **For Loop**:
	+ Pros: Most efficient and easy to understand, suitable for most programming tasks.
	+ Cons: Less flexible than while loops.

**Library Used**

There is no explicit library used in this benchmark. The `sum_recurse`, `sum_while`, and `sum_for` functions are simple implementations of each approach, and the `nums` array is a standard JavaScript array.

**Special JS Feature/Syntax**

None of the test cases use any special JavaScript features or syntax beyond the basics (e.g., array operations, loops). However, it's worth noting that some browsers may have specific optimizations or extensions that could affect the results of this benchmark.

**Alternative Approaches**

Some alternative approaches for summing up an array of numbers include:

* **Using `Array.prototype.reduce()`**: This is a more modern and efficient way to sum up an array using the reduce() method.
* **Using `Array.prototype.forEach()`**: While not as efficient as reduce(), forEach can still be used to iterate over an array and perform some operation on each element.

Overall, this benchmark provides a good starting point for understanding the performance differences between recursion, while loops, and for loops in JavaScript.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36

Browser/OS: Chrome 112 on Windows

View result in a separate tab

Test name	Executions per second
recursion	770381.5 Ops/sec
while loop	8892113.0 Ops/sec
for loop	8894490.0 Ops/sec

Related benchmarks:

recursion vs iteration bench (version: 0)

Comparing performance of: recursion vs while loop vs for loop

Created: 3 years ago by: Guest

Jump to the latest result

recursion

while loop

for loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):