Benchmark: Dict vs. Map vs. Array ( complete iteration Ultimate Collection)

Script Preparation code:

var dict= {}
for (var i=0; i<50000; i++) {
  dict['abc_'+i] = i;
}

var map= new Map()
for (var i=0; i<50000; i++) {
  map.set('abc_'+i, i);
}

var arr = []
for (var i=0; i<50000; i++) {
  arr.push(i);
}

Tests:

Dictionary
let c = 0 for (let key in dict) { c += dict[key]}
Array Iterator
let c = 0 for (let entry of arr) { c += entry}
Map
let c = 0 for (let [key, entry] of map) { c += entry}
Array For Index
let c = 0, len = arr.length; for (let i=0; i<len; ++i) { c += arr[i]}
Array Inverse While
let c = 0 let i = arr.length; while(i--){ c += arr[i]; }
forEach call Array
let c = 0; arr.forEach((entry) => c+= entry);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Dictionary
Array Iterator
Map
Array For Index
Array Inverse While
forEach call Array

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/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Dictionary	159.1 Ops/sec
Array Iterator	31062.5 Ops/sec
Map	4275.7 Ops/sec
Array For Index	13566.1 Ops/sec
Array Inverse While	11821.3 Ops/sec
forEach call Array	3262.7 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark you're examining compares the performance of different data structures in JavaScript: **Object (Dictionary)**, **Map**, and **Array**. It evaluates how these structures perform when iterating over and accessing their contents, particularly in terms of execution speed.

### Data Structures Tested

1. **Dictionary (Object)**
   - **Usage**: Standard JavaScript objects are used as key-value stores.
   - **Performance Test**: The test uses a `for...in` loop to iterate over the properties of the object.
   - **Pros**:
     - Simple syntax and widely used.
     - Generally suitable for cases with string keys.
   - **Cons**:
     - Performance can significantly degrade with many keys, as seen in the test, due to the lack of direct iteration support and the presence of additional prototype properties.
     - Iteration order is not guaranteed (though modern JavaScript engines maintain insertion order for string keys under most circumstances).

2. **Map**
   - **Usage**: The Map object in JavaScript is a collection of keyed data items, similar to an object, but with better performance for frequent additions and removals.
   - **Performance Test**: The benchmark iterates using a `for...of` loop.
   - **Pros**:
     - Maintains the insertion order of keys.
     - More performant with a large number of elements due to optimized key storage.
   - **Cons**:
     - More memory overhead compared to plain objects.
     - Slightly more verbose syntax for insertion compared to simple objects.

3. **Array**
   - **Usage**: Arrays are used to store ordered collections of items and provide methods to manipulate those collections.
   - **Performance Tests**: Multiple iteration strategies are tested:
     - **Array Iterator**: Uses `for...of`.
     - **Array For Index**: Uses a traditional `for` loop with index access.
     - **Array Inverse While**: Uses a `while` loop iterating reverse through the array.
     - **forEach Method**: Utilizes `Array.prototype.forEach`.
   - **Pros**:
     - Arrays provide diverse and convenient methods for manipulation, including sorting and filtering.
     - Fast indexed access and can be faster for loop-based iterations especially when avoiding dynamic key lookups.
   - **Cons**:
     - Potentially slower on large datasets when using methods like `forEach` due to the function callback overhead.
  
### Results Summary

- **Fastest**: The **Array Iterator** performed best in terms of executions per second, suggesting that the modern iteration methods of arrays are highly optimized.
- **Performance Drop**: The **Dictionary** performed the worst, indicating that its inefficiencies with many entries are pronounced.
- **Map** had limited performance compared to arrays but is significantly faster than using a Dictionary—indicating it is preferable for key-value pair operations in performance-sensitive scenarios.

### Other Considerations

- **Use Case**: The choice between these data structures depends on the specific requirements of an application: 
  - If you need unique keys, a `Map` is generally better.
  - If you require ordered collections, an `Array` is the way to go.
  - If a simple key-value store is sufficient and performance is less of a concern, then an `Object` will be adequate.
  
- **Memory Consumption**: In scenarios where memory footprint matters, Objects can be lighter than Maps, but with the trade-off in performance.

- **Alternatives**: Other alternatives could include:
  - Using Sets for unique values with no associated keys.
  - Using Typed Arrays for numeric data to optimize performance further.
  - Libraries like **Lodash** for utility functions can help if more complex manipulations are needed, but at the cost of overhead and potentially larger bundle size.

In conclusion, this benchmark provides an essential insight into the performance implications of choosing different data structures in JavaScript, with clear performance differences and notable strengths and weaknesses among Objects, Maps, and Arrays.

Related benchmarks:

Dict vs. Map vs. Array ( complete iteration Ultimate Collection) (version: 1)

Large dictionary - how worse is it from array with direct reference? And how does Map perform?

Comparing performance of: Dictionary vs Array Iterator vs Map vs Array For Index vs Array Inverse While vs forEach call Array

Created: 2 months ago by: Guest

Jump to the latest result

Dictionary

Array Iterator

Map

Array For Index

Array Inverse While

forEach call Array

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):