Benchmark: Set vs Object vs Map doing stuff with clones

Tests:

Set

const set = new Set();
for (let i = 0; i < 1000; ++i) {
  set.add(`key_${i}`);
}
let result = 0;
for (let j = 0; j < 100; ++j) {
  const clone = new Set(set);
  for (let k = -500; k < 500; ++k) {
    result += clone.has(`key_${k}`);
  }
}
console.log(result);

AخA
 
const set = new Set();for (let i = 0; i < 1000; ++i) {  set.add(`key_${i}`);}let result = 0;for (let j = 0; j < 100; ++j) {  const clone = new Set(set);  for (let k = -500; k < 500; ++k) {    result += clone.has(`key_${k}`);  }}console.log(result);

Object

const obj = {};
for (let i = 0; i < 1000; ++i) {
  obj[`key_${i}`] = true;
}
let result = 0;
for (let j = 0; j < 100; ++j) {
  const clone = {...obj};
  for (let k = -500; k < 500; ++k) {
    result += clone.hasOwnProperty(`key_${k}`);
  }
}
console.log(result);

 
const obj = {};for (let i = 0; i < 1000; ++i) {  obj[`key_${i}`] = true;}let result = 0;for (let j = 0; j < 100; ++j) {  const clone = {...obj};  for (let k = -500; k < 500; ++k) {    result += clone.hasOwnProperty(`key_${k}`);  }}console.log(result);

Map

const map = new Map();
for (let i = 0; i < 1000; ++i) {
  map.set(`key_${i}`, true);
}
let result = 0;
for (let j = 0; j < 100; ++j) {
  const clone = new Map(map);
  for (let k = -500; k < 500; ++k) {
    result += clone.get(`key_${k}`);
  }
}
console.log(result);

 
const map = new Map();for (let i = 0; i < 1000; ++i) {  map.set(`key_${i}`, true);}let result = 0;for (let j = 0; j < 100; ++j) {  const clone = new Map(map);  for (let k = -500; k < 500; ++k) {    result += clone.get(`key_${k}`);  }}console.log(result);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Set
Object
Map

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Linux

View result in a separate tab

Test name	Executions per second
Set	298.2 Ops/sec
Object	48.3 Ops/sec
Map	148.5 Ops/sec

Autogenerated LLM Summary (model gemma2:9b, generated 4 months ago):

This benchmark compares the performance of three different data structures (Set, Object, and Map) when performing similar tasks involving cloning and membership checking.

Here's a breakdown:

Objective: The benchmark aims to measure how efficiently each data structure can create clones and check for the existence of keys within those clones.
Test Setup:
- Each test case creates a set, object, or map with 1000 initial key-value pairs (key_0 to key_999).
- Then, it iterates 100 times. In each iteration:
  - A clone of the original data structure is created.
  - The code checks if a series of keys (key_-500 to key_499) exist within the clone using either has() (for Set), hasOwnProperty() (for Object), or get() (for Map).
Options Compared:
- Set: A collection designed for unique values, optimized for membership checks.
- Object: A flexible key-value store with dynamic property addition.
- Map: A more modern key-value store that offers better performance for large datasets and supports various data types as keys and values.

Pros/Cons & Considerations:

Data Structure	Pros	Cons	Other Considerations
Set	Fast `has()` operation, efficient for uniqueness checks.	Doesn't support additional data types as values (just boolean).	Not ideal for complex key-value relationships or when order matters.
Object	Flexible, allows dynamic property addition.	Can be slow for large datasets, potential performance issues with numerous property accesses.	Use `hasOwnProperty()` to accurately check for keys.
Map	Excellent performance for large datasets, supports various data types as keys and values, maintains insertion order.	More complex syntax than `Object`.	Best choice when you need key-value pairs with diverse data types and efficient retrieval.

Alternatives: Consider a library like Lodash (_.cloneDeep()) or Underscore.js for more robust cloning operations if you need finer control over the cloning process.

Let me know if you have any other questions!

LLMs can make mistakes. Check important info.

This benchmark compares the performance of three different data structures (`Set`, `Object`, and `Map`) when performing similar tasks involving cloning and membership checking.

**Here's a breakdown:**

* **Objective:**  The benchmark aims to measure how efficiently each data structure can create clones and check for the existence of keys within those clones.
* **Test Setup:**
    * Each test case creates a set, object, or map with 1000 initial key-value pairs (`key_0` to `key_999`).
    * Then, it iterates 100 times. In each iteration:
        * A clone of the original data structure is created.
        * The code checks if a series of keys (`key_-500` to `key_499`) exist within the clone using either `has()` (for `Set`), `hasOwnProperty()` (for `Object`), or `get()` (for `Map`).

* **Options Compared:**
    * **Set:**  A collection designed for unique values, optimized for membership checks.
    * **Object:** A flexible key-value store with dynamic property addition. 
    * **Map:** A more modern key-value store that offers better performance for large datasets and supports various data types as keys and values.

**Pros/Cons & Considerations:**

| Data Structure | Pros                                    | Cons                                          | Other Considerations                                       |
|-----------------|-------------------------------------------|----------------------------------------------|---------------------------------------------------------------|
| **Set**         |  Fast `has()` operation, efficient for uniqueness checks.       | Doesn't support additional data types as values (just boolean). | Not ideal for complex key-value relationships or when order matters. |
| **Object**      | Flexible, allows dynamic property addition.        | Can be slow for large datasets, potential performance issues with numerous property accesses. |  Use `hasOwnProperty()` to accurately check for keys. |
| **Map**         | Excellent performance for large datasets, supports various data types as keys and values, maintains insertion order.       | More complex syntax than `Object`.                    | Best choice when you need key-value pairs with diverse data types and efficient retrieval.

* **Alternatives:**  Consider a library like Lodash (`_.cloneDeep()`) or Underscore.js for more robust cloning operations if you need finer control over the cloning process.

Let me know if you have any other questions!

Related benchmarks:

Set vs Object vs Map doing stuff with clones (version: 0)

Comparing performance of: Set vs Object vs Map

Created: 3 years ago by: Guest

Jump to the latest result

Set