Benchmark: Lodash sort vs array.prototype.slice and array.prototype.sort

HTML Preparation code:

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

Script Preparation code:

function getRandomInt(max) {
  return Math.floor(Math.random() * Math.floor(max));
}

var arr = [];
for(var i = 0; i < 100000; i++){
  arr.push({value:getRandomInt(100)});
}

Tests:

_.sortBy
_.sortBy(arr,"value");
array.prototype.sort
arr.slice().sort((a,b) => a.value - b.value);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.sortBy
array.prototype.sort

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_15_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.122 Safari/537.36

Browser/OS: Chrome 80 on Mac OS X 10.15.3

View result in a separate tab

Test name	Executions per second
_.sortBy	19.1 Ops/sec
array.prototype.sort	35.6 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark is comparing two approaches to sort an array of objects: `lodash.sortby` and `array.prototype.slice().sort()` (or `arr.sort()`, for short). The benchmark creates a large array of 100,000 objects with random values and then sorts the array using both methods.

**Library Used**

Lodash is used in one of the test cases (`_.sortBy`). Lodash is a popular JavaScript utility library that provides a collection of functions for common tasks, such as functional programming, data manipulation, and string manipulation. In this case, `lodash.sortby` is used to sort the array.

**JavaScript Feature/Syntax**

The benchmark uses a syntax feature called "arrow function" in one of the test cases (`arr.prototype.sort`). An arrow function is a shorthand way of defining a function using the `=>` operator. It's equivalent to writing a traditional function with an anonymous function expression and assigning it to a variable.

**Test Case Options**

There are two options being compared:

1. **Lodash `_.sortBy`**: This method takes two arguments: the array to sort and the field (or property) to use for sorting.
2. **Array.prototype.slice().sort()**: This method creates a shallow copy of the original array using `slice()`, sorts the copied array, and then assigns it back to the original array.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Lodash `_.sortBy`**:
	+ Pros: More efficient for large datasets (uses optimized sorting algorithms), easier to read and maintain, and doesn't require modifying the original array.
	+ Cons: Requires Lodash library inclusion, which may not be desirable in all scenarios.
* **Array.prototype.slice().sort()**:
	+ Pros: Does not modify the original array, can be more intuitive for small datasets.
	+ Cons: Less efficient for large datasets (creates a shallow copy of the array), and requires modifying the original array.

**Other Considerations**

When choosing between these two approaches, consider the following:

* If you're working with large datasets or need high performance, `lodash.sortby` might be a better choice.
* If you're working with small datasets or prefer to avoid external libraries, `array.prototype.slice().sort()` might be a better choice.

**Alternatives**

If you want to explore other alternatives, here are some options:

* **Using a custom sorting function**: Instead of using either Lodash or the built-in `sort()` method, you can create your own custom sorting function.
* **Using other sorting libraries**: There are many other JavaScript sorting libraries available, such as Moment.js or FastSort.
* **Native JavaScript array methods**: Depending on the browser support and version, some native JavaScript array methods like `Array.prototype.sort()` might be faster or more efficient.

I hope this explanation helps!

Related benchmarks:

Lodash sort vs array.prototype.slice and array.prototype.sort (version: 0)

Comparing performance of: _.sortBy vs array.prototype.sort

Created: 4 years ago by: Guest

Jump to the latest result

_.sortBy

array.prototype.sort

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