Benchmark: test encore2 - MeasureThat.net

Script Preparation code:

function generateLargeTestRef() {
  const testRef = {};
  for (let i = 0; i < 1; i++) {
    testRef[`prop${i}`] = "x".repeat(2); // 1 million de caractères
  }
  return testRef;
}

// Créer le testRef_large avec 50 propriétés
const testRef_large = generateLargeTestRef();

// Créer 10 000 testObject avec 3 références à testRef_large
const testObject = Array.from({ length: 10 }, () => ({
  a: testRef_large,
  b: testRef_large,
  c: testRef_large,
}));

// Créer 10 000 testObject2 avec 5 références à testRef_large
const testObject2 = Array.from({ length: 10 }, () => ({
  a: testRef_large,
  b: testRef_large,
  c: testRef_large,
  e: testRef_large,
  f: testRef_large,
}));

Tests:

forEach 1
testObject.forEach(item => { console.log(item) });
forEach 2
testObject2.forEach(item => { console.log(item) });
for loop 1
for (let i = 0; i < testObject.length; i++) { console.log(testObject[i]) }
for loop 2
for (let i = 0; i < testObject2.length; i++) { console.log(testObject2[i]) }
for loop 1-2
for (let i = 0, l = testObject.length; i < l; i++) { console.log(testObject[i]) }
for loop 2-2
for (let i = 0, l = testObject2.length; i < l; i++) { console.log(testObject2[i]) }
for-in
for (let key in testObject) { console.log(testObject[key]) }
for-in 2
for (let key in testObject2) { console.log(testObject2[key]) }
for-of
for (let item of testObject) { console.log(item) }
for-of 2
for (let item of testObject2) { console.log(item) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach 1
forEach 2
for loop 1
for loop 2
for loop 1-2
for loop 2-2
for-in
for-in 2
for-of
for-of 2

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 133 on Windows

View result in a separate tab

Test name	Executions per second
forEach 1	18697.6 Ops/sec
forEach 2	18258.6 Ops/sec
for loop 1	21148.3 Ops/sec
for loop 2	16394.5 Ops/sec
for loop 1-2	18426.3 Ops/sec
for loop 2-2	17763.3 Ops/sec
for-in	20941.2 Ops/sec
for-in 2	18053.4 Ops/sec
for-of	18920.0 Ops/sec
for-of 2	19887.9 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The provided benchmark JSON describes a series of performance tests for different JavaScript iteration methods applied to collections of objects. This setup can help developers analyze the efficiency of various approaches to iterating through arrays and objects in JavaScript. Here’s a breakdown of what is being tested, the options compared, and their pros and cons.

### Benchmark Setup

1. **Preparation Code**:
   - A large test object (`testRef_large`) is generated, containing a single property that holds a string of 1 million characters.
   - Two arrays of objects are created:
     - `testObject`: 10 objects, each referencing `testRef_large` three times (properties `a`, `b`, and `c`).
     - `testObject2`: 10 objects, referencing `testRef_large` five times (properties `a`, `b`, `c`, `e`, and `f`).

### Test Cases

The benchmark consists of multiple methods of iterating over these arrays:

1. **forEach**:
   - **Test Cases**:
     - `forEach 1`: Iterates over `testObject`.
     - `forEach 2`: Iterates over `testObject2`.
   - **Pros**: A clean and expressive syntax, easier to read, avoids manual index management.
   - **Cons**: Slower performance compared to traditional loops as it involves function calls for each iteration.

2. **for loop**:
   - **Test Cases**:
     - `for loop 1`: Standard for loop iterating `testObject`.
     - `for loop 2`: Standard for loop iterating `testObject2`.
     - `for loop 1-2` and `for loop 2-2`: Using a cached length to avoid recalculating on every iteration.
   - **Pros**: Typically faster due to less overhead; can be optimized by the JavaScript engine, especially when caching lengths.
   - **Cons**: Slightly more verbose; developers must manage the index, which can introduce off-by-one errors.

3. **for-in loop**:
   - **Test Cases**:
     - `for-in`: Iterates over keys of `testObject`.
     - `for-in 2`: Iterates over keys of `testObject2`.
   - **Pros**: Directly accesses properties by key, useful for iterating over object properties.
   - **Cons**: It iterates over all enumerable properties, including prototype properties, which may lead to unexpected results. Performance is usually slower than `for` loops for arrays.

4. **for-of loop**:
   - **Test Cases**:
     - `for-of`: Iterates over values of `testObject`.
     - `for-of 2`: Iterates over values of `testObject2`.
   - **Pros**: Clean syntax, works well with iterable units like arrays; avoids manual index management.
   - **Cons**: Slightly slower than a basic `for` loop and can be more verbose if you're just iterating over indices.

### Benchmark Results

- The recorded performance results provide `ExecutionsPerSecond` for each method, which helps determine the most efficient iteration technique in this context. The benchmarks reveal the relative speeds of each approach, where traditional `for` loops generally outperform array methods (`forEach`).

### Considerations

When choosing an iteration method:

- **Readability vs. Performance**: Opt for methods like `forEach` or `for-of` for cleaner syntax and ease of maintenance, especially if performance is not critical.
- **Compatibility and Features**: The basic `for` loop is a common choice due to its universal support and optimization across all JavaScript engines. 
- **Performance Needs**: For performance-sensitive applications, especially with large datasets, traditional `for` loops might be the best option.

### Alternatives

In addition to the methods tested, other alternatives include:

- **map, filter, reduce**: Higher-order functions that provide functional programming paradigms; useful for transforming data but can have higher computational overhead.
- **while loop**: Offers another looping construct that can be useful for certain conditions or configurations.
- **forEach with an arrow function**: This syntax is modern and concise, aligning with ES6 standards, but does not change the performance characteristics of `forEach`.
- **Agent-Specific Methods**: Browsers may have specific implementations (e.g., parallel iteration) that are optimal in certain contexts; however, they are more advanced and require a deeper understanding of JavaScript internals.

Overall, this benchmark suite effectively emphasizes the differences in execution time among various JavaScript iteration techniques, aiding developers in making informed optimization choices based on their specific use case.

Related benchmarks:

test encore2 (version: 1)

Comparing performance of: forEach 1 vs forEach 2 vs for loop 1 vs for loop 2 vs for loop 1-2 vs for loop 2-2 vs for-in vs for-in 2 vs for-of vs for-of 2

Created: 2 months ago by: Guest

Jump to the latest result

forEach 1

forEach 2

for loop 1

for loop 2

for loop 1-2

for loop 2-2

for-in

for-in 2

for-of

for-of 2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):