Benchmark: Set has vs object key reversed

Script Preparation code:

var obj = (new Array(1000)).fill(null).reduce((prev, newVal) => {prev[Math.random() + ''] = Math.random() + ''; return prev; }, { sausage: 'tst' });
var array = Object.keys(obj).reverse();
var set = new Set(array);

Tests:

Includes
array.includes('sausage')
Object[key]
obj['sausage']
Set.has
set.has('saudage')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Includes
Object[key]
Set.has

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 121 on Android

View result in a separate tab

Object[key]

5.3M/s

Set.has

4.5M/s

Includes

369K/s

View exact numbers

Test name	Executions per second
✓ Object[key]	5,299,131 Ops/sec
Set.has	4,516,372 Ops/sec
Includes	369,331 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.

**Benchmark Definition**

The provided JSON represents a benchmark definition, which defines three test cases:

1. `Set has vs object key reversed`: This test case compares the performance of three approaches to check if an array contains a value.
	* Approach 1: `array.includes('sausage')`
	* Approach 2: `obj['sausage']` (accessing an object property using a bracket notation)
	* Approach 3: `set.has('saudage')` (checking if a Set contains a value using the `has()` method)
2. `Includes`: This test case measures the performance of the `array.includes('sausage')` approach.
3. `Object[key]`: This test case measures the performance of the `obj['sausage']` approach.

**Options Compared**

The three approaches compared in the first test case are:

* **Approach 1: `array.includes()`**: This method checks if a specified value is present in the array. It uses binary search to find the value, which has an average time complexity of O(log n).
* **Approach 2: `obj['sausage']`**: This method accesses an object property using bracket notation. The JavaScript engine needs to look up the property in the object's prototype chain and then perform a lookup in the object itself. This approach has a variable time complexity, depending on the number of properties in the object.
* **Approach 3: `set.has()`**: This method checks if a specified value is present in the Set. It uses a hash table to store the elements and performs a constant-time lookup. The average time complexity of this approach is O(1).

**Pros and Cons**

Here's a summary of the pros and cons of each approach:

* **Approach 1: `array.includes()`**
	+ Pros: Fast and efficient, especially for large arrays.
	+ Cons: May not be suitable for very small arrays or arrays with a limited number of unique values.
* **Approach 2: `obj['sausage']`**
	+ Pros: Can be useful when working with objects that have a specific structure.
	+ Cons: Has a variable time complexity, which can lead to performance issues if the object is too large or has many properties.
* **Approach 3: `set.has()`**
	+ Pros: Fast and efficient, especially for sets with a large number of unique values.
	+ Cons: May not be suitable for situations where you need to iterate over all elements in the set.

**Library Usage**

The benchmark uses the `Set` object, which is a built-in JavaScript object that stores unique values. The `has()` method is used to check if a value is present in the Set.

**Special JS Features/Syntax**

None of the benchmarks use any special JavaScript features or syntax.

**Other Alternatives**

If you're interested in exploring alternative approaches for checking if an array contains a value, here are some other options:

* Using `indexOf()` method: This method returns the index of the specified value, or -1 if the value is not found. This approach has a time complexity of O(n), where n is the length of the array.
* Using a custom loop: You can write a simple loop to iterate over the array and check for the presence of the specified value. This approach also has a time complexity of O(n).

However, keep in mind that these alternative approaches may not be as efficient or scalable as the methods used in the benchmark.

Set has vs object key reversed (version: 0)

performance comparison of ways to find if an array contains a value

Comparing performance of: `Includes vs Object[key] vs Set.has`

Created: 2 years ago by: Guest

Go to the latest result

Includes

Object[key]

Set.has

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Set has vs object key reversed (version: 0)

performance comparison of ways to find if an array contains a value

Comparing performance of: Includes vs Object[key] vs Set.has

Created: 2 years ago by: Guest

Go to the latest result

Includes

Object[key]

Set.has

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: `Includes vs Object[key] vs Set.has`