Benchmark: Filtering test LZ

Script Preparation code:

var array = Array.from({length: 40}, () => ({ value: Math.floor(Math.random() * 140)}));

Tests:

Set spread
const values = array.map(({ value }) => value) const f = [... new Set(values)]
Array from set
const values = array.map(({ value }) => value) const s = new Set(array) const l = Array.from(s)
Filter
const b = array.filter((i,index) => array.indexOf(i)=== index)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set spread
Array from set
Filter

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Context**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The website provides a platform for comparing the performance of different JavaScript implementations, such as browsers or Node.js engines.

**Script Preparation Code**

The provided script preparation code creates an array of 40 random objects with `value` properties between 0 and 139:
```javascript
var array = Array.from({length: 40}, () => ({ value: Math.floor(Math.random() * 140)}));
```
This code is used as input for the benchmark tests.

**Html Preparation Code**

There is no HTML preparation code provided, which means that the benchmark only involves JavaScript execution and does not rely on any specific HTML or DOM-related functionality.

**Individual Test Cases**

There are three individual test cases:

1. **Set Spread**: This test case creates an array of unique values from the original array using the spread operator (`[... new Set(values)]`).
2. **Array From Set**: This test case creates a set from the original array and then converts it back to an array using `Array.from()`.
3. **Filter**: This test case filters the original array to keep only elements that have the same index as their value in the original array (`array.filter((i, index) => array.indexOf(i) === index)`).

**Library Usage**

None of the test cases explicitly use any external libraries.

**Special JS Features or Syntax**

There are no special JavaScript features or syntax used in these test cases. They only rely on standard JavaScript language constructs.

**Pro/Cons of Different Approaches**

Here's a brief summary of the pros and cons of each approach:

1. **Set Spread**: This approach is concise and efficient, as it uses the spread operator to create an array of unique values.
	* Pros: Simple and fast
	* Cons: May not be as intuitive for some developers, especially those without experience with sets or spread operators
2. **Array From Set**: This approach creates a set first and then converts it back to an array using `Array.from()`.
	* Pros: Can be more efficient than the previous approach if the set contains many duplicates (as it only keeps unique values)
	* Cons: May be slower due to the additional creation of a set
3. **Filter**: This approach filters the original array to keep only elements that have the same index as their value.
	* Pros: Easy to understand and implement for developers familiar with filtering
	* Cons: May not be the most efficient approach, especially for large arrays

**Other Alternatives**

If these test cases were to be rewritten using different approaches or libraries, some alternative solutions could include:

1. Using `reduce()` instead of set spread: `Array.from({length: 40}, () => ({ value: Math.floor(Math.random() * 140)})).reduce((a, b) => new Set(a).has(b.value), [])`
2. Using `sort()` and filtering: `array.sort((a, b) => a.value - b.value);` followed by `array.filter((i, index) => array.indexOf(i) === index)`
3. Using a library like Lodash to implement the set spread operation

Keep in mind that these alternative solutions would likely have different performance characteristics and may not be as efficient or readable as the original implementations.

In conclusion, the benchmark tests are designed to compare the performance of three different approaches for creating an array of unique values from a larger array: set spread, array from set, and filtering. The pros and cons of each approach highlight the trade-offs between conciseness, efficiency, and readability in implementing these operations.

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

Browser/OS: Chrome 119 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Set spread	1462627.0 Ops/sec
Array from set	999646.1 Ops/sec
Filter	539023.6 Ops/sec

Related benchmarks:

Filtering test LZ (version: 0)

Comparing performance of: Set spread vs Array from set vs Filter

Created: one year ago by: Guest

Jump to the latest result

Set spread

Array from set

Filter

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