Benchmark: Array.includes() vs Set.has()

Array.includes() vs Set.has() (version: 0)

Comparing performance of: Array.includes, 10 000 elements vs Array.includes, 1 000 000 elements vs Set.has, 10 000 elements vs Set.has, 1 000 000 elements vs Array to Set + Set.has, 10 000 elements vs Array to Set + Set.has x 100, 10 000 elements vs Array.includes x 100, 10 000 elements

Created: 2 years ago by: Registered User

Jump to the latest result

Script Preparation code:

function getArray(length) {
  const result = [];
  for (let i = 0; i < length; i++) {
    result.push(i + 'abc'); // In case the browser does some sort of optimization for arrays with only integers ¯\_(ツ)_/¯
  }
  return result;
}

function getRandomTargetElement(arrayLength) {
  const index = Math.floor(Math.random() * arrayLength);
  return index + 'abc';
}


array_small = getArray(10000);
array_large = getArray(1000000);

set_small = new Set(array_small);
set_large = new Set(array_large);

​x
 
function getArray(length) {  const result = [];  for (let i = 0; i < length; i++) {    result.push(i + 'abc'); // In case the browser does some sort of optimization for arrays with only integers ¯\_(ツ)_/¯  }  return result;}​function getRandomTargetElement(arrayLength) {  const index = Math.floor(Math.random() * arrayLength);  return index + 'abc';}​​array_small = getArray(10000);array_large = getArray(1000000);​set_small = new Set(array_small);set_large = new Set(array_large);​

Tests:

Array.includes, 10 000 elements
array_small.includes(getRandomTargetElement(10000));
array_small.includes(getRandomTargetElement(10000));
Array.includes, 1 000 000 elements
array_large.includes(getRandomTargetElement(1000000))
array_large.includes(getRandomTargetElement(1000000))
Set.has, 10 000 elements
set_small.has(getRandomTargetElement(10000))
set_small.has(getRandomTargetElement(10000))
Set.has, 1 000 000 elements
set_large.has(getRandomTargetElement(1000000))
set_large.has(getRandomTargetElement(1000000))
Array to Set + Set.has, 10 000 elements
const target = getRandomTargetElement(10000); const set = new Set(array_small); set.has(target)
const target = getRandomTargetElement(10000);
const set = new Set(array_small);
set.has(target)
Array to Set + Set.has x 100, 10 000 elements
const set = new Set(array_small); for (let i = 0; i < 100; i++) { const target = getRandomTargetElement(10000); set.has(target) }
const set = new Set(array_small);
for (let i = 0; i < 100; i++) {
const target = getRandomTargetElement(10000);
set.has(target)
}
Array.includes x 100, 10 000 elements
for (let i = 0; i < 100; i++) { const target = getRandomTargetElement(10000); array_small.includes(target) }
for (let i = 0; i < 100; i++) {
const target = getRandomTargetElement(10000);
array_small.includes(target)
}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Array.includes, 10 000 elements
Array.includes, 1 000 000 elements
Set.has, 10 000 elements
Set.has, 1 000 000 elements
Array to Set + Set.has, 10 000 elements
Array to Set + Set.has x 100, 10 000 elements
Array.includes x 100, 10 000 elements

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.includes, 10 000 elements	95126.7 Ops/sec
Array.includes, 1 000 000 elements	958.7 Ops/sec
Set.has, 10 000 elements	38336568.0 Ops/sec
Set.has, 1 000 000 elements	26425542.0 Ops/sec
Array to Set + Set.has, 10 000 elements	2759.9 Ops/sec
Array to Set + Set.has x 100, 10 000 elements	2739.9 Ops/sec
Array.includes x 100, 10 000 elements	966.3 Ops/sec

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

Let's dive into the world of JavaScript microbenchmarks!

Benchmark Overview

The benchmark measures the performance difference between array.includes() and set.has() operations on large arrays and sets.

Options Compared

Two options are compared:

Array.includes(): A method that checks if a specified value exists in an array.
Set.has(): A method that checks if a specified value exists in a set (a collection of unique values).

Pros and Cons of Each Approach:

Array.includes():
- Pros:
  - Wide support across browsers and Node.js versions
  - Can be used for more complex data structures, such as arrays with duplicate values
- Cons:
  - May perform slower on large datasets due to the need to iterate over the array
Set.has():
- Pros:
  - Generally faster than array.includes() for large datasets
  - Can be more memory-efficient since sets only store unique values
- Cons:
  - Less support across browsers and Node.js versions (specifically, older browsers and some older Node.js versions may not support sets)
  - May require more complex code to convert data structures to sets

Other Considerations:

Preparation Code: The benchmark preparation code creates large arrays and sets using the getArray() function. This ensures consistent input data for each test case.
Random Targets: The getRandomTargetElement() function generates random targets for the includes() and has() operations, reducing any potential optimizations that might favor specific values.

Library Use:

The benchmark uses the Set object to represent sets. The Set class is a built-in JavaScript object that provides an efficient way to store unique values.

Special JS Features/Syntax (None Mentioned):

No special JavaScript features or syntax are used in this benchmark.

Alternatives:

If you're interested in exploring other benchmarking tools, consider the following alternatives:

Benchmark.js: A popular benchmarking library for Node.js that provides a simple and efficient way to measure performance.
WebPageTest: A web testing tool that also offers benchmarking capabilities for measuring page load times and performance.
Benchmark Library (in browser): Built-in Benchmark Library in browsers like Chrome, Firefox and others

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The benchmark measures the performance difference between `array.includes()` and `set.has()` operations on large arrays and sets.

**Options Compared**

Two options are compared:

1. **Array.includes()**: A method that checks if a specified value exists in an array.
2. **Set.has()**: A method that checks if a specified value exists in a set (a collection of unique values).

**Pros and Cons of Each Approach:**

*   **Array.includes():**
    *   Pros:
        *   Wide support across browsers and Node.js versions
        *   Can be used for more complex data structures, such as arrays with duplicate values
    *   Cons:
        *   May perform slower on large datasets due to the need to iterate over the array
*   **Set.has():**
    *   Pros:
        *   Generally faster than `array.includes()` for large datasets
        *   Can be more memory-efficient since sets only store unique values
    *   Cons:
        *   Less support across browsers and Node.js versions (specifically, older browsers and some older Node.js versions may not support sets)
        *   May require more complex code to convert data structures to sets

**Other Considerations:**

*   **Preparation Code:** The benchmark preparation code creates large arrays and sets using the `getArray()` function. This ensures consistent input data for each test case.
*   **Random Targets:** The `getRandomTargetElement()` function generates random targets for the includes() and has() operations, reducing any potential optimizations that might favor specific values.

**Library Use:**

The benchmark uses the `Set` object to represent sets. The `Set` class is a built-in JavaScript object that provides an efficient way to store unique values.

**Special JS Features/Syntax (None Mentioned):**

No special JavaScript features or syntax are used in this benchmark.

**Alternatives:**

If you're interested in exploring other benchmarking tools, consider the following alternatives:

*   **Benchmark.js:** A popular benchmarking library for Node.js that provides a simple and efficient way to measure performance.
*   **WebPageTest:** A web testing tool that also offers benchmarking capabilities for measuring page load times and performance.
*   **Benchmark Library (in browser):** Built-in Benchmark Library in browsers like Chrome, Firefox and others

Related benchmarks: