Benchmark: TAMERE SALOPE - MeasureThat.net

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 => { });
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	359399.3 Ops/sec
forEach 2	354638.5 Ops/sec
for loop 1	63179.2 Ops/sec
for loop 2	62977.0 Ops/sec
for loop 1-2	87915.4 Ops/sec
for loop 2-2	88056.8 Ops/sec
for-in	7650.0 Ops/sec
for-in 2	7875.3 Ops/sec
for-of	394294.8 Ops/sec
for-of 2	396475.8 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided benchmark assesses various looping mechanisms in JavaScript by measuring their performance when iterating over two large data structures: `testObject` and `testObject2`. These objects have multiple references to a single large reference object `testRef_large` containing numerous properties with substantial values.

### Overview of Benchmark Structure

1. **Data Preparation**:
   - **Reference Object (`testRef_large`)**: This object has 50 properties, each containing a string of 1 million characters.
   - **Test Objects (`testObject` and `testObject2`)**: 
     - `testObject`: 10,000 instances each referencing `testRef_large` three times.
     - `testObject2`: 10,000 instances each referencing `testRef_large` five times.

### Individual Test Cases Explained

1. **forEach**:
   - **Test Cases**:
     - `forEach 1`: Iterates over `testObject`.
     - `forEach 2`: Iterates over `testObject2`.
   - **Pros**: Simple and clean syntax; easy to read and maintain.
   - **Cons**: Generally slower performance compared to traditional for loops, especially for large datasets.

2. **for loop**:
   - **Test Cases**:
     - `for loop 1`: Standard for loop over `testObject`.
     - `for loop 2`: Standard for loop over `testObject2`.
     - `for loop 1-2`: Uses a loop variable `l` to store the length of `testObject` for efficiency.
     - `for loop 2-2`: Similar optimization as above for `testObject2`.
   - **Pros**: Often the fastest due to low overhead; allows for optimizations like caching the length.
   - **Cons**: More verbose and less elegant than functional methods like `forEach`.

3. **for-in**:
   - **Test Cases**:
     - `for-in`: Iterates over `testObject`.
     - `for-in 2`: Iterates over `testObject2`.
   - **Pros**: Can iterate over properties of an object. Useful when the count or order of properties is not certain.
   - **Cons**: Can include properties from the object's prototype chain, leading to potential issues unless filtered correctly. Typically slower than other methods for array-like objects.

4. **for-of**:
   - **Test Cases**:
     - `for-of`: Looks through `testObject`.
     - `for-of 2`: Looks through `testObject2`.
   - **Pros**: Provides a clean syntax and directly iterates over values in iterable objects (like arrays).
   - **Cons**: Slightly overhead compared to traditional for loops, but generally performant for most use cases.

### Benchmark Results

The results indicate that the `for-of` syntax performs the best in terms of executions per second across both test cases:
1. **for-of 2**: 396,475.78 executions/second
2. **for-of**: 394,294.84 executions/second

In contrast, the traditional `for loop` methods had significantly lower performance metrics:
1. **for loop 2-2**: 88,056.77 executions/second
2. **for loop 1-2**: 87,915.35 executions/second

### Other Considerations

- **Memory Consumption**: The size of the objects being processed (particularly the strings in `testRef_large`) may impact how long iterations take, especially with limited memory resources.
- **Garbage Collection**: When working with large objects, garbage collection can become a performance bottleneck, especially if many objects are created.
- **Browser and Environment**: The results can vary between different JavaScript engines and browsers.

### Alternatives

1. **Array.from()**: Similar to `forEach`, allows for creating new arrays from existing ones for mapping but may not impact performance significantly.
2. **Map/Reduce**: Functional programming methods that can be expressive but generally incur overhead.
3. **Typed Arrays**: If working with numerical data, using typed arrays (e.g., `Float32Array`) can significantly improve performance.
4. **Worker Threads**: For CPU-intensive tasks, delegating operations to web workers can improve responsiveness by utilizing multi-threading.

This benchmark provides insights into the performance of different looping methods within JavaScript, considering readabilty, efficiency, and potential pitfalls. Software engineers can utilize these results to optimize operations that involve large data structures effectively.

Related benchmarks:

TAMERE SALOPE (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):