Benchmark: Reduce vs push - MeasureThat.net

Script Preparation code:

var a = [];
for (let i = 0; i <= 100; i++) {
	a.push(i);
}

Tests:

1
const v = a.reduce((a, b) => [...a, b], []);
2
const v = []; a.forEach(x => v.push(x));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
1
2

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/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36

Browser/OS: Chrome 134 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
1	194887.8 Ops/sec
2	5305679.5 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition:**

The benchmark is comparing two approaches to build an array: `reduce` vs `push`. The script preparation code sets up an empty array `a`, which will be used in both test cases. The HTML preparation code is not specified.

**Options Compared:**

There are two options being compared:

1. **`reduce`**: This method takes a callback function that iterates over the array, applying the provided transformation to each element (in this case, pushing it to the result array). The `reduce` method returns an accumulator value, which is initialized with the first element of the array.
2. **`push`**: This method appends one or more elements to the end of the array and returns `undefined`.

**Pros and Cons:**

*   **`reduce`**:
    *   Pros:
        *   More concise and expressive syntax
        *   Reduces memory allocation overhead compared to using a separate loop and `push`
    *   Cons:
        *   Can be less efficient due to the need to create an accumulator value
        *   May have higher overhead due to the callback function execution
*   **`push`**:
    *   Pros:
        *   Generally faster since it only needs to allocate memory for a single element
        *   Less overhead in terms of function call and parameter passing
    *   Cons:
        *   Requires more code and is less concise than the `reduce` method

**Library Usage:**

There are no libraries explicitly mentioned in the provided JSON data. However, some modern browsers may have optimized implementations or polyfills for these methods.

**Special JS Features/Syntax:**

None mentioned in this specific benchmark definition.

**Alternatives:**

Other alternatives to compare could include:

*   **Using `forEach` with an arrow function**: This approach is similar to using `push`, but uses a different method.
*   **Using `Array.prototype.map`**: This would transform each element of the array into a new value without modifying the original array, which might affect performance in this benchmark.

Here's a basic implementation of these alternatives for reference:

```javascript
// Using forEach with an arrow function
const v = [];
a.forEach(x => {
    const tmp = [...v]; // Create a temporary copy of the array
    tmp.push(x);
});

// Using Array.prototype.map
const v = [];
a.forEach(x => v.push(x));
```

**Benchmark Preparation Code:**

Here's a more detailed version of the script preparation code, including a basic HTML structure:

```javascript
// Benchmark script
var a = [];

// Create an array with 100 elements
for (let i = 0; i <= 100; i++) {
    a.push(i);
}

// Create a basic HTML structure for benchmarking
document.write("<html><body><script>console.log('Test case completed');</script></body></html>");
```

This code creates an empty array `a` and populates it with numbers from 0 to 100. It then prints "Test case completed" to the console using a basic HTML structure.

Please note that the above code is just for benchmarking purposes, and should not be used in production environments due to potential security risks or performance impacts.

Related benchmarks:

Reduce vs push (version: 0)

Comparing performance of: 1 vs 2

Created: 4 years ago by: Guest

Jump to the latest result

1

2

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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