Benchmark: reduce vs loop - MeasureThat.net

Script Preparation code:

t = [];
for (let i=0; i < 50; i++) t.push(Math.random());

Tests:

reduce
t.reduce((p,c) => p+c, 0);
loop
(() => { let res = 0; for (let i=0;i<t.length;i++) res += t[i]; return res;})();
loop2
(() => { var i, res; for (i=res=0;i<t.length;i++) res += t[i]; return res;})();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
loop
loop2

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 world of JavaScript microbenchmarks on MeasureThat.net!

**Overview**

The provided benchmark tests two approaches to calculate the sum of an array: using the `reduce` method and a traditional loop. The test is designed to compare the performance of these two methods.

**Benchmark Definition JSON**

The benchmark definition JSON consists of three main sections:

1. **Name**: A unique identifier for the benchmark.
2. **Script Preparation Code**: This code prepares the data used in the benchmark. In this case, it creates an array `t` with 50 random numbers between 0 and 1.
3. **Html Preparation Code**: This section is empty, indicating that no HTML preparation is required.

**Individual Test Cases**

There are three test cases:

1. **reduce**: Uses the `reduce` method to calculate the sum of the array elements, starting from an initial value of 0. The callback function `(p, c) => p + c` adds each element to the accumulator `p`.
2. **loop**: Uses a traditional loop to iterate over the array and add each element to a running total stored in `res`.
3. **loop2**: Similar to the previous test case, but with a different syntax for declaring variables (`var i, res;` instead of `let i, res;`).

**Library Usage**

In the `reduce` test case, the `reduce` method is used, which is a part of the Array.prototype. The purpose of this library is to provide a concise way to calculate the sum of an array by applying a reduction function to each element.

**Special JavaScript Features or Syntax**

The benchmark uses some advanced syntax features:

* Arrow functions (`(p, c) => p + c` and `(() => {...})`)
* Let and var declarations (in test cases 2 and 3)
* Template literals (not used in this example)

**Performance Comparison**

The performance comparison is based on the number of executions per second. The results indicate that:

* The `reduce` method performs significantly better than the traditional loop, with a ratio of approximately 41:1.
* Test cases 2 and 3 have similar execution rates, but still outperform the `reduce` method.

**Other Alternatives**

If you're interested in exploring alternative approaches to calculate the sum of an array, here are some options:

* Using `forEach` loop: Instead of using a traditional loop, you can use the `forEach` method to iterate over the array and add each element to a running total.
* Using `every` method: The `every` method can be used to check if all elements in an array meet a condition. However, this approach would require some creative thinking to calculate the sum.

Keep in mind that these alternatives might not be as efficient or straightforward as using the `reduce` method or traditional loop.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15

Browser/OS: Safari 16 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
reduce	6738364.5 Ops/sec
loop	161457.6 Ops/sec
loop2	159848.8 Ops/sec

Related benchmarks:

reduce vs loop (version: 0)

Comparing performance of: reduce vs loop vs loop2

Created: 8 years ago by: Guest

Jump to the latest result

reduce

loop

loop2

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