Benchmark: Test for loop / reduce / cached loop / cached loop destructive

Script Preparation code:

function generateTestArray() {
  const result = [];
  for (let i = 0; i < 1000000; ++i) {
    result.push({
      a: i,
      b: i / 2,
      r: 0,
    });
  }
  return result;
}

Tests:

.reduce
const array = generateTestArray(); array.reduce((p, x) => p + x.a + x.b, 0);
.for (init array)
const array = generateTestArray(); const r = new Array(array.length); for (let i = 0; i < array.length; ++i) { r[i] = array[i].a + array[i].b; }
.for (init array) (cached)
const array = generateTestArray(); var arrLen = array.length; const r = new Array(array.length); for (let i = 0; i < arrLen; ++i) { r[i] = array[i].a + array[i].b; }
.for (init array) (cached) (destructive)
const array = generateTestArray(); var arrLen = array.length; const r = new Array(array.length); for (let i = 0; i < arrLen; ++i) { const {a,b} = array[i] r[i] = a + b; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
.reduce
.for (init array)
.for (init array) (cached)
.for (init array) (cached) (destructive)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
.reduce	26.3 Ops/sec
.for (init array)	31.2 Ops/sec
.for (init array) (cached)	34.2 Ops/sec
.for (init array) (cached) (destructive)	32.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript benchmarks!

**Benchmark Definition and Script Preparation Code**

The benchmark definition is a JSON object that contains information about the test case. The `Script Preparation Code` section defines a function `generateTestArray()` that creates an array of 1 million objects, each containing three properties: `a`, `b`, and `r`. This array will be used as input for the different test cases.

**Individual Test Cases**

The benchmark includes four test cases:

1. `.reduce`: This test case uses the `reduce()` method to iterate over the generated array and sum up the values of `a` and `b`.
2. `.for (init array)`: This test case uses a traditional `for` loop to iterate over the array and calculate the sum.
3. `.for (init array) (cached)`: This test case is similar to the previous one, but it reuses the length of the array as a cache value before the loop starts. This optimization is expected to improve performance by reducing the number of iterations.
4. `.for (init array) (cached) (destructive)`: This test case uses the same optimization as the previous one, but it destructures the array elements to access their properties (`a` and `b`). This approach might be considered "destructive" since it modifies the original array by changing its contents.

**Library: none**

None of these test cases rely on a specific JavaScript library. The benchmark is focused solely on the performance differences between using a traditional loop, the `.reduce()` method, or an optimized loop with caching and destruction.

**Special JS feature or syntax: caching**

The ".for (init array) (cached)" and ".for (init array) (cached) (destructive)" test cases utilize caching, which is a technique used to store the size of an array in memory before iterating over it. This can help reduce the number of iterations required to iterate over the array.

**Pros and Cons**

Here are some pros and cons associated with each approach:

* `.reduce()`: Pros:
	+ Easier to write and maintain, as it uses a single method.
	+ No need to worry about indexing or caching.
Cons:
	+ Might be slower due to the overhead of method calls.
* `.for (init array)`: Pros:
	+ Fast and efficient for large arrays.
	+ Simple and easy to understand.
Cons:
	+ Requires manual management of indexing and loops.
	+ Not as readable as other approaches.
* `.for (init array) (cached)`: Pros:
	+ Combines the benefits of caching and traditional looping.
	+ Can be faster than the pure `reduce()` method.
Cons:
	+ Requires a bit more code to implement correctly.
	+ Might not be as readable as other options.
* `.for (init array) (cached) (destructive)`: Pros:
	+ Similar performance benefits to the previous test case.
	+ Allows for destruction of the original array while iterating over it.
Cons:
	+ Adds an extra layer of complexity due to destruction.

**Other Alternatives**

Some alternative approaches that could be considered include:

* Using `Array.prototype.forEach()` or other iteration methods instead of traditional loops.
* Employing more advanced optimization techniques, such as SIMD (Single Instruction, Multiple Data) or parallel processing.
* Utilizing specialized libraries or frameworks optimized for performance and efficiency.

However, these alternatives are not represented in the provided benchmark definition.

Related benchmarks:

Test for loop / reduce / cached loop / cached loop destructive (version: 0)

Comparing performance of: .reduce vs .for (init array) vs .for (init array) (cached) vs .for (init array) (cached) (destructive)

Created: 2 years ago by: Guest

Jump to the latest result

.reduce

.for (init array)

.for (init array) (cached)

.for (init array) (cached) (destructive)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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