Benchmark: using set vs array

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>

Script Preparation code:

var max = 2000;

var arr = [];
for (var i = 0; i <= max; i++) { arr.push(i); }

var set = new Set(arr);

Tests:

removing with array
for (var i = 0; i <= max; i++) {set.delete(i); }
removing with set
for (var i = 0; i <= max; i++) { _.remove(arr, item => item === i); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
removing with array
removing with 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/119.0.0.0 Safari/537.36 Edg/119.0.0.0

Browser/OS: Chrome 119 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
removing with array	4654.4 Ops/sec
removing with set	2053.0 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark definition is about comparing two approaches to remove elements from an array:

1. `for (var i = 0; i <= max; i++) { set.delete(i); }` - This test case uses a `Set` object to store the elements, and then iterates over the range of numbers from 0 to `max`, deleting each element from the set.
2. `for (var i = 0; i <= max; i++) { _.remove(arr, item => item === i); }` - This test case uses the Lodash library (`_`) and its `remove` function to remove elements from the array.

**Options Compared**

The two options being compared are:

* Using a `Set` object to store elements
* Using the Lodash library's `remove` function to remove elements from an array

**Pros and Cons**

**Using a Set Object:**

Pros:

* Sets are inherently fast and efficient for adding and removing elements.
* They eliminate duplicates automatically.

Cons:

* Sets are not ordered, so iterating over them may be slower than arrays.
* They do not preserve the original order of elements.

**Using Lodash's remove function:**

Pros:

* Lodash's `remove` function is optimized for array manipulation and can handle large datasets efficiently.
* It preserves the original order of elements.

Cons:

* Requires an external library (Lodash).
* May be slower than using a Set object due to the overhead of iterating over the array.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for data manipulation, string manipulation, and more. The `remove` function in this benchmark definition uses Lodash's implementation of the `removeAt` function with a callback function to filter out elements based on their value.

**Special JS Feature or Syntax**

There is no special JavaScript feature or syntax used in this benchmark definition. However, it's worth noting that the use of `var` for variable declaration is an older style of JavaScript and may not be recommended for new codebases.

**Other Alternatives**

If you want to write a similar benchmark, you could consider using other libraries or approaches, such as:

* Using an array's built-in `splice` method instead of the Lodash `remove` function.
* Comparing the performance of different data structures, such as arrays vs. linked lists.
* Investigating the impact of different optimization techniques, such as caching or memoization.

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

Related benchmarks:

using set vs array (version: 0)

Comparing performance of: removing with array vs removing with set

Created: one year ago by: Guest

Jump to the latest result

removing with array

removing with set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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