Benchmark: Map and Object number key vs string key

Script Preparation code:

var map = new Map();
var obj = {};

var randomInteger = Array(100000).fill(0).map(v => Math.floor(Math.random() * 1e8));
var randomFloat = Array(100000).fill(0).map(v => Math.random() * 1e8);
var randomString = Array(100000).fill(0).map(v => (Math.random() * 1e8).toString());

Tests:

Integer
map.clear(); randomInteger.forEach(v => { map.set(v, Math.random()); map.get(v); });
Float
map.clear(); randomFloat.forEach(v => { map.set(v, v); map.get(v); });
String
map.clear(); randomString.forEach(v => { map.set(v, v); map.get(v); });
Integer with Object
obj = {}; randomInteger.forEach(v => { obj[v] = v; obj[v]; });
Float with Object
obj = {}; randomFloat.forEach(v => { obj[v] = v; obj[v]; });
String with Object
obj = {}; randomString.forEach(v => { obj[v] = v; obj[v]; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Integer
Float
String
Integer with Object
Float with Object
String with Object

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared options, pros and cons, library usage, special JS features, and other considerations.

**Benchmark Definition**

The benchmark is to compare the performance of using integer keys versus string keys (or object keys) in a `Map` data structure. The test cases cover various scenarios:

1. Using integer keys with no objects.
2. Using float values as keys with no objects.
3. Using strings as keys with no objects.
4. Using integer keys with objects.
5. Using float values as keys with objects.
6. Using strings as keys with objects.

**Options Compared**

The main option being compared is:

* Integer (or float) keys vs string keys (or object keys).

**Pros and Cons of Options**

* **Integer Keys**: Pros:
	+ Typically faster lookups due to the efficient use of binary search trees.
	+ May be more suitable for numerical data.
Cons:
	+ May not perform well with large strings or object values.
	+ Limited range, as most JavaScript engines have a maximum 32-bit integer value.
* **String Keys**: Pros:
	+ Can store any type of string data (including non-numeric characters).
	+ More flexible than integer keys for storing data.
Cons:
	+ Lookups may be slower due to the inefficient use of hash tables or tries.
	+ May lead to more collisions with similar strings.
* **Object Keys**: Pros:
	+ Can store complex object values, which might be useful in certain scenarios.
Cons:
	+ Typically slower lookups compared to integer keys.
	+ Additional overhead for object creation and comparison.

**Library Usage**

There is no explicit library mentioned in the benchmark definition. However, `Map` is a built-in JavaScript data structure, which means that any performance differences are inherent to the JavaScript engine or its implementation.

**Special JS Features (Not Mentioned)**

No special JavaScript features or syntax are used in this benchmark.

**Other Considerations**

* The benchmark uses random integers, floats, and strings to populate the keys. This helps distribute the load evenly across different types of data.
* Each test case is self-contained, making it easier to compare the performance of each option independently.

**Alternatives**

If you were to create a similar benchmark, you might consider exploring other options, such as:

1. Using a `Set` instead of a `Map`, which would eliminate the need for keys and focus on lookup performance.
2. Implementing a custom data structure, like a trie or a Patricia tree, tailored to your specific use case.
3. Comparing different JavaScript engines or implementations (e.g., V8 vs SpiderMonkey) to see how they handle these types of operations.

Keep in mind that the results may vary depending on the specific implementation and environment used for the benchmark.

Latest run results:

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

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

Browser/OS: Chrome 126 on Windows

View result in a separate tab

Test name	Executions per second
Integer	36.0 Ops/sec
Float	45.6 Ops/sec
String	56.2 Ops/sec
Integer with Object	43.0 Ops/sec
Float with Object	17.7 Ops/sec
String with Object	51.8 Ops/sec

Related benchmarks:

Map and Object number key vs string key (version: 0)

Comparing performance of: Integer vs Float vs String vs Integer with Object vs Float with Object vs String with Object

Created: 6 months ago by: Registered User

Jump to the latest result

Integer

Float

String

Integer with Object

Float with Object

String with Object

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