Benchmark: array.includes vs array.indexOf vs set.has vs weakSet.has

Script Preparation code:

var array = []
var set = new Set()
var weakSet = new WeakSet()

var target = {}

let i = 100
while (i--) {
    array.push({})
	set.add({})
    weakSet.add({})
}

array.push(target)
set.add(target)
weakSet.add(target)

Tests:

array.includes
array.includes(target)
array.indexOf
array.indexOf(target)
set.has
set.has(target)
weakSet.has
weakSet.has(target)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array.includes
array.indexOf
set.has
weakSet.has

Fastest: N/A

Slowest: N/A

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/114.0.0.0 Safari/537.36 Edg/114.0.1823.43

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
array.includes	7769461.5 Ops/sec
array.indexOf	7827950.5 Ops/sec
set.has	8893302.0 Ops/sec
weakSet.has	8865175.0 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark measures the performance of four different methods to check for the presence of an element in various data structures:

1. `array.includes(target)`: checks if the `target` object is present in an array.
2. `array.indexOf(target)`: returns the index of the first occurrence of the `target` object in an array, or -1 if not found.
3. `set.has(target)`: checks if the `target` object is present in a Set data structure.
4. `weakSet.has(target)`: checks if the `target` object is present in a WeakSet data structure.

**Options Compared**

The benchmark compares the performance of these four methods on arrays and Sets, which are two fundamental data structures in JavaScript.

**Pros and Cons of Different Approaches:**

1. **`array.includes(target)`**: This method has a time complexity of O(n), where n is the length of the array. However, it can be optimized to have a linear search by using a hash table (e.g., `Map`) to store the elements of the array.
2. **`array.indexOf(target)`**: This method also has a time complexity of O(n) and requires an exhaustive search for each element in the array. However, it returns the index of the first occurrence, which can be useful in some cases.
3. **`set.has(target)`**: This method has an average time complexity of O(1), making it much faster than `array.includes()` or `array.indexOf()`. Sets are implemented as hash tables, allowing for efficient lookups.
4. **`weakSet.has(target)`**: Similar to a regular Set, but WeakSets store only weak references, which can be useful in cases where the object being stored may not prevent its garbage collection.

**Library and Its Purpose**

In this benchmark, no external libraries are used. However, if you were to use a library like Lodash or Ramda, you might use functions like `_.includes()` or `R.includes()` to achieve similar results.

**Special JS Features or Syntax:**

There are no special JavaScript features or syntax explicitly mentioned in the provided code snippets.

**Other Alternatives:**

For comparing performance, other alternatives include:

1. **Benchmarking libraries**: Such as Benchmark.js, which provides a simple way to create and run benchmarks.
2. **Browser benchmarking tools**: Like Chrome DevTools' Benchmarking panel, which allows you to create and run benchmarks directly in the browser.

Keep in mind that these alternatives may have additional features or complexity compared to the provided JSON and benchmark code.

Related benchmarks:

array.includes vs array.indexOf vs set.has vs weakSet.has (version: 0)

Comparing performance of: array.includes vs array.indexOf vs set.has vs weakSet.has

Created: one year ago by: Registered User

Jump to the latest result

array.includes

array.indexOf

set.has

weakSet.has

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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