Benchmark: Underscore _.sortBy() vs Vanilla .sort() vs Vanilla CUSTOM sort method vs Vanille .sort() using localeCompare

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js'></script>

Script Preparation code:

window.users = [
  { name: 'Ваня', level: '3' },
  { name: 'Саша', level: '1' },
  { name: 'Маша', level: '2' },
  { name: 'Ника', level: '3' },
  { name: 'Вера', level: '1' },
  { name: 'Саша', level: '2' },
  { name: 'Ваня', level: '2' }
];

window.sortBy = (key) => {
  return (a, b) => (a[key] > b[key]) ? 1 : ((b[key] > a[key]) ? -1 : 0);
};

function insertionSort(array, fieldName) {
  let { length } = array, items = [];
  let i, j, current;
  while (length--) {
    items[length] = array[length];
  }

  for (i = 1; i < length; i++) {
    current = items[i];
    j = i;
    while (j > 0 && getItem(items[j - 1], fieldName) > getItem(current, fieldName)) {
      items[j] = items[j - 1];
      j--;
    }
    items[j] = current;
  }
  return items;
}

function getItem(item, fieldName) {
  if (fieldName) {
    item = item[fieldName]
  }
  return item;
}

Tests:

Underscore sortBy()
_.sortBy(users, 'name')
Vanilla sort()
users.sort(sortBy("name"));
Vanilla CUSTOM sort method
insertionSort(users, "name");
localeCampare
users.sort((a, b) => a.name.localeCompare(b.name));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Underscore sortBy()
Vanilla sort()
Vanilla CUSTOM sort method
localeCampare

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated one month ago):

LLMs can make mistakes. Check important info.

Let's break down what's being tested and compared in this benchmark.

**What is being tested?**

The benchmark compares four different approaches to sorting an array of objects:

1. **Underscore sortBy()**: This uses the `_.sortBy()` function from the Underscore.js library, which sorts an array based on a specified property.
2. **Vanilla sort()**: This uses the built-in `sort()` method of JavaScript arrays, without any additional libraries or helper functions.
3. **Vanilla CUSTOM sort method**: This is a custom implementation of a sorting algorithm, specifically insertion sort, written in plain JavaScript.
4. **localeCompare**: This uses the `localeCompare()` method to compare strings, which is used as part of the sorting process.

**What options are compared?**

The four test cases compare different approaches to sorting an array of objects:

1. Using Underscore.js's `_.sortBy()` function
2. Using JavaScript's built-in `sort()` method directly
3. Implementing a custom insertion sort algorithm in plain JavaScript
4. Using the `localeCompare()` method for string comparisons

**Pros and Cons of each approach:**

* **Underscore sortBy()**: Pros:
	+ Easy to use and concise code.
	+ Works well with arrays of objects.
	Cons:
		- Requires an additional library (Underscore.js).
		- May have performance overhead due to the library's implementation.
* **Vanilla sort()**: Pros:
	+ Built-in JavaScript method, no external dependencies.
	+ Can be used with any type of array data.
	Cons:
		- Requires more verbose code for complex sorting scenarios.
		- May not perform as well as specialized sorting algorithms.
* **Vanilla CUSTOM sort method**: Pros:
	+ Custom implementation allows for optimization and control.
	+ No external dependencies or library overhead.
	Cons:
		- More complex to implement, especially for large datasets.
		- May require more memory due to the algorithm's complexity.
* **localeCompare**: Pros:
	+ Efficient string comparison method.
	+ Used as part of the sorting process.
	Cons:
		- Only applicable when comparing strings.

**Other considerations:**

* The test case uses a small dataset (6 objects) for performance measurement. Larger datasets may yield different results.
* The custom insertion sort implementation is not optimized for large datasets and may perform poorly in such scenarios.

Overall, this benchmark provides insights into the trade-offs between using built-in JavaScript methods, libraries like Underscore.js, and custom implementations for sorting an array of objects.

Latest run results:

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

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

Browser/OS: Chrome 98 on Windows

View result in a separate tab

Test name	Executions per second
Underscore sortBy()	642250.8 Ops/sec
Vanilla sort()	1719645.8 Ops/sec
Vanilla CUSTOM sort method	3928503.5 Ops/sec
localeCampare	623403.8 Ops/sec

Related benchmarks:

Underscore _.sortBy() vs Vanilla .sort() vs Vanilla CUSTOM sort method vs Vanille .sort() using localeCompare (version: 0)

Comparing performance of: Underscore sortBy() vs Vanilla sort() vs Vanilla CUSTOM sort method vs localeCampare

Created: 2 years ago by: Guest

Jump to the latest result

Underscore sortBy()

Vanilla sort()

Vanilla CUSTOM sort method

localeCampare

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated one month ago):