Benchmark: es6 map access with string vs symbol keys.

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]]);

var eightSymbol = Symbol("eight")

Tests:

Get string key from map with only string keys
var value = mapStringKeys.get('eight');
Get symbol key from map with mixed string and symbol keys
var value = mapStringAndSymbolKeys.get(eightSymbol);

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: 11 months ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 137 on Android

View result in a separate tab

Test name	Executions per second
Get string key from map with only string keys	125022592.0 Ops/sec
Get symbol key from map with mixed string and symbol keys	118942808.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.

**Benchmark Definition JSON**

The test measures the performance difference between two approaches to accessing elements in a `Map` data structure:

1. Using only string keys (`mapStringKeys`)
2. Using both string and symbol keys (`mapStringAndSymbolKeys`)

In the script preparation code, we see that we create two maps: one with only string keys and another with both string and symbol keys.

The benchmark involves accessing elements in these two maps using their respective keys (either a string or a symbol). The test cases are:

* `Get string key from map with only string keys`: Accessing the value associated with the key `"eight"` in the `mapStringKeys` map.
* `Get symbol key from map with mixed string and symbol keys`: Accessing the value associated with the symbol key `Symbol("eight")` in the `mapStringAndSymbolKeys` map.

**Options Compared**

The two options being compared are:

1. **String Key Access**: Using only string keys to access elements in a `Map`.
2. **Symbol Key Access**: Using both string and symbol keys to access elements in a `Map`.

**Pros and Cons of Each Approach**

* **String Key Access**:
	+ Pros:
		- More common use cases, as most developers are familiar with using strings as keys.
		- May be faster for large maps due to cache efficiency.
	+ Cons:
		- May not perform well if the map is very large, as it can lead to slower lookup times due to hash collisions.
* **Symbol Key Access**:
	+ Pros:
		- Can provide better performance for large maps, as symbol keys are hashed differently and may reduce collisions.
		- Allows for more efficient iteration over the map's entries using `for...[Symbol.iterator()]`.
	+ Cons:
		- Less common use cases, as few developers are familiar with using symbols as keys.

**Library and Purpose**

In this benchmark, we're using the built-in `Map` data structure in JavaScript, which is a fundamental data structure for storing key-value pairs.

**Special JS Feature/Syntax**

The test uses symbol literals (`Symbol("key")`) to create symbol keys. Symbols are a relatively new feature introduced in ECMAScript 2015 (ES6) and provide a unique way to identify values that can't be easily guessed or replicated by other means. They're used here to demonstrate the performance difference between string key access and symbol key access.

**Other Alternatives**

If you want to create your own benchmark similar to this one, you could explore other data structures like:

1. **Object**: Instead of using a `Map`, you could use an object with string keys.
2. **Set**: A set is an unordered collection of unique values. You could test the performance of accessing elements in a set using different types of keys (e.g., strings, symbols).
3. **Array**: An array is a contiguous block of memory. While not ideal for storing key-value pairs, you could experiment with using arrays and indexing to access elements.

Keep in mind that each data structure has its own strengths and weaknesses, and performance differences may vary depending on the specific use case and requirements.

Related benchmarks:

es6 map access with string vs symbol keys. (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):