Benchmark: DDS Array vs Set - performance v4

Script Preparation code:

var numberOfElements = 50000
var arr = [];
for (let i = 0; i < numberOfElements; i++) arr.push(i);


var set = new Set(arr);

Tests:

Array - iteration
for (const x of arr) {}
Set - iteration
for (const x of set) {}
Array - includes
const value = numberOfElements - 1; arr.includes(value)
Set - has
const value = numberOfElements - 1; set.has(value)
Array - push
arr.push(numberOfElements + 1)
Set - add
set.add(numberOfElements + 1)
Array - deletion
const value = numberOfElements - 1; const index = arr.indexOf(value); arr.splice(index, 1);
Set - deletion
const value = numberOfElements - 1; set.delete(value);
Converting a Set to an Array
const array = Array.from(set);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array - iteration
Set - iteration
Array - includes
Set - has
Array - push
Set - add
Array - deletion
Set - deletion
Converting a Set to an Array

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the test cases and explain what's being tested, along with their pros and cons.

**Test Cases:**

1. **Array - iteration**: This test case measures the performance of iterating over an array using a `for...of` loop. The `for...of` loop is a modern JavaScript syntax that allows you to iterate over arrays and other iterable objects in a more concise way.
	* Pros: Easy to read and write, efficient, and widely supported by modern browsers.
	* Cons: May not work in older browsers or environments that don't support the `for...of` loop.
2. **Set - iteration**: Similar to the previous test case, this measures the performance of iterating over a Set using a `for...of` loop.
3. **Array - includes**: This test case measures the performance of checking if an element is present in an array using the `includes()` method.
	* Pros: Efficient and widely supported by modern browsers.
	* Cons: May be slower than other methods, such as `indexOf()`, for very large arrays.
4. **Set - has**: Similar to the previous test case, this measures the performance of checking if an element is present in a Set using the `has()` method.
5. **Array - push**: This test case measures the performance of adding an element to an array using the `push()` method.
	* Pros: Efficient and widely supported by modern browsers.
	* Cons: May be slower than other methods, such as `splice()`, for very large arrays.
6. **Set - add**: Similar to the previous test case, this measures the performance of adding an element to a Set using the `add()` method.
7. **Array - deletion**: This test case measures the performance of removing an element from an array using the `splice()` method or the `indexOf()` method followed by `splice()`.
	* Pros: Efficient and widely supported by modern browsers.
	* Cons: May be slower than other methods, such as `filter()`, for very large arrays.
8. **Set - deletion**: Similar to the previous test case, this measures the performance of removing an element from a Set using the `delete()` method or the `has()` method followed by `delete()`.
9. **Converting a Set to an Array**: This test case measures the performance of converting a Set to an array using the `Array.from()` method.
	* Pros: Efficient and widely supported by modern browsers.
	* Cons: May be slower than other methods, such as `Spread operator`, for very large Sets.

**Libraries and Features:**

None of the test cases use any external libraries or features. The tests are designed to measure the performance of built-in JavaScript features.

**Other Alternatives:**

For comparison, you could consider measuring the performance of older browsers or environments that don't support modern JavaScript features, such as `for...of` loops or `includes()` methods.

You could also consider measuring the performance of other methods for each operation, such as:

* Array - iteration: `forEach()`, `map()`, and `filter()`
* Set - iteration: `forEach()`, `map()`, and `reduce()`
* Array - includes: `indexOf()`, `indexOfFirst()`, and `indexOfLast()`
* Set - has: `has()` vs. `some()`

These alternatives could provide additional insights into the performance characteristics of different JavaScript features and methods.

Latest run results:

Run details: (Test run date: 4 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:123.0) Gecko/20100101 Firefox/123.0

Browser/OS: Firefox 123 on Windows

View result in a separate tab

Test name	Executions per second
Array - iteration	2831.6 Ops/sec
Set - iteration	1016.5 Ops/sec
Array - includes	10721.1 Ops/sec
Set - has	873604608.0 Ops/sec
Array - push	14720297.0 Ops/sec
Set - add	39704720.0 Ops/sec
Array - deletion	6.2 Ops/sec
Set - deletion	27850610.0 Ops/sec
Converting a Set to an Array	625.5 Ops/sec

Related benchmarks:

DDS Array vs Set - performance v4 (version: 2)

Comparing performance of: Array - iteration vs Set - iteration vs Array - includes vs Set - has vs Array - push vs Set - add vs Array - deletion vs Set - deletion vs Converting a Set to an Array

Created: one year ago by: Registered User

Jump to the latest result

Array - iteration

Set - iteration

Array - includes

Set - has

Array - push

Set - add

Array - deletion

Set - deletion

Converting a Set to an Array

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):