Benchmark: Array.includes vs Set.has vas Map.has (string)

Script Preparation code:

const add = "0x5F9e5e051Ca77a6117171e068e4d2EEe00f1DDF5"
const len = 10
const arr = Array.apply(null, Array(len)).map(function(x, i) {
    return add + i.toString();
});

var firstElem = arr[0]
var midElem = arr[Math.floor(len/2)]
var lastElem = arr[len-1]
      
var a = arr;
var b = new Set(arr);
var c = new Map(arr.map(function(x) {
    return [x, x]
}));

Tests:

Array includes (first)
return a.includes(firstElem);
Set has (first)
return b.has(firstElem);
Map has (first)
return c.has(firstElem);
Array includes (mid)
return a.includes(midElem);
Set has (mid)
return b.has(midElem);
Map has (mid)
return c.has(midElem);
Array includes (last)
return a.includes(lastElem);
Set has (last)
return b.has(lastElem);
Map has (last)
return c.has(lastElem);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array includes (first)
Set has (first)
Map has (first)
Array includes (mid)
Set has (mid)
Map has (mid)
Array includes (last)
Set has (last)
Map has (last)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

Browser/OS: Chrome 120 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array includes (first)	15018375.0 Ops/sec
Set has (first)	10967130.0 Ops/sec
Map has (first)	10872117.0 Ops/sec
Array includes (mid)	8886254.0 Ops/sec
Set has (mid)	14200633.0 Ops/sec
Map has (mid)	14100850.0 Ops/sec
Array includes (last)	6651759.0 Ops/sec
Set has (last)	14112494.0 Ops/sec
Map has (last)	14016691.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is tested, compared options, pros and cons, and other considerations.

**Benchmark Overview**

The benchmark tests the performance of three data structures in JavaScript: `Array.includes()`, `Set.has()`, and `Map.has()` (or `Object.hasOwn()` in older browsers). The test creates a large array of strings and measures how long it takes to check if an element is present in the array using each of these methods.

**Data Structures Comparison**

The three data structures being tested are:

1. **Array.includes()**: This method checks if an element exists in an array.
2. **Set.has()**: This method checks if a value exists in a Set object, which is a collection of unique values.
3. **Map.has()**: This method checks if a key-value pair exists in a Map object (or uses `Object.hasOwn()` in older browsers). In this benchmark, the map contains only strings as keys.

**Options Compared**

The options being compared are:

1. **Array.includes()**
2. **Set.has()**
3. **Map.has()**

**Pros and Cons of Each Approach:**

1. **Array.includes():**
	* Pros:
		+ Fast and efficient for large arrays.
		+ Widely supported across browsers and JavaScript engines.
	* Cons:
		+ Can be slower than other methods for very small arrays or when searching for a specific element near the beginning of the array.
2. **Set.has():**
	* Pros:
		+ Fast and efficient for large Sets, especially when checking membership in a sorted Set.
		+ Good for hash-based data structures.
	* Cons:
		+ May be slower than Array.includes() for unsorted arrays or when searching for an element near the end of the array.
3. **Map.has():**
	* Pros:
		+ Fast and efficient for large Maps, especially when checking membership in a sorted Map.
		+ Good for key-value pairs with unique keys.
	* Cons:
		+ May be slower than Array.includes() or Set.has() for simple lookup operations.

**Other Considerations:**

1. **Cache locality**: When iterating over an array, modern JavaScript engines use cache locality to improve performance. This means that the engine can predict which elements are likely to be accessed next and prefetch them into the CPU's cache. In this benchmark, Array.includes() may benefit from cache locality due to its linear search pattern.
2. **Type coercion**: When using Set.has() or Map.has(), JavaScript must perform type coercion (i.e., convert the element being searched for to a comparable type). This can introduce additional overhead.

**Benchmark Results:**

The provided benchmark results show that Array.includes() tends to be faster than Set.has() and Map.has() across all test cases. However, these differences may become less pronounced as the size of the array increases or when using very small arrays. The results also indicate that older browsers (using `Object.hasOwn()`) can be slower than modern browsers (using `Map.has()`).

Related benchmarks:

Array.includes vs Set.has vas Map.has (string) (version: 0)

Comparing performance of: Array includes (first) vs Set has (first) vs Map has (first) vs Array includes (mid) vs Set has (mid) vs Map has (mid) vs Array includes (last) vs Set has (last) vs Map has (last)

Created: 10 months ago by: Guest

Jump to the latest result

Array includes (first)

Set has (first)

Map has (first)

Array includes (mid)

Set has (mid)

Map has (mid)

Array includes (last)

Set has (last)

Map has (last)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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