Benchmark: set.has vs. array.includes vs obj[key] vs map.get 2

Script Preparation code:

function shuffle(array) {
  let currentIndex = array.length,  randomIndex;

  // While there remain elements to shuffle...
  while (currentIndex != 0) {

    // Pick a remaining element...
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex--;

    // And swap it with the current element.
    [array[currentIndex], array[randomIndex]] = [
      array[randomIndex], array[currentIndex]];
  }

  return array;
}

var a = shuffle(Array(100000).fill(undefined).map((_, i) => i));
var b = a.reduce((acc, el) => { acc[el] = true; return acc }, {});
var c = new Set(a);
var d = new Map(a.map(el => [el, true]));
var elements = [1, 100, 1000, 24, 56, 78, 23, 5643, 863, 2679, 9999, 45, 5832, 7510, 3756];

Tests:

includes
return elements.map(el => a.includes(el))
hash
return elements.map(el => b[el])
set
return elements.map(el => c.has(el))
map
return elements.map(el => d.get(el))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
hash
set
map

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 2 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what is tested on the website, along with the pros and cons of different approaches.

**Benchmark Definition**

The benchmark defines four test cases:

1. `set.has`
2. `array.includes`
3. `obj[key]` (assuming an object `a` created using the `shuffle` function)
4. `map.get`

These tests compare the performance of four different data structures and methods to check for membership in a list: Sets, arrays, objects, and Maps.

**Data Structures and Methods**

Here's what each test case checks:

1. `set.has`: Checks if an element is present in a Set.
2. `array.includes`: Checks if an element is present in an array using the `includes` method.
3. `obj[key]`: Checks if an element is present in an object by accessing its key-value pair using bracket notation (`obj[key]`). (Note: This assumes that the object `a` has been shuffled and populated with unique elements.)
4. `map.get`: Checks if an element is present in a Map.

**Options Compared**

The benchmark compares the performance of these four approaches:

* **Sets**: A data structure that stores unique values. It provides fast membership testing.
* **Arrays**: A data structure that stores ordered collections of values. The `includes` method is used for membership testing.
* **Objects**: A data structure that stores key-value pairs. Bracket notation (`obj[key]`) is used to access elements by their keys.
* **Maps**: A data structure that stores key-value pairs with fast lookup times.

**Pros and Cons**

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

1. **Sets**:
	* Pros: Fast membership testing, good cache locality.
	* Cons: May not be suitable for all use cases (e.g., when elements need to be ordered or have multiple keys).
2. **Arrays**:
	* Pros: Easy to implement and understand, good for ordered data.
	* Cons: Membership testing can be slower than Sets due to the `includes` method's implementation.
3. **Objects**:
	* Pros: Convenient for accessing elements by their names (keys), easy to implement.
	* Cons: Slow membership testing due to bracket notation's overhead.
4. **Maps**:
	* Pros: Fast lookup times, convenient access to values using keys.
	* Cons: May not be suitable for all use cases (e.g., when elements need to be ordered).

**Library and Special Features**

The benchmark uses the `shuffle` function from the Lodash library to shuffle an array of unique elements. It also assumes that the object `a` has been created using this shuffled array.

No special features or syntax are used in this benchmark.

**Alternatives**

If you're looking for alternatives to these approaches, consider:

* Using a `Set` data structure instead of an array for fast membership testing.
* Implementing your own `includes` method on arrays or objects for better performance.
* Using a library like Lodash or Ramda that provides optimized implementations of these functions.

Keep in mind that the choice of approach depends on your specific use case and requirements.

Latest run results:

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

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

Browser/OS: Chrome 96 on Windows

View result in a separate tab

Test name	Executions per second
includes	1118.2 Ops/sec
hash	881811.9 Ops/sec
set	776648.6 Ops/sec
map	750669.1 Ops/sec

Related benchmarks:

set.has vs. array.includes vs obj[key] vs map.get 2 (version: 0)

Comparing performance of: includes vs hash vs set vs map

Created: 2 years ago by: Guest

Jump to the latest result

includes

hash

set

map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 2 days ago):