Benchmark: Has Objects vs Sets

Script Preparation code:

const set = new Set();
const obj = {};

const length = 5000;

for (let i = 0; i < length; i++) {
  set.add(i);
  obj[i] = true;
}

Tests:

Set
let bool; for (let i = 0; i < length * 2; i++) { bool = set.has(i); }
Obj
let bool; for (let i = 0; i < length * 2; i++) { bool = obj[i]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set
Obj

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript microbenchmark test case on the MeasureThat.net website. The benchmark tests two approaches: using a Set data structure and using an object.

**Options being compared:**

1. Using a Set data structure
2. Using an object (specifically, an object with numeric keys)

**Pros and Cons of each approach:**

Using a Set data structure:

Pros:

* Sets are optimized for fast membership testing, making them suitable for large datasets.
* They use less memory than objects when storing unique values.

Cons:

* Sets do not allow direct indexing like objects, which can impact performance in certain scenarios.
* When using a Set, you need to convert the value to a string or number before adding it, which can be slower than simply assigning a value to an object key.

Using an object (specifically, an object with numeric keys):

Pros:

* Objects allow direct indexing, making them suitable for large datasets where you need to access values by index.
* Assigning a value to an object key is generally faster than adding an element to a Set.

Cons:

* Objects use more memory than Sets when storing unique values.
* Membership testing in objects can be slower than in Sets due to the need to traverse the object's keys and values.

**Library usage:**

In this benchmark, no libraries are used explicitly. However, it's worth noting that the Set data structure is a native JavaScript built-in, while objects require the use of the `in` operator or bracket notation to access properties.

**Special JS features or syntax:**

None mentioned in the provided JSON.

**Benchmark preparation code analysis:**

The script preparation code creates a Set and an object, both with 5000 elements. The script then populates these data structures by iterating over a range of numbers and adding each number to the Set and assigning it as a key-value pair in the object.

The HTML preparation code is empty, which suggests that this benchmark does not rely on any specific HTML or DOM-related factors.

**Other alternatives:**

1. Using an array instead of a Set or object.
2. Using other data structures like Maps (JavaScript's native Map implementation) or custom implementations like hash tables.
3. Using different indexing methods, such as using `Math.random()` to generate random indices for elements in the Set or object.

Keep in mind that the specific alternatives will depend on the requirements and constraints of your use case.

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/103.0.0.0 Safari/537.36

Browser/OS: Chrome 103 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Set	4009624.0 Ops/sec
Obj	4018201.2 Ops/sec

Related benchmarks:

Has Objects vs Sets (version: 0)

Comparing performance of: Set vs Obj

Created: 2 years ago by: Guest

Jump to the latest result

Set

Obj

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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