Benchmark: set.has vs. array.includes for 1000 elements

Script Preparation code:

var a = Array(1000).fill(null).map((__, i) => i)
var b = new Set(Array(1000).fill(null).map((__, i) => i))

Tests:

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

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: 9 days ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
includes	75114432.0 Ops/sec
lookup	70730664.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of what's being tested in this benchmark.

**Benchmark Definition**

The provided JSON represents a JavaScript microbenchmark, specifically comparing two approaches: `array.includes` and `Set.has`. The benchmark aims to measure which method is faster for checking if an element (in this case, the number 9) exists within a large array or set of 1000 elements.

**Options Compared**

Two options are being compared:

1. **Array.includes**: This method checks if an element exists in the array by iterating through its length and comparing each element to the target value.
2. **Set.has**: This method uses a data structure called a Set, which is optimized for fast membership testing. When you call `has` on a Set, it essentially asks the question "do I have this element in my set?", which can be answered quickly by examining the internal data structure of the Set.

**Pros and Cons**

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

* **Array.includes**:
	+ Pros: Simple to implement and widely supported.
	+ Cons: Has to iterate through the entire array, making it slower for large datasets.
* **Set.has**:
	+ Pros: Much faster for membership testing, especially with large datasets.
	+ Cons: Requires a Set data structure, which might not be familiar to all developers.

In general, if you need to perform fast membership testing on large datasets, using a Set is the way to go. However, if simplicity and wide support are more important than raw performance, `array.includes` might still be the better choice.

**Library Used**

The benchmark uses the JavaScript built-in `Set` data structure, which is part of the ECMAScript standard (as of ECMAScript 2015). The Set data structure provides fast membership testing and other useful methods for working with collections of unique values.

**Special JS Feature or Syntax**

There's no special JavaScript feature or syntax being used in this benchmark. It's a straightforward comparison of two existing methods using the JavaScript language.

**Other Alternatives**

If you're looking for alternative approaches, here are a few:

* For membership testing on large datasets, you could consider using a data structure like a `Map`, which is similar to a Set but provides additional lookup methods.
* If you need to perform more complex membership tests (e.g., checking if an element exists in multiple arrays or sets), you might want to explore other libraries or frameworks that provide specialized functions for these tasks.

Keep in mind that the choice of data structure and implementation will depend on your specific use case, performance requirements, and familiarity with JavaScript.

Related benchmarks:

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

Comparing performance of: includes vs lookup

Created: one year 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 2 months ago):