Benchmark: es6 map access with string vs symbol keys 2

Script Preparation code:

var mapStringKeys = new Map([["one", true], ["two", true], ["three", true], ["four", true], ["five", true], ["six", true], ["seven", true], ["eight", true], ["nine", true], ["ten", true]]);
var mapStringAndSymbolKeys = new Map([["one", true], [Symbol("two"), true], ["three", true], [Symbol("four"), true], ["five", true], [Symbol("six"), true], ["seven", true], [Symbol('eight'), true], ["nine", true], [Symbol("ten"), true]]);

function random(elements) {
	return Math.random() * elements.length - 1
}

var stringKeys = Array.from(mapStringKeys.keys());
var symbolKeys = Array.from(mapStringAndSymbolKeys.keys());

Tests:

Get string key from map with only string keys
var value = mapStringKeys.get(random(stringKeys));
Get symbol key from map with mixed string and symbol keys
var value = mapStringAndSymbolKeys.get(random(symbolKeys));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Get string key from map with only string keys
Get symbol key from map with mixed string and symbol keys

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36

Browser/OS: Chrome 122 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Get string key from map with only string keys	5362407.5 Ops/sec
Get symbol key from map with mixed string and symbol keys	5587404.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases.

**Benchmark Definition JSON**

The provided JSON represents a JavaScript microbenchmark that compares two approaches to accessing values in a Map object: one using string keys and the other using mixed string and symbol keys.

* `Script Preparation Code`: This code creates two Maps, `mapStringKeys` and `mapStringAndSymbolKeys`, with different key types. The keys for `mapStringKeys` are all strings, while the keys for `mapStringAndSymbolKeys` include both strings and symbols.
* `Html Preparation Code`: This is empty, which means that no HTML code is provided to set up any environmental context.

**Individual Test Cases**

There are two test cases:

1. **Get string key from map with only string keys**: This test case accesses a value in `mapStringKeys` using the `get()` method and a random string key generated by the `random()` function.
2. **Get symbol key from map with mixed string and symbol keys**: This test case accesses a value in `mapStringAndSymbolKeys` using the `get()` method and a random symbol key generated by the `random()` function.

**Options Compared**

The two options being compared are:

1. Accessing values in a Map object using string keys.
2. Accessing values in a Map object using mixed string and symbol keys.

**Pros and Cons of Each Approach**

* **String Keys**:
	+ Pros: Widely supported, easy to understand, and well-documented.
	+ Cons: May lead to slower performance due to the overhead of searching for strings in the Map's internal data structure.
* **Mixed String and Symbol Keys**:
	+ Pros: Can take advantage of symbol-based lookup, which can be faster than string-based lookup in some cases.
	+ Cons: May not be as widely supported or well-documented, requiring more developer expertise to set up.

**Library Used**

The `Map` object is a built-in JavaScript object that provides an implementation for hash tables. It's used here to store key-value pairs, allowing for efficient lookups by key.

**Special JS Feature or Syntax**

There are no special features or syntaxes mentioned in the provided code snippet. The focus is on comparing two different approaches to accessing values in a Map object using JavaScript.

**Other Alternatives**

If you wanted to benchmark similar scenarios, you could consider using other data structures such as:

* `Object`: Instead of Maps, you could use objects with string keys and values.
* `Sets` or `WeakSets`: For faster lookup or insertion operations on unique values.
* Other hash table implementations, like `HashTable` from a specific library (e.g., Lodash).

Keep in mind that each alternative data structure has its own strengths and weaknesses, and the choice of which one to use depends on your specific requirements.

Related benchmarks:

es6 map access with string vs symbol keys 2 (version: 0)

Comparing performance of: Get string key from map with only string keys vs Get symbol key from map with mixed string and symbol keys

Created: 4 years ago by: Guest

Jump to the latest result

Get string key from map with only string keys

Get symbol key from map with mixed string and symbol keys

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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