Benchmark: test encore - 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: 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 => { });
forEach 2
testObject2.forEach(item => { });
for loop 1
for (let i = 0; i < testObject.length; i++) { const item = testObject[i]; }
for loop 2
for (let i = 0; i < testObject2.length; i++) { const item = testObject2[i]; }
for loop 1-2
for (let i = 0, l = testObject.length; i < l; i++) { const item = testObject[i]; }
for loop 2-2
for (let i = 0, l = testObject2.length; i < l; i++) { const item = testObject2[i]; }
for-in
for (let key in testObject) { }
for-in 2
for (let key in testObject2) { }
for-of
for (let item of testObject) { }
for-of 2
for (let item of testObject2) { }

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	359046.1 Ops/sec
forEach 2	361259.8 Ops/sec
for loop 1	63181.8 Ops/sec
for loop 2	63584.4 Ops/sec
for loop 1-2	88896.0 Ops/sec
for loop 2-2	87808.6 Ops/sec
for-in	7859.4 Ops/sec
for-in 2	7932.0 Ops/sec
for-of	394819.3 Ops/sec
for-of 2	395288.9 Ops/sec

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

LLMs can make mistakes. Check important info.

### Overview of the Benchmark

This benchmark evaluates different methods of iterating through arrays of objects in JavaScript, specifically focusing on two array setups (testObject and testObject2), each consisting of 10,000 elements. Each element is an object with references to a large object `testRef_large`, which is created by the `generateLargeTestRef` function. The benchmark tests the following iteration techniques:

1. **forEach**
2. **for loop** (basic)
3. **for loop** (using a loop length variable)
4. **for-in** (object properties)
5. **for-of** (iterable objects)

### Iteration Methods Tested

#### 1. **forEach**
   - **Test Cases:**
     - `forEach 1`: Iterating through `testObject`
     - `forEach 2`: Iterating through `testObject2`
   - **Pros:** 
     - Simple syntax and easy to read.
     - Provides a functional approach to iteration.
   - **Cons:** 
     - Can be slightly less performant compared to other loop constructs, especially with large data sets, as it cannot be easily optimized by the engine.
     - We cannot break or continue the loop mid-way.

#### 2. **for loop**
   - **Test Cases:**
     - `for loop 1`: Basic for loop through `testObject`
     - `for loop 2`: Basic for loop through `testObject2`
     - `for loop 1-2`: For loop using a length variable with `testObject`
     - `for loop 2-2`: For loop using a length variable with `testObject2`
   - **Pros:**
     - Provides fine-grained control over the loop counter and can exit early using `break`.
     - Generally, offers better performance for large data sets.
   - **Cons:**
     - Verbose syntax compared to functional methods.
     - More room for off-by-one errors.

#### 3. **for-in**
   - **Test Cases:**
     - `for-in`: Iterating through `testObject`
     - `for-in 2`: Iterating through `testObject2`
   - **Pros:**
     - Can enumerate over all enumerable properties of an object.
   - **Cons:**
     - Not recommended for array iteration as it iterates over properties, which can lead to unexpected behavior.
     - May include inherited properties, affecting performance and accuracy.

#### 4. **for-of**
   - **Test Cases:**
     - `for-of`: Iterating through `testObject`
     - `for-of 2`: Iterating through `testObject2`
   - **Pros:**
     - Clean and readable syntax for iterating through iterable objects such as arrays or strings.
     - Similar performance to the traditional `for` loops.
   - **Cons:** 
     - Requires ES6 support, which might not be available in all environments.

### Summary of Performance Results

Based on the benchmark results in the provided JSON, `for-of` performed the best followed closely by `forEach` methods. The traditional `for` loops showed significantly lesser performance, indicating that their more verbose setup may involve additional overhead during execution. The `for-in` loop showed the poorest results as it is not intended for iterating through arrays, reinforcing the recommendation against its use for such cases.

### Conclusion

This benchmark provides a useful overview for software engineers on how different iteration methods can impact performance, especially in JavaScript. The findings suggest using `for-of` or `forEach` for readability in most cases, while traditional `for` may be used when maximum performance is critical.

### Other Alternatives

Other iteration constructs or methods not tested here include:

- **Array methods like `.map()`, `.filter()`, and `.reduce()`:** These methods provide a functional programming style and can be insightful for creating new arrays or reducing values, but typically involve more overhead than pure iteration.
  
- **While and do-while loops:** Additional looping mechanisms that can be used similarly to the `for` loop.

- **Using external libraries (like Lodash):** Libraries often provide methods that may optimize iteration tasks, especially with very complex data manipulation scenarios.

Overall, the choice of iteration method should be guided by a balance of performance, readability, and the specific requirements of the task at hand.

Related benchmarks:

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