Benchmark: List vs Set - MeasureThat.net

Script Preparation code:

var data1 = [ ...Array.from(Array(10000).keys()) ];
var data2 = [ ...Array.from(Array(1000).keys()) ];

Tests:

filter and includes
const filteredArray = data1.filter(value => data2.includes(value));
set
const filteredArray = data1.filter(Set.prototype.has, new Set(data2));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
filter and includes
set

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

Browser/OS: Chrome 108 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
filter and includes	574.7 Ops/sec
set	3362.4 Ops/sec

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):

LLMs can make mistakes. Check important info.

This benchmark tests the performance of filtering an array using two different methods:

**Method 1: `filter` with `includes`**

-  The code `data1.filter(value => data2.includes(value))` uses the built-in `filter` method on the `data1` array. 
   - For each element in `data1`, it calls `includes` on `data2` to check if the element exists in `data2`. If it does, the element is kept in the resulting filtered array.

**Method 2: `filter` with a `Set`**

- The code `data1.filter(Set.prototype.has, new Set(data2))` uses the `filter` method again but passes two arguments:
     -  `Set.prototype.has`: This refers to the `has` method of the `Set` object, which efficiently checks if a value is present in the set. 
     -  `new Set(data2)`: A new `Set` object is created from the `data2` array. Sets are optimized for checking membership (using `has`).

**Pros and Cons:**

* **Method 1 (`filter` with `includes`)**:
    - **Con:** The `includes` method iterates through the entire `data2` array every time it's called, which can be slow for large arrays. This leads to O(n) complexity for filtering where n is the size of data2. 
* **Method 2 (`filter` with `Set`)**:
    - **Pro:** Using a `Set` offers near constant time complexity (O(1)) for membership checking using `has`. This makes filtering much faster, especially for larger arrays.

**Other Considerations:**

* **Data Size:** The performance difference between the two methods will be most noticeable with larger `data2` arrays.
* **Memory Usage:** Creating a `Set` consumes additional memory, which might be a factor if memory is a significant concern.

**Alternatives:**

There are other ways to achieve filtering:

* **Array Methods (`forEach`, `some`)**: You could manually iterate through `data1` and check for membership in `data2` using a loop or methods like `forEach` and `some`.  However, these often lack the performance optimizations of built-in array methods.
* **External Libraries:** Some libraries (e.g., Lodash) provide efficient filtering functions with different options and behaviors.

Related benchmarks:

List vs Set (version: 0)

Comparing performance of: filter and includes vs set

Created: one year ago by: Guest

Jump to the latest result

filter and includes

set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):