Benchmark: Map population - MeasureThat.net

Tests:

forEach
const oldState = { entities: [ {SomeProp: 'nonsense 1', SomeOtherProp: 'more nonsense 1', id: 1}, {SomeProp: 'nonsense 2', SomeOtherProp: 'more nonsense 2', id: 2}, {SomeProp: 'nonsense 3', SomeOtherProp: 'more nonsense 3', id: 3}, {SomeProp: 'nonsense 4', SomeOtherProp: 'more nonsense 4', id: 4}, {SomeProp: 'nonsense 5', SomeOtherProp: 'more nonsense 5', id: 5}, {SomeProp: 'nonsense 6', SomeOtherProp: 'more nonsense 6', id: 6}, ] }; var oldEntitiesById = new Map(); Object.values(oldState.entities).forEach(e => oldEntitiesById.set(e.id, e)); console.log(oldEntitiesById);
Map
const oldState = { entities: [ {SomeProp: 'nonsense 1', SomeOtherProp: 'more nonsense 1', id: 1}, {SomeProp: 'nonsense 2', SomeOtherProp: 'more nonsense 2', id: 2}, {SomeProp: 'nonsense 3', SomeOtherProp: 'more nonsense 3', id: 3}, {SomeProp: 'nonsense 4', SomeOtherProp: 'more nonsense 4', id: 4}, {SomeProp: 'nonsense 5', SomeOtherProp: 'more nonsense 5', id: 5}, {SomeProp: 'nonsense 6', SomeOtherProp: 'more nonsense 6', id: 6}, ] }; const oldEntitiesById = new Map(oldState.entities.map(element => [element.id, element])); console.log(oldEntitiesById);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
Map

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 115 on Windows

View result in a separate tab

Test name	Executions per second
forEach	278287.2 Ops/sec
Map	290732.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript microbenchmarks can be fascinating.

The provided JSON represents two benchmark test cases for measuring the performance difference between using `Map` and `forEach` to populate a Map data structure in JavaScript.

**Benchmark Definition:**

The benchmark measures how efficient it is to populate a Map with a fixed array of objects, either by using `forEach` or by directly mapping each object to its corresponding key-value pair.

In both test cases, we have an initial `oldState` object containing an array of objects (`entities`). We then create two Maps: one using `Map` and the other using `forEach`.

**Options Compared:**

There are two main options being compared:

1. **Direct Mapping**: Using a direct mapping approach, where each element in the `entities` array is mapped to its corresponding key-value pair in the Map.
2. **Using `forEach`**: Using the `forEach` method to iterate over the `entities` array and populate the Map.

**Pros and Cons of Each Approach:**

1. **Direct Mapping:**
	* Pros:
		+ May be more efficient since it directly maps each element to its corresponding key-value pair.
		+ Can potentially take advantage of internal optimizations in the Map implementation.
	* Cons:
		+ Requires explicit mapping logic, which can be error-prone if not implemented correctly.
2. **Using `forEach`:**
	* Pros:
		+ Easier to implement and less prone to errors compared to direct mapping.
		+ Can provide more flexibility for future iterations or modifications.
	* Cons:
		+ May incur additional overhead due to the iteration process.

**Library and Purpose:**

In both test cases, no specific libraries are used. The `Map` data structure is a built-in JavaScript API, while the `forEach` method is also a native JavaScript function.

**Special JS Features or Syntax:**

There are no special JS features or syntax used in these benchmark test cases.

**Other Alternatives:**

If we were to consider alternative approaches, some options could be:

1. **Using `reduce()`**: Instead of using `forEach`, you could use the `reduce()` method to accumulate elements into a Map.
2. **Using `for...of` loop**: You could also use a `for...of` loop to iterate over the `entities` array and populate the Map.
3. **Using a library like Lodash**: If performance is critical, you might consider using a library like Lodash, which provides optimized implementations for various data structure operations.

Keep in mind that these alternatives may introduce additional complexity or overhead, so it's essential to evaluate their benefits against your specific use case and requirements.

I hope this explanation helps!

Related benchmarks:

Map population (version: 0)

compare ways to populate JS Map

Comparing performance of: forEach vs Map

Created: one year ago by: Registered User

Jump to the latest result

forEach

Map

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