Benchmark: Set vs Object vs Map a4vw343v43

Tests:

Set
var set = new Set(["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"]); set.add("eleven"); if(set.has("seven")){};
Object
var set = {"one": null, "two": null, "three": null, "four": null, "five": null, "six": null, "seven": null, "eight": null, "nine": null, "ten": null}; set["eleven"] = null; if(set["seven"]!== undefined){};
Map
var set = new Map([["one", null], ["two", null], ["three", null], ["four", null], ["five", null], ["six", null], ["seven", null], ["eight", null], ["nine", null], ["ten", null]]); set.set("eleven", null); if (set.get("seven") !== undefined){};

Historical Performance Data aggregated from 13 community runs

Desktop Results:

Chrome 13 runs

Object

183.5M/s

Set

6.4M/s

Map

4.3M/s

Fastest: Object (43.0x faster)

View exact numbers

✓ Object: 183,454,880 ops/sec
• Set: 6,352,754 ops/sec
• Map: 4,265,877 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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

Latest run results:

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

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

Browser/OS: Chrome 153 on Windows

View result in a separate tab

Object

999.2M/s

Set

5.9M/s

Map

3.6M/s

View exact numbers

Test name	Executions per second
✓ Object	999,231,360 Ops/sec
Set	5,916,906 Ops/sec
Map	3,566,940 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The benchmark being measured is the performance difference between using a `Set`, an `Object`, and a `Map` data structure in JavaScript to store and retrieve elements.

**Options Compared:**

1. **Set**: A collection of unique values, ordered or unordered, with fast lookups.
2. **Object**: An unordered collection of key-value pairs, where keys are strings and values can be any type.
3. **Map**: An unordered collection of key-value pairs, similar to an Object, but with additional methods for manipulating the key-value pairs.

**Pros and Cons:**

* **Set**:
	+ Pros: Fast lookups (O(1)), efficient insertion and removal of elements.
	+ Cons: Limited functionality compared to Objects and Maps, can only store unique values.
* **Object**:
	+ Pros: Flexible data structure, can store any type of value, allows for nested objects.
	+ Cons: Slower lookups compared to Sets (O(1) on average), more overhead due to the need to manage properties.
* **Map**:
	+ Pros: Fast lookups (O(1)), efficient insertion and removal of elements, additional methods for manipulating key-value pairs.
	+ Cons: Less familiar API than Objects, requires more memory due to the need to store keys.

The choice of data structure depends on the specific use case. If you only need to store unique values and perform fast lookups, a `Set` might be the best choice. For more flexible data structures with nested objects or complex key-value pairs, an `Object` or `Map` might be more suitable.

**Library Used:**

None explicitly mentioned in the benchmark definition. However, it's likely that JavaScript's built-in `Set`, `Object`, and `Map` constructors are used under the hood.

**Special JS Features/Syntax:**

None explicitly mentioned in the benchmark definition.

**Other Alternatives:**

1. **Array**: While not as flexible as Sets or Objects, Arrays can be used to store collections of values with fast lookups (O(1)).
2. **WeakSet**, `WeakMap`: These are similar to Sets and Maps but allow for weak references, which can be useful in certain scenarios.
3. **Sparse arrays**: Some modern JavaScript engines (e.g., V8) support sparse arrays, which are arrays that don't store the index values of missing elements.

In summary, this benchmark measures the performance difference between using `Set`, `Object`, and `Map` data structures in JavaScript for storing and retrieving elements. The choice of data structure depends on the specific use case and the desired trade-offs between performance, flexibility, and memory usage.

Set vs Object vs Map a4vw343v43 (version: 0) Benchmark.js

Comparing performance of: `Set vs Object vs Map`

Created: 4 years ago by: Guest

Go to the latest result

Set

Object

Map

Historical Performance Data aggregated from 13 community runs

Desktop Results:

Chrome 13 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Set vs Object vs Map a4vw343v43 (version: 0) Benchmark.js

Comparing performance of: Set vs Object vs Map

Created: 4 years ago by: Guest

Go to the latest result

Set

Object

Map

Historical Performance Data aggregated from 13 community runs

Desktop Results:

Chrome 13 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `Set vs Object vs Map`