Benchmark: For meseuerement

Script Preparation code:

let data = [
    [
        1731416366378,
        3
    ],
    [
        1731416400000,
        3
    ],
    [
        1731416546584,
        3
    ],
    [
        1731416734567,
        1
    ],
    [
        1731416915539,
        1
    ],
    [
        1731417103129,
        1
    ],
    [
        1731417283810,
        1
    ],
    [
        1731417465766,
        3
    ],
    [
        1731417644518,
        3
    ],
    [
        1731417828571,
        0
    ],
    [
        1731418008276,
        0
    ],
    [
        1731418195886,
        0
    ],
    [
        1731418399363,
        0
    ],
    [
        1731418592505,
        0
    ],
    [
        1731418771085,
        0
    ],

    [
        1731416366378,
        3
    ],
    [
        1731416400000,
        3
    ],
    [
        1731416546584,
        3
    ],
    [
        1731416734567,
        1
    ],
    [
        1731416915539,
        1
    ],
    [
        1731417103129,
        1
    ],
    [
        1731417283810,
        1
    ],
    [
        1731417465766,
        3
    ],
    [
        1731417644518,
        3
    ],
    [
        1731417828571,
        0
    ],
    [
        1731418008276,
        0
    ],
    [
        1731418195886,
        0
    ],
    [
        1731418399363,
        0
    ],
    [
        1731418592505,
        0
    ],
    [
        1731418771085,
        0
    ],
    [
        1731418962461,
        0
    ],
    [
        1731419159333,
        4
    ],
    [
        1731419341648,
        4
    ],
    [
        1731419521583,
        0
    ],
    [
        1731419702032,
        0
    ],
    [
        1731419886050,
        0
    ],
    [
        1731420068947,
        0
    ],
    [
        1731420270874,
        3
    ],
    [
        1731420475599,
        3
    ],
    [
        1731420698605,
        3
    ],
    [
        1731420884749,
        3
    ],
    [
        1731421063997,
        3
    ],
    [
        1731421286506,
        3
    ],
    [
        1731421486691,
        3
    ],
    [
        1731421709849,
        3
    ],
    [
        1731421926377,
        3
    ],
    [
        1731422158517,
        3
    ],
    [
        1731422380359,
        3
    ],
    [
        1731422586810,
        3
    ],
    [
        1731422801770,
        3
    ],
    [
        1731422994511,
        3
    ],
    [
        1731423178622,
        3
    ],
    [
        1731423389025,
        3
    ],
    [
        1731423579395,
        3
    ],
    [
        1731423772915,
        3
    ],
    [
        1731423961422,
        3
    ],
    [
        1731424137407,
        3
    ],
    [
        1731424317518,
        3
    ],
    [
        1731424499838,
        3
    ],
    [
        1731424688200,
        3
    ],
    [
        1731424866749,
        3
    ],
    [
        1731425063896,
        3
    ],
    [
        1731425246643,
        3
    ],
    [
        1731425426094,
        2
    ],
    [
        1731425614740,
        2
    ],
    [
        1731425802064,
        2
    ],
    [
        1731425982614,
        2
    ],
    [
        1731426161980,
        2
    ],
    [
        1731426342528,
        3
    ],
    [
        1731426522163,
        3
    ],
    [
        1731426704198,
        2
    ],
    [
        1731426885779,
        2
    ],
    [
        1731427064012,
        2
    ],
    [
        1731427243469,
        2
    ],
    [
        1731427424704,
        2
    ],
    [
        1731427606431,
        2
    ],
    [
        1731427788341,
        3
    ],
    [
        1731427976305,
        3
    ],
    [
        1731428154194,
        3
    ],
    [
        1731428333770,
        3
    ],
    [
        1731428516483,
        3
    ],
    [
        1731428693636,
        3
    ],
    [
        1731428876329,
        3
    ],
    [
        1731429054588,
        3
    ],
    [
        1731429234320,
        3
    ],
    [
        1731429413846,
        3
    ],
    [
        1731429594286,
        3
    ],
    [
        1731429675516,
        3
    ]

]

Tests:

for
for (var i = 0; i < data.length; i++) { data[i]; }
forEach
data.forEach(function(i) { data[i]; });
For In
for (var i in data) { data[i]; }
For of with continue
let criticalityCount = {}; for (let [, criticality] of data) { if (criticality === 0) { continue; } if (criticality in criticalityCount) { criticalityCount[criticality]++; } else { criticalityCount[criticality] = 1; } }
For of with filter before
let filteredData = data.filter(([, criticality]) => criticality !== 0); let criticalityCount = {}; for (let [, criticality] of filteredData) { if (criticality in criticalityCount) { criticalityCount[criticality]++; } else { criticalityCount[criticality] = 1; } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for
forEach
For In
For of with continue
For of with filter before

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 8 days ago):

LLMs can make mistakes. Check important info.

The benchmark tests various iteration techniques in JavaScript applied to a predefined array of data points. This data consists of pairs, where the first element is a timestamp (in milliseconds) and the second is an integer representing a "criticality" level. The objective of these benchmarks is to measure the performance characteristics of different looping constructs and approaches for processing this data.

### Tested Options

1. **For Loop**
   - **Benchmark Code:** `for (var i = 0; i < data.length; i++) { data[i]; }`
   - **Pros:** 
     - Fast execution; generally regarded as one of the best performing methods due to low overhead.
   - **Cons:**
     - Verbose and manual, which could lead to off-by-one errors if not carefully implemented.
   - **Considerations:** Best for scenarios where maximum performance is critical, and the number of iterations is known.

2. **forEach Method**
   - **Benchmark Code:** `data.forEach(function(i) { data[i]; });`
   - **Pros:**
     - More concise and easier to read; expresses intent clearly.
   - **Cons:**
     - Slightly slower due to overhead of function calls. It can't be stopped or optimized easily in terms of early exits.
   - **Considerations:** Useful for readability but may not be ideal for performance-sensitive applications.

3. **For...in Loop**
   - **Benchmark Code:** `for (var i in data) { data[i]; }`
   - **Pros:**
     - Useful for iterating over object properties or if the exact order does not matter.
   - **Cons:**
     - The `for...in` loop is slower and can lead to unexpected behavior when iterating over array-like structures, as it iterates over all enumerable properties, not just indexes.
   - **Considerations:** Generally, not recommended for arrays due to potential performance issues and side effects.

4. **For...of Loop with Continue Statement**
   - **Benchmark Code:** 
     ```javascript
     let criticalityCount = {};
     for (let [, criticality] of data) {
       if (criticality === 0) { continue; }
       if (criticality in criticalityCount) {
         criticalityCount[criticality]++;
       } else {
         criticalityCount[criticality] = 1;
       }
     }
     ```
   - **Pros:**
     - Cleaner syntax and easier to read, while also allowing breaks and continues.
   - **Cons:**
     - Depending on the context, may not match the raw speed of a traditional for loop.
   - **Considerations:** A balanced choice in situations where both readability and performance matter.

5. **For...of Loop with a Filtered Data Set**
   - **Benchmark Code:** 
     ```javascript
     let filteredData = data.filter(([, criticality]) => criticality !== 0);
     let criticalityCount = {};
     for (let [, criticality] of filteredData) {
       if (criticality in criticalityCount) {
         criticalityCount[criticality]++;
       } else {
         criticalityCount[criticality] = 1;
       }
     }
     ```
   - **Pros:**
     - First filters out unnecessary elements, thus only processing relevant data.
   - **Cons:**
     - Creating a new array using `filter` adds overhead and reduces performance due to additional memory operations.
   - **Considerations:** This method is useful when you want to simplify subsequent processing at the cost of some performance.

### Benchmark Results Interpretation

The benchmark's results indicate that the "For of with continue" loop has the highest performance, executing approximately **2,040,000 times per second**. The filtered version also performs well, but with reduced efficiency compared to the direct iteration. The traditional "for" loop is efficient but slightly less readable, while the "forEach" method shows the lowest performance, which is expected given its overhead.

### Conclusions

In summary, each iteration method has its own pros and cons, making them suitable for different scenarios. The choice of which technique to use depends on specific use cases: The standard `for` loop is great for performance; the `forEach` loop is better for clarity; the `for...of` syntax bridges the readability and performance gap; and additional methods like filtering before looping, while useful for specific needs, introduce overhead that may make them less suited to performance-critical applications.

JavaScript offers various options; engineers should always weigh the needs for speed against the necessities for code clarity and maintainability. Understanding these differences is crucial for selecting the right iteration strategy based on the context and requirements of the project they are working on.

Latest run results:

Run details: (Test run date: 8 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
for	127807.0 Ops/sec
forEach	39370.3 Ops/sec
For In	187857.5 Ops/sec
For of with continue	2040335.9 Ops/sec
For of with filter before	1309746.4 Ops/sec

Related benchmarks:

For meseuerement (version: 3)

Comparing performance of: for vs forEach vs For In vs For of with continue vs For of with filter before

Created: 8 days ago by: Registered User

Jump to the latest result

for

forEach

For In

For of with continue

For of with filter before

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 8 days ago):