Benchmark: set.has vs. array.includes 1000

Script Preparation code:

var a = [];
for (var i = 0; i < 1000; i++)
  a[i] = i;
var b = new Set(a)

Tests:

includes
return a.includes(900)
lookup
return b.has(900)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
lookup

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 12; RMX3363) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 101 on Android

View result in a separate tab

Test name	Executions per second
includes	240698.1 Ops/sec
lookup	1434139.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark.

**What is tested on the provided JSON?**

The provided JSON represents two test cases for a JavaScript microbenchmarking scenario. The tests are designed to compare the performance of `Array.prototype.includes()` and `Set.prototype.has()`, both used to check if an element exists within a specific array or set, respectively.

**Options compared:**

1. `Array.prototype.includes()` vs. `Set.prototype.has()`
2. `lookup` (uses `b.has(900)`) vs. `includes` (uses `a.includes(900)`)

**Pros and cons of each approach:**

1. **Using Array.prototype.includes()**
	* Pros:
		+ More widely supported across browsers and JavaScript versions.
		+ Familiar to many developers, making it easier to optimize.
	* Cons:
		+ Can be slower for large arrays due to the need to linearly search through the array elements.
2. **Using Set.prototype.has()**
	* Pros:
		+ Faster lookup times compared to `Array.prototype.includes()` for large datasets.
		+ More efficient use of memory, as sets only store unique values.
	* Cons:
		+ Less widely supported across browsers and JavaScript versions (although support has improved in recent years).
		+ Requires creating a set from the array elements, which can be an additional overhead.

**Library and purpose:**

The `Set` object is a built-in JavaScript data structure that stores unique values. It's used here to simulate a set for fast lookup of element existence. The `Array.prototype.includes()` method is also a built-in JavaScript method that checks if an element exists within the array.

**Special JS feature or syntax:**

None mentioned in this specific benchmark.

**Other alternatives:**

For large datasets, alternative approaches can be explored:

1. **Using a Map**: A map data structure can provide faster lookup times than arrays for some use cases.
2. **Using a SortedArray**: Some libraries and implementations offer sorted array data structures that can enable faster lookup times using binary search.

In the context of this benchmark, Set.prototype.has() is likely to be faster due to its optimized implementation for fast lookups. However, for smaller datasets or specific requirements, Array.prototype.includes() might still be a suitable choice.

**Benchmark preparation code:**

The script preparation code creates an array `a` with 1000 elements and then creates a set `b` from that array using the spread operator (`var b = new Set(a)`). This setup ensures that both tests are operating on the same dataset, allowing for accurate comparisons between `Array.prototype.includes()` and `Set.prototype.has()`.

Related benchmarks:

set.has vs. array.includes 1000 (version: 0)

Comparing performance of: includes vs lookup

Created: 2 years ago by: Guest

Jump to the latest result

includes

lookup

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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