Benchmark: complex values for reduce 1

Tests:

without indexing
function fill(count) { let obj = {} for(i=0; i<100000; i++){ let v = { g: i, v: i }; obj = { ...obj, i: v}; } return Object.entries(obj); } console.log(fill(10000).length)
with indexing
function fill(count) { let obj = {} for(i=0; i<100000; i++){ let v = { g: i, v: i }; obj[i] = v; } return Object.entries(obj); } console.log(fill(10000).length)
with set and array
function fill(count) { let objArray = [] let set1 = new Set(); for(i=0; i<count; i++){ if(!set1.has(i)) { set1.add(i); let v = { g: i, v: i }; objArray.push(v); } } return objArray; } console.log(fill(10000).length)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
without indexing
with indexing
with set and array

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 15_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 15 on iOS 15.4.1

View result in a separate tab

Test name	Executions per second
without indexing	295.3 Ops/sec
with indexing	61.4 Ops/sec
with set and array	2724.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition**

The provided JSON defines three benchmark tests, each representing a different approach to generating an array of objects using the `reduce()` method or direct indexing on arrays.

1.  **Test without indexing**: This test creates an object with nested properties and then uses the `reduce()` method to generate an array of objects. The resulting array has a large number of elements, which makes it computationally expensive.
2.  **Test with indexing**: In this case, the test uses direct indexing on the array to access its elements, creating a more lightweight array.
3.  **Test with set and array**: Here, we have an additional approach using a `Set` data structure to eliminate duplicate values in the resulting array.

**Options Comparison**

Each of these tests offers different trade-offs:

*   **Performance:** Without indexing (test 1) is likely to be the slowest due to its reliance on nested objects and the `reduce()` method. With indexing (test 2) should be faster because it only accesses the array elements directly, without unnecessary object lookups. The set-based approach with an array (test 3) might offer a balance between readability and performance.
*   **Readability:** Tests without indexing or with set and arrays tend to be less readable due to their complexity and use of `Set` data structure. On the other hand, tests using direct indexing on arrays are likely easier for developers familiar with array operations to understand.

**Pros and Cons**

Here's a summary of each test:

*   **Test without indexing:**
    *   Pros:
        *   Easy to implement, especially if you're already familiar with nested objects and `reduce()`.
        *   This approach can be useful in situations where readability is prioritized over performance.
    *   Cons:
        *   Slowest of the three due to its reliance on complex object lookups.
*   **Test with indexing:**
    *   Pros:
        *   Faster because it directly accesses array elements without unnecessary object lookups.
        *   Easy for developers familiar with arrays and array operations.
    *   Cons:
        *   May not be as readable due to its simplicity compared to other approaches.
*   **Test with set and array:**
    *   Pros:
        *   Offers a balance between readability and performance by utilizing `Set` data structure.
        *   Can help eliminate duplicate values, making it more efficient in certain scenarios.

**Special JS Features/Syntax**

No specific JavaScript features or syntax are used here; only standard JavaScript methods like `reduce()` and basic array operations are utilized.

Related benchmarks:

complex values for reduce 1 (version: 0)

Comparing performance of: without indexing vs with indexing vs with set and array

Created: 2 years ago by: Guest

Jump to the latest result

without indexing

with indexing

with set and array

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