Benchmark: Array immutable union: set from lodash union vs set from lodash flatten

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var list = [[ 'a', 'b', 'c' ], [ 'b', 'd', 'a', 'e', 'f' ]];

Tests:

set from lodash union
var c = new Set(_.union(...list));
Set from flatten
var c = new Set(_.flatten(list))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
set from lodash union
Set from flatten

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36

Browser/OS: Chrome 81 on Mac OS X 10.14.6

View result in a separate tab

Test name	Executions per second
set from lodash union	878948.9 Ops/sec
Set from flatten	1261891.1 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 benchmark and its test cases.

**Benchmark Overview**

The benchmark, named "Array immutable union: set from lodash union vs set from lodash flatten", compares two approaches to create an immutable set from an array using Lodash.

**Test Cases**

There are two test cases:

1. **Set from Union**: This test case creates a set by passing the array `list` to the `_union` function from Lodash, which returns a new set with unique elements.
```javascript
var c = new Set(_.union(...list));
```
2. **Set from Flatten**: This test case creates a set by passing the array `list` to the `_flatten` function from Lodash, which returns a new array with all nested arrays flattened.

**Comparison of Approaches**

The two approaches differ in their use of Lodash functions:

* The "Union" approach uses the `_union` function, which takes multiple arguments and returns a new set with unique elements.
* The "Flatten" approach uses the `_flatten` function, which takes an array as input and returns a new array with all nested arrays flattened.

**Pros and Cons of Each Approach**

**Set from Union:**

Pros:

* Efficient for creating sets from arrays with unique elements
* May be faster for large datasets due to Lodash's optimization for union operations

Cons:

* Requires multiple function calls, which can lead to higher overhead
* May not be suitable for very large datasets due to potential memory limitations

**Set from Flatten:**

Pros:

* Can handle nested arrays and more complex data structures
* Often faster and more efficient than the "Union" approach

Cons:

* May not preserve unique elements as effectively, leading to slower performance compared to the "Union" approach
* Requires a single function call, which can be less overhead than multiple calls for large datasets.

**Lodash Library**

The benchmark uses Lodash version 4.17.5, which is a popular JavaScript utility library that provides various functions for tasks such as array manipulation, string manipulation, and more. In this case, Lodash's `_union` and `_flatten` functions are used to create the sets.

**JavaScript Features and Syntax**

This benchmark does not utilize any special JavaScript features or syntax beyond standard ECMAScript 2015 (ES6+) language features. It only uses JavaScript as a programming language without introducing any specific syntax extensions or experimental APIs.

**Alternative Approaches**

If you were to implement these test cases using native JavaScript instead of Lodash, you could use the following approaches:

1. Using `Set` constructor with array methods:
```javascript
var c = new Set(list.map(item => item.join(',')));
```
This approach requires flattening the nested arrays and converting them to strings before passing them to the `Set` constructor.

2. Using a custom union function:
```javascript
function union(arrays) {
  const result = new Set();
  arrays.forEach(array => array.forEach(value => result.add(value)));
  return result;
}

var c = new Set(union(list));
```
This approach requires defining and implementing your own `union` function, which can be more complex than using Lodash's `_union` function.

Overall, the benchmark provides a useful comparison of two approaches to create immutable sets from arrays using Lodash, showcasing the trade-offs between efficiency, flexibility, and simplicity.

Related benchmarks:

Array immutable union: set from lodash union vs set from lodash flatten (version: 0)

Comparing performance of: set from lodash union vs Set from flatten

Created: 4 years ago by: Guest

Jump to the latest result

set from lodash union

Set from flatten

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