Benchmark: Compount Mapping and Sorting (lodash vs native)

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js" integrity="sha512-WFN04846sdKMIP5LKNphMaWzU7YpMyCU245etK3g/2ARYbPK9Ub18eG+ljU96qKRCWh+quCY7yefSmlkQw1ANQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>

Script Preparation code:

var arr = [];
for (var i = 0; i < 1_000_000; i++) {
  arr.push({ value: Math.random() });
}

Tests:

Native JS map and sort
arr.map(item=>({...item, negated_square: -item.value*item.value})).sort((a, b) => a.negated_square - b.negated_square);
lodash sortby(native map)
_.sortBy(arr.map(item=>({...item, negated_square: -item.value*item.value})), 'negated_square');
lodash chain map, and sortBy
_.chain(arr).map(item=>({...item, negated_square: -item.value*item.value})).sortBy('negated_square');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native JS map and sort
lodash sortby(native map)
lodash chain map, and sortBy

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 17 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its options.

**Benchmark Overview**

The benchmark tests three different approaches to performing mapping and sorting operations on an array of objects:

1. Native JavaScript (ES6) `map()` and `sort()`
2. Lodash's `sortBy()` function
3. Lodash's `chain()` method combined with `map()` and `sortBy()` functions

**Options Compared**

The three options are compared in terms of their execution speed, measured by the number of executions per second.

**Native JavaScript (`map()` and `sort()`)**

* This option uses ES6's built-in `map()` function to create a new array with transformed objects, followed by the `sort()` function to sort the resulting array based on the `negated_square` property.
* Pros:
	+ Lightweight and efficient, as it only requires the standard library functions.
	+ Easy to understand and implement for developers familiar with JavaScript.
* Cons:
	+ May not perform well for large datasets due to the overhead of creating a new array.
	+ Requires ES6 support.

**Lodash's `sortBy()` function**

* This option uses Lodash's `sortBy()` function to sort the array in place, passing the transformed objects from the previous step as an argument.
* Pros:
	+ Can be more efficient than the native approach for large datasets, as it avoids creating a new array.
	+ Provides a convenient and well-maintained function for sorting arrays.
* Cons:
	+ Requires Lodash to be included in the benchmark's scope.
	+ May have additional overhead due to the library's functionality.

**Lodash's `chain()` method combined with `map()` and `sortBy()` functions**

* This option uses Lodash's `chain()` function to create a pipeline of transformations, followed by the `map()` function to transform the objects again, and finally the `sortBy()` function to sort the resulting array.
* Pros:
	+ Provides an efficient way to chain multiple operations together.
	+ Can be more readable than other approaches for complex transformations.
* Cons:
	+ May have additional overhead due to the pipeline's creation and execution.
	+ Requires Lodash to be included in the benchmark's scope.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for various tasks, including array manipulation, object transformation, and more. In this benchmark, Lodash's `sortBy()` function is used to sort arrays in place, while its `chain()` method is used to create pipelines of transformations.

**Special JS Feature/Syntax**

This benchmark does not use any special JavaScript features or syntax that would require specific support or interpretation by the test environment.

**Alternatives**

Other approaches to mapping and sorting operations might include:

* Using a different library, such as Underscore.js or Moment.js
* Implementing custom array manipulation functions using ES6's standard library
* Using parallel processing or concurrent programming techniques to speed up execution

Keep in mind that the choice of approach depends on the specific requirements and constraints of the project, including performance, readability, and maintainability.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36

Browser/OS: Chrome 125 on Windows

View result in a separate tab

Test name	Executions per second
Native JS map and sort	1.2 Ops/sec
lodash sortby(native map)	0.7 Ops/sec
lodash chain map, and sortBy	3647431.8 Ops/sec

Related benchmarks:

Compount Mapping and Sorting (lodash vs native) (version: 0)

_.sortBy vs _.orderBy vs JS sort

Comparing performance of: Native JS map and sort vs lodash sortby(native map) vs lodash chain map, and sortBy

Created: 5 months ago by: Guest

Jump to the latest result

Native JS map and sort

lodash sortby(native map)

lodash chain map, and sortBy

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 17 days ago):