Benchmark: Array loop vs for loop vs for loop cached

Script Preparation code:

function getArr() {
  	return Array(1000).fill(1);
//	var arr = [];
//    for (var i = 0; i < 1000; i++) {
//      arr[i] = i;
//    }
//    return arr;
}
  
function someFn(i) {
  return i * 3 * 8;
}

Tests:

foreach
var arr = getArr(); arr.forEach((item) => { someFn(item); })
map
var arr = getArr(); arr.map(item => someFn(item));
for each
var arr = getArr(); for (var i = 0; i < arr.length; i++) { someFn(arr[i]); }
for each cached
var arr = getArr(); for (var i = 0, len = arr.length; i < len; i++) { someFn(arr[i]); }
for each cached reversed
var arr = getArr(); for (var i = arr.length - 1; i >= 0; i--) { someFn(arr[i]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
foreach
map
for each
for each cached
for each cached reversed

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 months ago)

User agent: Mozilla/5.0 (Android 13; Mobile; rv:122.0) Gecko/122.0 Firefox/122.0

Browser/OS: Firefox Mobile 122 on Android

View result in a separate tab

Test name	Executions per second
foreach	54208.8 Ops/sec
map	26685.7 Ops/sec
for each	79064.2 Ops/sec
for each cached	77794.3 Ops/sec
for each cached reversed	92935.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark JSON and explain what is being tested.

**Benchmark Definition**
The benchmark measures the performance of three different approaches to iterate over an array: `foreach`, `map`, and two variations of `for` loops (`for each cached` and `for each cached reversed`). The test uses a fixed-size array of 1000 elements, filled with zeros (in reality, they're being filled with ones in the code).

**Script Preparation Code**
The script defines two functions: `getArr()` creates an array of 1000 elements, and `someFn(i)` takes an element from the array and returns its value multiplied by 3 and then by 8.

**Test Cases**

1. **foreach**: Iterates over the array using the `forEach` method, which calls `someFn(item)` for each element.
2. **map**: Uses the `map` method to create a new array with transformed elements, where `someFn(item)` is applied to each element.
3. **for each cached**: Similar to the previous one, but uses a `for` loop that iterates over the array length instead of the array itself.
4. **for each cached reversed**: The same as the previous one, but iterates over the array in reverse order.

**Library and Special Features**

* `forEach`: The `forEach` method is a built-in JavaScript method for iterating over arrays and other iterable objects.
* `map`: The `map` method is also a built-in JavaScript method for creating new arrays by applying a transformation function to each element of the original array.
* No special features or syntax are being tested in this benchmark.

**Options Compared**

The options compared are:

1. Iterating over an array using `forEach`, `map`, and two variations of `for` loops (`for each cached` and `for each cached reversed`).
2. The caching behavior of the `for` loop optimizations (i.e., whether the loop iterates over the array length or the array itself).

**Pros and Cons**

Here are some pros and cons for each approach:

1. **foreach**: Pros: Simple to understand, easy to maintain. Cons: May have performance overhead due to method call.
2. **map**: Pros: Creates a new array with transformed elements, can be more efficient than `forEach`. Cons: Requires additional memory allocation and copying of elements.
3. **for each cached**: Pros: Optimizes the loop by iterating over the array length, reducing memory allocations. Cons: May require explicit initialization of variables.
4. **for each cached reversed**: The same pros and cons as the previous one, with an added complexity due to the reverse iteration.

**Other Considerations**

* This benchmark only tests performance on a single array size (1000 elements). In practice, you may want to test different array sizes to see how the results scale.
* The benchmark assumes that the `someFn` function is inlined and optimized by the JavaScript engine. In reality, this function may be called multiple times per iteration, affecting its performance.

**Alternatives**

If you need to compare performance of similar loops or functions, you can consider using other benchmarking frameworks, such as:

* Google's Benchmark: A high-performance benchmarking framework for C++ and JavaScript.
* jsPerf: A web-based benchmarking tool specifically designed for testing JavaScript performance.
* Node.js Performance Test: A built-in benchmarking tool in Node.js that allows you to test the performance of your application.

Keep in mind that each framework has its own strengths and weaknesses, so choose one that fits your specific needs.

Related benchmarks:

Array loop vs for loop vs for loop cached (version: 0)

Comparing performance of: foreach vs map vs for each vs for each cached vs for each cached reversed

Created: 10 months ago by: Guest

Jump to the latest result

foreach

map

for each

for each cached

for each cached reversed

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):