Benchmark: POJO hash table vs Map

Script Preparation code:

var pojo1 = {};
var pojo2 = {};

var map1 = new Map();
var map2 = new Map();

for (var i = 0; i < 300; i++) {
    var val1 = Math.round(Math.random() * 10);
    var val2 = Math.round(Math.random() * 10);

    pojo1[`${i}`] = val1;
    map1.set(`${i}`, val1);

    pojo2[`${i}`] = val2;
    map2.set(`${i}`, val2);
}

Tests:

POJO - for...in
var diff = []; for (var key in pojo1) { if (pojo1.hasOwnProperty(key)) { if (pojo1[key] !== pojo2[key]) { diff.push(key); } } }
POJO - for...of Object.entries
var diff = []; for (var [key, val] of Object.entries(pojo1)) { if (val !== pojo2[key]) { diff.push(key); } }
POJO - reduce Object.entries
var diff = Object.entries(pojo1).reduce((acc, [key, val]) => { if (val !== pojo2[key]) { acc.push(key); } return acc; }, []);
Map - forEach
var diff = []; map1.forEach((val, key) => { if (val !== map2.get(key)) { diff.push(key); } });
Map - for...of entries
var diff = []; for (var [key, val] of map1.entries()) { if (val !== map2.get(key)) { diff.push(key); } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
POJO - for...in
POJO - for...of Object.entries
POJO - reduce Object.entries
Map - forEach
Map - for...of entries

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is being tested?**

The benchmark tests the performance of different iteration and diffing strategies when comparing two objects: a plain JavaScript object (POJO) and an ES6 Map data structure. The test creates a large dataset with 300 key-value pairs, where each value is a random number between 0 and 9.

**Options being compared**

The benchmark compares four options:

1. **POJO - for...in**: Uses the `for...in` loop to iterate over the object's properties and checks for differences using `pojo1[key] !== pojo2[key]`.
2. **POJO - for...of Object.entries**: Uses the `Object.entries()` method to get an array of key-value pairs, and then iterates over it using a `for...of` loop, checking for differences using `val !== pojo2[key]`.
3. **POJO - reduce Object.entries**: Uses the `reduce()` method to iterate over the array of key-value pairs generated by `Object.entries()`, checking for differences using `val !== pojo2[key]`.
4. **Map - forEach**: Uses the `forEach()` method to iterate over the map's entries, and checks for differences using `val !== map2.get(key)`.
5. **Map - for...of entries**: Similar to the previous option, but uses a `for...of` loop to iterate over the map's entries.

**Pros and cons of each approach**

1. **POJO - for...in**: Simple and easy to implement, but can be slower due to the overhead of checking `hasOwnProperty()`.
2. **POJO - for...of Object.entries**: More concise and efficient than `for...in`, but may have slightly higher memory usage due to the creation of an array.
3. **POJO - reduce Object.entries**: Can be faster than the previous two options, as it avoids the overhead of creating a loop control variable.
4. **Map - forEach**: Typically the fastest option, as it uses optimized C++ code for iteration and lookup.
5. **Map - for...of entries**: Similar to `forEach()`, but with slightly higher memory usage due to the creation of an array.

**Libraries and special features**

The benchmark uses the following libraries:

* None (all comparisons are built-in JavaScript)

No special JavaScript features or syntax are mentioned in the test cases.

**Other alternatives**

For those interested in exploring alternative approaches, here are a few options:

1. **Using `JSON.stringify()` and `JSON.parse()`:** This method can be used to compare objects using JSON serialization.
2. **Using `Array.prototype.some()`:** Similar to `forEach()`, but with slightly higher memory usage due to the creation of an array.
3. **Using `Array.prototype.findIndex()`:** Can be faster than `forEach()` for large arrays, as it uses optimized C++ code for iteration and lookup.

Keep in mind that these alternatives may not provide significant performance gains over the benchmarked options.

Latest run results:

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

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

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
POJO - for...in	18663.9 Ops/sec
POJO - for...of Object.entries	34832.3 Ops/sec
POJO - reduce Object.entries	33205.7 Ops/sec
Map - forEach	41408.1 Ops/sec
Map - for...of entries	50272.1 Ops/sec

Related benchmarks:

POJO hash table vs Map (version: 0)

Benchmark of various iteration and diffing strategies over a plain JavaScript-object-as-hash-table vs the ES6 Map data structure

Comparing performance of: POJO - for...in vs POJO - for...of Object.entries vs POJO - reduce Object.entries vs Map - forEach vs Map - for...of entries

Created: 4 years ago by: Guest

Jump to the latest result

POJO - for...in

POJO - for...of Object.entries

POJO - reduce Object.entries

Map - forEach

Map - for...of entries

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):