Benchmark: test encore2 large

Script Preparation code:

function generateLargeTestRef() {
  const testRef = {};
  for (let i = 0; i < 50; i++) {
    testRef[`prop${i}`] = "x".repeat(10**6); // 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: 10000 }, () => ({
  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: 10000 }, () => ({
  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	23.9 Ops/sec
forEach 2	23.3 Ops/sec
for loop 1	21.9 Ops/sec
for loop 2	22.1 Ops/sec
for loop 1-2	22.8 Ops/sec
for loop 2-2	21.7 Ops/sec
for-in	21.8 Ops/sec
for-in 2	22.2 Ops/sec
for-of	22.5 Ops/sec
for-of 2	20.3 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark defined in the JSON you provided tests different approaches for iterating over JavaScript objects within a specific context: it compares performance across various looping constructs using two arrays of objects (`testObject` and `testObject2`), each containing references to a large object (`testRef_large`).

### Overview of the Test Environment

1. **Data Generation**:
   - The `generateLargeTestRef` function creates an object (`testRef_large`) with 50 properties, each containing a string of 1 million characters. This simulates a large dataset to stress test the performance of different iteration methods.
   - Two arrays (`testObject` and `testObject2`) are constructed, each containing 10,000 objects that reference `testRef_large` multiple times (3 and 5 references, respectively).

### Iteration Methods Tested

The benchmark consists of various looping constructs:

1. **forEach**:
   - **Code**: Uses the `.forEach()` method to iterate over `testObject` and `testObject2`.
   - **Pros**: More readable and concise syntax; does not require manual index handling.
   - **Cons**: Slightly less performance compared to traditional `for` loops because it involves a function call for each iteration.

2. **for loop**:
   - **Code**: Uses traditional `for` loops to iterate over `testObject` and `testObject2`.
   - Variants tested include a simple `for` loop (without caching length) and one that caches the length:
     - `for (let i = 0; i < testObject.length; i++)` 
     - `for (let i = 0, l = testObject.length; i < l; i++)`
   - **Pros**: Generally offers the best performance due to low overhead and allows for greater control over the iteration process.
   - **Cons**: More verbose; manual handling of loop variables and may lead to errors if not careful (e.g., off-by-one errors).

3. **for-in loop**:
   - **Code**: Iterates over the properties of the array using `for (let key in testObject)` and `for (let key in testObject2)`.
   - **Pros**: Provides a way to iterate over all properties of the object, including non-numeric keys.
   - **Cons**: Can include properties from the prototype chain, which may lead to unexpected results. Generally, slower compared to a traditional `for` loop when dealing with arrays.

4. **for-of loop**:
   - **Code**: Iterates over iterable objects (like arrays) using `for (let item of testObject)`.
   - **Pros**: Provides a more straightforward syntax compared to the `for` loop; only works with iterable objects.
   - **Cons**: Performance is typically less than a traditional `for` loop, and it's not suitable for iterating over non-iterable objects.

### Summary of Results

Based on the benchmark results, we can observe how many iterations can be executed per second for each test:

- **forEach**: Slightly slower than traditional for loops.
- **for loop (with length cache)**: Generally offers the highest performance, particularly for large datasets.
- **for-in loop**: Typically slower (from the provided results) and should be avoided for array iteration due to potential performance hits and logical pitfalls.
- **for-of loop**: Generally performs very well, but still slightly slower compared to the simplest `for` variants.

### Other Considerations and Alternatives

- **Performance**: The choice of looping construct can significantly affect performance, especially with a large volume of data, like in this benchmark.
- **Code Readability vs. Performance**: While maintaining code readability is essential, engineers must balance this with the performance requirements of the application.
  
Other alternatives not directly tested could include:
- **Array methods**: Such as `.map`, `.filter`, and `.reduce`, which can provide functional programming constructs.
- **Modern JavaScript constructs**: Such as combining `async/await` with iteration for asynchronous operations, though that wasn't tested here.

Choosing the right iteration method will depend on the context of use, data size, performance requirements, and team coding standards.

Related benchmarks:

test encore2 large (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):