Benchmark: Map bench - MeasureThat.net

Script Preparation code:

var esmap = new Map();
var omap = {};
var keys = [];

var cnt = 1e4;

while(cnt--){
	var v = Math.random();
	var k = keys[cnt] = 'key'+v;

	esmap.set(k,v);
	omap[k] = v;
}

Tests:

es get
var v; for(var i = 0; i<keys.length; i++){ v = esmap.get(keys[k]) }
objmap get
var v; for(var i = 0; i<keys.length; i++){ v = omap[keys[k]] }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
es get
objmap get

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 23 days ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark, titled "Map bench", tests the performance of JavaScript objects (`esmap` and `omap`) when accessing elements using their keys. The test consists of two individual test cases: `es get` (using `esmap.get()`) and `objmap get` (using `omap[keys[k]]`). The benchmark prepares a large dataset of 10,000 key-value pairs in both objects.

**Options Compared**

The two options being compared are:

1. **Object Iteration**: Both test cases iterate over the keys of the object using a `for` loop.
2. **Method Call**: In the `es get` test case, the `get()` method is called on the object, while in the `objmap get` test case, direct property access (`keys[k]`) is used.

**Pros and Cons**

* **Object Iteration (Both)**:
	+ Pros: Portable across different JavaScript engines and environments.
	+ Cons: May be slower due to the overhead of iterating over the keys.
* **Method Call (es get)**:
	+ Pros: May be faster since it's a single method call, potentially optimized by the engine.
	+ Cons: Requires the `get()` method, which might not exist in older engines or when used with some libraries.
* **Direct Property Access (objmap get)**:
	+ Pros: Potentially faster since direct property access can be optimized by the engine.
	+ Cons: May require special handling in older engines or when using certain libraries.

**Library and Purpose**

In this benchmark, two libraries are used:

1. **Map**: A built-in JavaScript object that stores key-value pairs.
2. **Array**: Although not explicitly mentioned, an array (`keys`) is created to hold the keys for iteration.

**Special JS Feature/Syntax (Not applicable in this case)**

None of the test cases use special JavaScript features or syntax that require specific handling.

**Other Alternatives**

If you were to create a similar benchmark, you could also consider adding other variations, such as:

* Using different data structures (e.g., `Set`, `WeakMap`) instead of `Map`.
* Adding additional overhead, like memoization or caching.
* Testing with different engine versions or environments.

Keep in mind that the specific options and variations will depend on your testing goals and the requirements of your benchmark.

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Firefox/102.0

Browser/OS: Firefox 102 on Linux

View result in a separate tab

Test name	Executions per second
es get	161150.3 Ops/sec
objmap get	227377.2 Ops/sec

Related benchmarks:

Map bench (version: 0)

Comparing performance of: es get vs objmap get

Created: 6 years ago by: Guest

Jump to the latest result

es get

objmap get

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 23 days ago):