Benchmark: JS For vs reduce

Script Preparation code:

var l = 100;
var a = Array(l).fill('').map(()=>Math.round(Math.random(0,1)*l))
var b = Array(l).fill('').map(()=>Math.round(Math.random(0,1)*l))

Tests:

For + push
const p = [] for (let i=0; i < l; i++){ const c = a[i] < b[i] ? [a[i], b[i]] : [b[i], a[i]]; if(!p.includes(c)){ p.push(c); } }
For + concat
let p = [] for (let i=0; i < l; i++){ const c = a[i] < b[i] ? [a[i], b[i]] : [b[i], a[i]]; if(!p.includes(c)){ p = [...p, c] } }
Reduce
const p = a.reduce((acc, v, i) => { const c = v< b[i] ? [v, b[i]]: [b[i], v]; if(!acc.includes(c)){ acc.push(c) } return acc }, [])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For + push
For + concat
Reduce

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/116.0.0.0 Safari/537.36

Browser/OS: Chrome 116 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
For + push	27116.7 Ops/sec
For + concat	20582.1 Ops/sec
Reduce	59829.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and discussed.

**Benchmark Overview**

The benchmark is designed to compare three approaches for creating an array of unique pairs: `for + push`, `for + concat`, and `reduce`. The test case generates two arrays `a` and `b` with random elements between 0 and 100. The goal is to create a third array `p` containing only the unique pairs from `a` and `b`.

**Approaches Compared**

1. **For + push**: This approach uses a traditional `for` loop to iterate over the arrays, creating a new pair on each iteration and pushing it onto the `p` array if it doesn't already exist.
2. **For + concat**: Similar to the previous approach, but instead of using `push`, it uses the `concat` method to append the new pair to the `p` array.
3. **Reduce**: This approach uses the `reduce` method to accumulate the unique pairs in the `p` array.

**Pros and Cons**

*   **For + push**:
    *   Pros: Easy to understand, straightforward implementation.
    *   Cons: May lead to unnecessary allocations and copies of the arrays, especially for large datasets.
*   **For + concat**:
    *   Pros: Avoids unnecessary allocations and copies like `push`, but may still lead to performance issues due to the overhead of concatenating arrays.
*   **Reduce**:
    *   Pros: Efficient, as it avoids allocations and copies by using a single array for accumulation. Also, optimized for large datasets.
    *   Cons: May require additional understanding of the `reduce` method and its behavior.

**Library and Special Features**

None are explicitly mentioned in this benchmark definition.

**Alternatives**

Other approaches to create unique pairs could include:

*   **Set**: Using a Set data structure (e.g., with the `Set` class in modern JavaScript) to store the unique pairs. This would be similar to the `reduce` approach but might have additional overhead due to set operations.
*   **Map**: Using a Map data structure (e.g., with the `Map` class in modern JavaScript) to store the unique pairs, which could offer better performance than Sets.

Keep in mind that these alternatives might not necessarily outperform the existing approaches in this specific benchmark but can be explored for different use cases.

Related benchmarks:

JS For vs reduce (version: 0)

Comparing performance of: For + push vs For + concat vs Reduce

Created: one year ago by: Registered User

Jump to the latest result

For + push

For + concat

Reduce

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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