Benchmark: reduce vs loop - MeasureThat.net

Script Preparation code:

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

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

Tests:

reduce
t.reduce((p,c) => p+c, 0);
t.reduce((p,c) => p+c, 0);

loop

(() => {
let res = 0;
for (let i=0;i<t.length;i++) res += t[i];
return res;})();

​x
 
(() => {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;})();

 
(() => {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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
reduce
loop
loop2

Fastest: N/A

Slowest: N/A

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

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

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:

Name: A unique identifier for the benchmark.
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.
Html Preparation Code: This section is empty, indicating that no HTML preparation is required.

Individual Test Cases

There are three test cases:

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.
loop: Uses a traditional loop to iterate over the array and add each element to a running total stored in res.
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.

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.

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