Benchmark: set vs array lookup

Script Preparation code:

arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Tests:

array
arr.includes(5)
set
const set = new Set(arr) set.has(5)

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

array

78.5M/s

set

5.3M/s

Fastest: array (14.7x faster)

View exact numbers

✓ array: 78,472,008 ops/sec
• set: 5,344,534 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array
set

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36

Browser/OS: Chrome 136 on Linux

View result in a separate tab

array

128.8M/s

set

9.4M/s

View exact numbers

Test name	Executions per second
✓ array	128,832,632 Ops/sec
set	9,381,509 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested.

**Benchmark Definition**

The benchmark definition is a JSON object that describes two test cases:

1. `arr.includes(5)`
2. `const set = new Set(arr) set.has(5)`

These tests are comparing two approaches to check if a value exists in an array (or a set).

**Options Compared**

The options being compared are:

* Array lookup using the `includes()` method
* Using a set data structure with the `has()` method

**Pros and Cons of Each Approach**

**Array Lookup using includes()**

Pros:

* Simple and straightforward implementation
* Widely supported by modern browsers
* Can be used for various array operations beyond just existence checks

Cons:

* May have performance overhead due to the search algorithm (linear scan)
* May not be suitable for very large arrays or datasets

**Set Data Structure with has()**

Pros:

* Fast lookups (constant time complexity) since sets use hash tables internally
* Suitable for large datasets and can improve performance in some cases

Cons:

* Requires additional memory to store the set
* Implementation may vary depending on the programming language or environment (e.g., JavaScript engines)

**Library: Set**

In this benchmark, the `Set` library is used to create a set from an array. A set data structure is a collection of unique values that are ordered in no particular order.

The purpose of using a set here is to demonstrate the trade-offs between array lookup and set-based lookups. While sets provide fast lookups, they require additional memory to store the set, which might be a concern for very large datasets.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntax mentioned in this benchmark.

**Other Alternatives**

If you're interested in exploring alternative approaches, here are some options:

* Using other data structures like `Map` (JavaScript's built-in Map object) or custom hash tables
* Implementing your own search algorithm for arrays
* Using a different programming language or environment that may provide better performance or features

Keep in mind that the choice of approach depends on the specific requirements and constraints of your project.

set vs array lookup (version: 0)

Comparing performance of: `array vs set`

Created: 2 years ago by: Registered User

Go to the latest result

array

set

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

set vs array lookup (version: 0)

Comparing performance of: array vs set

Created: 2 years ago by: Registered User

Go to the latest result

array

set

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `array vs set`