Benchmark: _.sortBy vs _.orderBy vs JS sort multiple

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; i++) {
  arr.push({
    id: i
    , lower: String.fromCharCode(65+Math.floor(Math.random() * 26))
    , upper: String.fromCharCode(97+Math.floor(Math.random() * 26))
    , value: Math.random() 
});
}

Tests:

Native JS sort
arr.sort((a, b) => a.value - b.value);
lodash sortby
_.sortBy(arr, (arr) => arr.value);
lodash orderBy
_.orderBy(arr, (arr) => arr.value);
lodash orderby 2 properties
_.orderBy(arr, [s1 => s1.lower, s2 => s2.value]);
lodash orderby 3 properties
_.orderBy(arr, [s1 => s1.lower, s2 => s2.upper, s3 => s3.value]);
lodash oderby 4 properties
_.orderBy(arr, [s1 => s1.lower, s2 => s2.upper, s3 => s3.value, s4 => s4.id]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native JS sort
lodash sortby
lodash orderBy
lodash orderby 2 properties
lodash orderby 3 properties
lodash oderby 4 properties

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of what is tested in the provided JSON benchmark.

**Benchmark Definition**

The benchmark tests the performance of three sorting methods:

1. Native JavaScript sort (using the built-in `Array.prototype.sort()` method).
2. Lodash `_.sortBy()` function, which sorts an array based on a given sorting function.
3. Lodash `_.orderBy()` function, which sorts an array based on one or more properties.

**Options Compared**

The benchmark compares different approaches:

* Native JavaScript sort: uses the built-in `Array.prototype.sort()` method with a simple comparison function (`a.value - b.value`).
* Lodash `_.sortBy()`: uses the `_.sortBy()` function, which takes an array and a sorting function as arguments.
* Lodash `_.orderBy()`: uses the `_.orderBy()` function, which takes an array and one or more sorting functions as arguments.

**Pros and Cons**

Here's a brief summary of each approach:

* Native JavaScript sort:
	+ Pros: Fast, efficient, and widely supported.
	+ Cons: Can be slow for large datasets due to the complexity of the comparison function.
* Lodash `_.sortBy()`:
	+ Pros: Flexible, customizable sorting behavior. Reduces the need for explicit loop constructs.
	+ Cons: May have higher overhead compared to native JavaScript sort due to the additional function call.
* Lodash `_.orderBy()`:
	+ Pros: Allows sorting based on multiple properties, which can be useful in certain scenarios.
	+ Cons: Adds an additional layer of complexity and potential performance overhead.

**Library: Lodash**

Lodash is a popular utility library for JavaScript that provides various functions for tasks such as array manipulation, string manipulation, and functional programming. The `_.sortBy()` and `_.orderBy()` functions are part of the Lodash library and provide convenient ways to sort arrays based on specific criteria.

**Special JS Feature/Syntax: None**

There are no special JavaScript features or syntax used in this benchmark.

**Other Alternatives**

If you're interested in exploring alternative sorting libraries or methods, here are a few options:

* `Array.prototype.sort()` with custom comparison functions
* Other utility libraries like Moment.js for date-based sorting
* Custom implementation using vanilla JavaScript and algorithms like QuickSort or MergeSort

Keep in mind that the choice of sorting method depends on the specific requirements of your use case.

Latest run results:

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

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

Browser/OS: Chrome 122 on Windows

View result in a separate tab

Test name	Executions per second
Native JS sort	46713.2 Ops/sec
lodash sortby	13764.3 Ops/sec
lodash orderBy	12109.6 Ops/sec
lodash orderby 2 properties	1923.1 Ops/sec
lodash orderby 3 properties	1657.4 Ops/sec
lodash oderby 4 properties	1495.7 Ops/sec

Related benchmarks:

_.sortBy vs _.orderBy vs JS sort multiple (version: 0)

Comparing performance of: Native JS sort vs lodash sortby vs lodash orderBy vs lodash orderby 2 properties vs lodash orderby 3 properties vs lodash oderby 4 properties

Created: one year ago by: Guest

Jump to the latest result

Native JS sort

lodash sortby

lodash orderBy

lodash orderby 2 properties

lodash orderby 3 properties

lodash oderby 4 properties

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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