Benchmark: Loop vs Recursion for Array

Script Preparation code:

var DogArr = [ "Great Pyranees", "Great Dane", "Irish Wolfhound", "Golden Retriever" ];

function runLoop() {
	for( var i = 0; i < DogArr.length; i++ )
    {
    	console.log( DogArr[ i ] );
    }
}

function runRecursion() {
  	var count = 0;
	function loopThroughArray() {
    	if( count < DogArr.length ) {
          console.log( DogArr[ count ] );
          loopThroughArray();
        } else {
        	return;
        }
      
    }

}

Tests:

Loop
runLoop();
Recursion
runRecursion();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Loop
Recursion

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 5 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Loop	126093.3 Ops/sec
Recursion	153273648.0 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**What is being tested?**

The benchmark tests two approaches to iterate over an array: a traditional loop and recursion.

**Options compared**

There are two options being compared:

1. **Loop**: This approach uses a for loop to iterate over the array elements.
2. **Recursion**: This approach uses a recursive function to iterate over the array elements.

**Pros and Cons of each approach**

* **Loop:**
	+ Pros:
		- Typically faster and more efficient than recursion.
		- Less memory usage, as it doesn't require creating multiple function call stacks.
	+ Cons:
		- Can be less intuitive for beginners, especially for those without prior experience with loops.
		- May not be suitable for very large datasets or infinite loops.
* **Recursion:**
	+ Pros:
		- Easier to understand and implement for beginners, as it's a familiar concept.
		- Can be useful for problems that have a recursive structure, such as tree traversals.
	+ Cons:
		- Typically slower than loops due to the overhead of function calls and stack management.
		- Higher memory usage, as each recursive call creates a new stack frame.

**Library used**

There is no explicit library mentioned in the benchmark definition or test cases. However, it's likely that the benchmark uses built-in JavaScript functions and features, such as `console.log()` and array iteration methods like `forEach()` or `for...of`.

**Special JS feature or syntax**

The benchmark uses a special JS feature called "Closures" with the recursive function `loopThroughArray()`. A closure is a function that has access to its own scope and can capture variables from that scope, even when the outer function has finished executing. In this case, the recursive function `loopThroughArray()` captures the `count` variable from the outer scope, allowing it to keep track of the iteration index.

**Other alternatives**

If you're interested in exploring other approaches to iterate over an array, here are a few examples:

* **Iterators**: JavaScript iterators provide a way to iterate over arrays and other iterable objects using a custom implementation.
* **Generators**: Generators are a type of function that can be used to implement iterative logic. They allow you to create functions that yield values instead of returning them directly.
* **SetTimed**: This approach uses the `setTimeout()` function to schedule iterations at regular intervals, allowing for a more controlled and efficient iteration.

Note that these alternatives may have their own trade-offs in terms of performance, memory usage, and code complexity.

Related benchmarks:

Loop vs Recursion for Array (version: 0)

Comparing performance of: Loop vs Recursion

Created: 8 years ago by: Guest

Jump to the latest result

Loop

Recursion

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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