Benchmark: Set vs Object vs Map, Access

Script Preparation code:

var set = new Set(["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"]);
var object = {"one": true, "two": true, "three": true, "four": true, "five": true, "six": true, "seven": true, "eight": true, "nine": true, "ten": true};
var map = new Map([["one", true], ["two", true], ["three", true], ["four", true], ["five", true], ["six", true], ["seven", true], ["eight", true], ["nine", true], ["ten", true]]);

var values = Object.keys(object);

Tests:

Set
set.has('one'); set.has('two'); set.has('three'); set.has('four'); set.has('five'); set.has('six'); set.has('seven'); set.has('eight'); set.has('nine'); set.has('ten');
Object
object['one']; object['two']; object['three']; object['four']; object['five']; object['six']; object['seven']; object['eight']; object['nine']; object['ten'];
Map
map.get('one'); map.get('two'); map.get('three'); map.get('four'); map.get('five'); map.get('six'); map.get('seven'); map.get('eight'); map.get('nine'); map.get('ten');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set
Object
Map

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark and its test cases to understand what is being tested, the options compared, pros, cons, and other considerations.

**Benchmark Definition:**

The benchmark compares the speed of retrieving values from three data structures that can be used for boolean referencing:

1. **Set**: A collection of unique values, which can be used to store boolean settings.
2. **Object**: An object with string keys, where each key has a corresponding boolean value.
3. **Map**: An unordered collection of key-value pairs, where each key is unique and maps to a specific value.

**Test Cases:**

Each test case consists of a benchmark definition that performs the same operation multiple times. The operations are:

* `set.has('one');` (Set)
* `object['one'];` (Object)
* `map.get('one');` (Map)

The number of executions for each operation is not specified, but it can be inferred from the "ExecutionsPerSecond" value in the benchmark results.

**Options Compared:**

The three data structures are compared in terms of their performance when used to retrieve boolean values. The test aims to determine which data structure is fastest for this specific use case.

**Pros and Cons:**

1. **Set**:
	* Pros: Fast lookups (O(1) on average), efficient memory usage, and simple implementation.
	* Cons: Not designed for storing boolean values; may not be suitable for other types of data.
2. **Object**:
	* Pros: Widely supported and well-established, easy to implement, and flexible.
	* Cons: Slow lookups (O(n) in the worst case), and may lead to slower performance due to object lookup overhead.
3. **Map**:
	* Pros: Fast lookups (O(1) on average), efficient memory usage, and flexible key-value pairs.
	* Cons: May not be as widely supported as objects; requires careful key management.

**Other Considerations:**

* Memory usage: All three data structures have relatively low memory overhead for storing a small set of boolean values.
* Implementation complexity: Sets and maps are generally easier to implement than objects, especially when it comes to handling null or undefined keys.
* Browser support: The test results indicate that Chrome 129 is used as the testing browser. It's essential to consider other browsers and versions when comparing performance across different data structures.

**Alternative Approaches:**

If not using sets, objects, or maps, alternative approaches could include:

1. **Array**: Using a boolean array to store settings can be efficient, but may require more memory than the other options.
2. **Boolean flag**: Implementing a simple boolean flag system using a single variable can be very lightweight but might lead to slower performance due to branching and overhead.
3. **Custom data structure**: Depending on specific requirements, it's possible that a custom data structure could be designed to optimize for boolean referencing, potentially offering better performance than the existing options.

Keep in mind that this analysis is based on general knowledge of JavaScript data structures and their performance characteristics. The actual results may vary depending on the specific implementation, usage patterns, and browser versions.

Latest run results:

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

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

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Set	1695627.4 Ops/sec
Object	1547339.4 Ops/sec
Map	1740744.5 Ops/sec

Related benchmarks:

Set vs Object vs Map, Access (version: 0)

Compare the speed to retrieve a value from three data structures that can be used for boolean referencing; i.e. for mapping enabled settings.

Comparing performance of: Set vs Object vs Map

Created: one year ago by: Guest

Jump to the latest result

Set

Object

Map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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