Benchmark: lodash sorting vs JS sort

HTML Preparation code:

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

Script Preparation code:

var users = [
      { user: 'fred', age: 48 },
      { user: 'barney', age: 36 },
      { user: 'fred', age: 40 },
      { user: 'barney', age: 34 },
      { user: 'frank', age: 12 },
      { user: 'barry', age: 38 },
      { user: 'ted', age: 19 },
      { user: 'marshall', age: 42 }
    ];

Tests:

sort object with orderBy, ascending
_.orderBy(users, 'age', 'asc');
sort object with sortBy, ascending
_.sortBy(users, 'age');
sort object with native sort, ascending
[...users].sort((a, b) => a.age - b.age);
sort object with orderBy, descending
_.orderBy(users, 'age', 'desc');
sort object with native sort, descending
users.sort((a, b) => b.age - a.age);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
sort object with orderBy, ascending
sort object with sortBy, ascending
sort object with native sort, ascending
sort object with orderBy, descending
sort object with native sort, descending

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 benchmark and explain what is being tested.

The provided JSON represents a JavaScript microbenchmark that compares the performance of three different approaches for sorting an array of objects: native sort, `lodash.sortBy`, and `lodash orderBy`.

**Native Sort**

The first approach uses the built-in `sort()` method on the array, which sorts the elements in place. The sorting function takes two arguments, `a` and `b`, representing the two elements being compared.

In this specific test case, the sorting function compares the `age` property of each object: `(a, b) => a.age - b.age`. This is an ascending sort order.

Pros:

* Native sort is widely supported by most browsers and can be executed quickly without any additional libraries.
* It's easy to implement and understand.

Cons:

* Performance may vary depending on the browser and JavaScript engine used.
* Not all browsers support stable sorting, which means the original order of equal elements may not be preserved.

**Lodash sortBy**

The second approach uses the `sortBy()` function from the Lodash library. This function takes an array and a key function that returns a value to sort by.

In this test case, the sorting function is `[...users].sort((a, b) => a.age - b.age)`. The Lodash `sortBy()` function can be used in place of the native `sort()` method, but it's not as efficient since it creates a new array with the sorted elements.

Pros:

* Easy to implement and understand.
* Works well for large datasets.
* Can handle complex sorting logic.

Cons:

* Requires an additional library (Lodash) that needs to be included in the HTML file.
* May have performance overhead due to creating a new array.

**Lodash orderBy**

The third approach uses the `orderBy()` function from Lodash. This function takes an array and two arguments: the key to sort by, and the sorting order ('asc' or 'desc').

In this test case, the sorting functions are `_ = _.orderBy(users, 'age', 'asc');` (ascending) and `_ = _.orderBy(users, 'age', 'desc');` (descending). The Lodash `orderBy()` function sorts the array in place, similar to the native `sort()` method.

Pros:

* Easy to implement and understand.
* Works well for large datasets.
* Can handle complex sorting logic.

Cons:

* Requires an additional library (Lodash) that needs to be included in the HTML file.
* May have performance overhead due to creating a new array (in the case of native sort).

Other considerations:

* The benchmark uses Chrome 123 as the browser, which is relatively recent. Performance results may vary on other browsers or older versions.
* The test cases use an array of objects with multiple properties to be sorted. This can help demonstrate how sorting performance scales with dataset size and complexity.
* The benchmark does not account for parallel processing or concurrent execution, which could further improve performance in real-world scenarios.

Alternatives:

* For a more lightweight approach, you could consider using the `Array.prototype.sort()` method with a custom comparison function, without Lodash or any other library.
* If you need to perform complex sorting logic, you might want to explore alternative libraries like Moment.js for date-based sorting or a custom solution using vanilla JavaScript.
* For high-performance sorting, you may want to consider using a dedicated sorting library like Fast Sort or Introsort, which are optimized for specific use cases and can outperform the built-in `sort()` method.

Latest run results:

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

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

Browser/OS: Chrome 123 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
sort object with orderBy, ascending	1444585.4 Ops/sec
sort object with sortBy, ascending	1450932.0 Ops/sec
sort object with native sort, ascending	4078733.5 Ops/sec
sort object with orderBy, descending	1538871.6 Ops/sec
sort object with native sort, descending	6836785.5 Ops/sec

Related benchmarks:

lodash sorting vs JS sort (version: 0)

Comparing performance of: sort object with orderBy, ascending vs sort object with sortBy, ascending vs sort object with native sort, ascending vs sort object with orderBy, descending vs sort object with native sort, descending

Created: 3 years ago by: Guest

Jump to the latest result

sort object with orderBy, ascending

sort object with sortBy, ascending

sort object with native sort, ascending

sort object with orderBy, descending

sort object with native sort, descending

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