Benchmark: Set.has vs Array.includes

Script Preparation code:

function range(s, e) {
  const xs = [];
  for (let i=s; i<e; i++) xs.push(i);
  return xs;
}
const pow = y => x => Math.pow(y, x);
const p10 = pow(10);

// [10, 100, ..., 1_000_000]
const xss = range(1, 7)
  .map(i => range(0, p10(i)));

const sxss = xss
  .map(xs => new Set(xs));

var yss = range(1, 7)
  .map(i => range(1, 9)
    .map(j => j * p10(i))
  );

var smallXss = xss.slice(0, 3);
var largeXss = xss.slice(3);

var smallSxss = sxss.slice(0, 3);
var largeSxss = sxss.slice(3);

Tests:

Array.includes - small
const xss = smallXss; const n = xss.length; const n2 = yss[0].length; for (let i = 0; i < n; i++) { const xs = xss[i]; const ys = yss[i]; for (let j = 0; j < n2; j++) { xs.includes(ys[j]); } }
Set.has - small
const xss = smallSxss; const n = xss.length; const n2 = yss[0].length; for (let i = 0; i < n; i++) { const xs = xss[i]; const ys = yss[i]; for (let j = 0; j < n2; j++) { xs.has(ys[j]); } }
Array.includes - large
const xss = largeXss; const n = xss.length; const n2 = yss[0].length; for (let i = 0; i < n; i++) { const xs = xss[i]; const ys = yss[i]; for (let j = 0; j < n2; j++) { xs.includes(ys[j]); } }
Set.has - large
const xss = largeSxss; const n = xss.length; const n2 = yss[0].length; for (let i = 0; i < n; i++) { const xs = xss[i]; const ys = yss[i]; for (let j = 0; j < n2; j++) { xs.has(ys[j]); } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.includes - small
Set.has - small
Array.includes - large
Set.has - large

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/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.includes - small	795712.4 Ops/sec
Set.has - small	5627109.0 Ops/sec
Array.includes - large	220691.3 Ops/sec
Set.has - large	5623946.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks and explore what's being tested in this specific benchmark.

**Benchmark Description**

The benchmark is designed to compare the performance of two approaches for checking membership in arrays: `Array.includes()` and `Set.has()`. The tests create a set of large arrays, where each array contains a subset of numbers generated using the `range` function. The arrays are then sliced into smaller and larger subsets.

**Options being compared**

The benchmark compares four test cases:

1. **Small Array with Set.has**: A small array (`smallXss`) is used to create sets (`sxss`). The test checks if each element in the set exists using `Set.has()`.
2. **Small Array with Array.includes**: The same small array is used, but instead of creating a set, it's used directly for membership checks using `Array.includes()`.
3. **Large Array with Set.has**: A larger array (`largeXss`) is used to create sets (`largeSxss`). The test checks if each element in the set exists using `Set.has()`.
4. **Large Array with Array.includes**: Another larger array is used, and membership checks are performed using `Array.includes()`.

**Pros and Cons**

1. **Set.has()**:
	* Pros: Sets provide fast lookup times (O(1)) for membership checks.
	* Cons: Sets require more memory to store the underlying data structure.
2. **Array.includes()**:
	* Pros: Arrays are widely supported, and `includes()` is a simple and efficient method.
	* Cons: `includes()` has to search through the array, which can be slower for large arrays.

**Other considerations**

1. **Memory usage**: The benchmark creates large arrays, which could lead to high memory usage if not managed properly.
2. **Cache performance**: The benchmark's use of nested loops and array indexing might affect cache performance, as some elements may be cached, while others are not.

**Library used**

The `range` function is a custom function that generates an array of numbers from a start value to an end value.

**Special JavaScript feature or syntax**

This benchmark uses the following features:

1. **Arrow functions**: The `pow` and `p10` variables use arrow functions, which are a concise way to define small functions.
2. **Destructuring**: The `map()` method is used to create new arrays by applying a transformation function to each element in an existing array.

**Alternative approaches**

Other approaches for checking membership in arrays include:

1. **Using `indexOf()`**: This method searches for the first occurrence of a value and returns its index. It can be slower than `includes()` but might be more suitable for certain use cases.
2. **Using `filter()`**: This method creates a new array with all elements that pass a test function. While not specifically designed for membership checks, it can be used in conjunction with other methods to achieve the same result.

In conclusion, this benchmark provides a detailed comparison of two approaches for checking membership in arrays: `Set.has()` and `Array.includes()`. By analyzing the pros and cons of each approach, developers can choose the most suitable method for their specific use cases.

Related benchmarks:

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

Comparing performance of: Array.includes - small vs Set.has - small vs Array.includes - large vs Set.has - large

Created: 5 years ago by: Registered User

Jump to the latest result

Array.includes - small

Set.has - small

Array.includes - large

Set.has - large

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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