Benchmark: Set vs hasmap - MeasureThat.net

Script Preparation code:

var fooArr = [];
for(var i=0;i<10000;i++) {
  fooArr.push(i);
}

Tests:

Set duplication
var set = new Set(fooArr);
includes
var barArr = [] for(var i=0;i<fooArr.length;i++) { if (!barArr.includes(fooArr[i])) barArr.push(fooArr[i]) }
hasmap
var hashmap = new Map(); var barArr = [] for(var i=0;i<fooArr.length;i++) { if (!hashmap.has(fooArr[i])) { barArr.push(fooArr[i]); hashmap.set(fooArr[i], true); } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set duplication
includes
hasmap

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and benchmarking code to understand what is being tested.

**Benchmark Definition JSON:**

The JSON defines a benchmark with three test cases:

1. "Set duplication" - This test case creates a Set from an array `fooArr` and measures its performance.
2. "includes" - This test case uses the `includes()` method on the same array `fooArr` to check if each element exists in another array `barArr`.
3. "hasmap" - This test case creates a Map from the same array `fooArr` (using a different approach) and measures its performance.

**Script Preparation Code:**

The script preparation code is used to create an array `fooArr` with 10,000 elements, populated with numbers from 0 to 9,999. This array will be used in all three test cases.

**Html Preparation Code:**

There is no HTML preparation code provided, which means that the benchmarking is performed solely on JavaScript execution.

**Test Cases:**

Now, let's analyze each test case:

1. **Set Duplication:**
	* Creates a new Set `set` from the array `fooArr`.
	* This operation has a time complexity of O(n), where n is the size of the set (which is typically much smaller than the original array).
	* Pros:
		+ Efficient use of memory, as sets only store unique values.
		+ Fast lookup and insertion times due to its hash-based implementation.
	* Cons:
		+ May not be suitable for large datasets, as it can consume significant memory.
2. **Includes:**
	* Creates an empty array `barArr` and populates it with elements from the original array `fooArr`, using the `includes()` method to check if each element already exists in the array.
	* This operation has a time complexity of O(n^2), where n is the size of the array, because the `includes()` method performs a linear search for each added element.
	* Pros:
		+ Can be used with large datasets, as it does not require storing all elements in memory.
	* Cons:
		+ Slow performance due to the O(n^2) complexity.
3. **Hasmap:**
	* Creates an empty Map `hashmap` and populates it with key-value pairs from the original array `fooArr`.
	* This operation has a time complexity of O(1), on average, for insertions and lookups, because Maps use hash tables to store their data.
	* Pros:
		+ Fast lookup and insertion times due to its hash-based implementation.
	* Cons:
		+ May not be suitable for large datasets, as it can consume significant memory.

**Libraries and Features:**

None of the test cases explicitly use any libraries. However, they do utilize built-in JavaScript features:

1. Sets (introduced in ECMAScript 2015)
2. Maps (introduced in ECMAScript 2015)
3. The `includes()` method (introduced in ECMAScript 2015)

**Other Alternatives:**

If you wanted to create a similar benchmark, you could use other data structures like:

1. Linked lists
2. Trees (e.g., binary search trees or AVL trees)
3. Hash tables (not necessarily Maps or Sets)
4. Array-based implementations with custom search and insertion algorithms

Keep in mind that the choice of data structure and algorithm depends on the specific requirements of your benchmarking scenario.

In general, when working with large datasets, you may want to consider the following:

1. Use efficient data structures like Sets, Maps, or optimized hash tables.
2. Optimize for lookup and insertion times, as these operations can dominate performance in many scenarios.
3. Consider memory usage and fragmentation, especially when dealing with large datasets.

I hope this explanation helps! Let me know if you have any further questions.

Related benchmarks:

Set vs hasmap (version: 0)

Comparing performance of: Set duplication vs includes vs hasmap

Created: 4 years ago by: Registered User

Jump to the latest result

Set duplication

includes

hasmap

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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