Benchmark: list includes vs set has

Tests:

get from list nope
[470, 364, 173, 535, 140, 374, 442, 64, 245, 69, 323, 155, 529, 405, 131, 431, 445, 281, 164, 576].includes(51)
get from list last
[470, 364, 173, 535, 140, 374, 442, 64, 245, 69, 323, 155, 529, 405, 131, 431, 445, 281, 164, 576].includes(576)
get from list first
[470, 364, 173, 535, 140, 374, 442, 64, 245, 69, 323, 155, 529, 405, 131, 431, 445, 281, 164, 576].includes(470)
get from set nope
new Set([470,364,173,535,140,374,442,64,245,69,323,155,529,405,131,431,445,281,164,576]).has(51)
get from set last
new Set([470,364,173,535,140,374,442,64,245,69,323,155,529,405,131,431,445,281,164,576]).has(576)
get from set first
new Set([470,364,173,535,140,374,442,64,245,69,323,155,529,405,131,431,445,281,164,576]).has(470)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
get from list nope
get from list last
get from list first
get from set nope
get from set last
get from set first

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark definition and test cases.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark that tests the performance of two different data structures: arrays (lists) and Sets. The benchmark measures the time it takes to perform lookups in these data structures using three different methods:

1. `includes()` method for arrays
2. `has()` method for Sets

**Options compared**

The options being compared are:

* Using `includes()` vs `has()` for array-based lookups
* Searching from start (`first`) vs end (`last`) of the array for a specific element using `includes()`

**Pros and cons of each approach:**

1. **Arrays (lists)**
	* `includes()` method:
		+ Pros: widely supported, easy to use, allows searching from start/end.
		+ Cons: has to iterate through the entire array, can be slower for large datasets.
2. **Sets**
	* `has()` method:
		+ Pros: faster lookup times since sets are typically implemented as hash tables, reducing the need for iteration.
		+ Cons: not all browsers support Sets or `has()` method, and some might have slightly different implementation details.

**Other considerations:**

* The benchmark uses a specific JavaScript version ( likely modern versions) which ensures consistent behavior across different browser implementations.
* The use of WebAssembly (WASM) in the test cases suggests that the results are representative for systems running WASM-based browsers like Blink, as well as other JavaScript engines that support it.

**Library and its purpose:**

The `Set` data structure is a built-in JavaScript object, introduced in ECMAScript 2015. It provides an efficient way to store unique values and perform membership tests using the `has()` method.

**Special JS feature or syntax:**

There are no special features or syntax mentioned explicitly, but it's worth noting that some older browsers might not support modern JavaScript features like Sets. The use of WebAssembly (WASM) in the test cases helps to mitigate this issue, as WASM allows for platform-agnostic execution.

**Alternatives:**

Other alternatives could include:

* Using `find()` method with a callback function instead of `includes()`
* Implementing custom search algorithms or data structures (e.g., balanced binary search trees)
* Utilizing other libraries or frameworks that provide optimized data structure implementations

Keep in mind that these alternatives might not be suitable for production environments, and the provided benchmark provides a good starting point for evaluating performance differences between these options.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 111 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
get from list nope	1042769152.0 Ops/sec
get from list last	1042511616.0 Ops/sec
get from list first	1039321216.0 Ops/sec
get from set nope	2542316.2 Ops/sec
get from set last	2543142.5 Ops/sec
get from set first	2541528.5 Ops/sec

Related benchmarks:

list includes vs set has (version: 0)

Comparing performance of: get from list nope vs get from list last vs get from list first vs get from set nope vs get from set last vs get from set first

Created: one year ago by: Guest

Jump to the latest result

get from list nope

get from list last

get from list first

get from set nope

get from set last

get from set first

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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