Benchmark: _.sortBy vs JS sort vs for vs forEach

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 sort
arr.sort((a, b) => a.value - b.value);
lodash sort
_.sortBy(arr, (arr) => arr.value);
for loop
for (let i = 0; i < arr.length; i++) { let b = arr[i].value }
forEach loop
arr.forEach(a => { let b = a.value })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native JS sort
lodash sort
for loop
forEach loop

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 19 hours ago):

LLMs can make mistakes. Check important info.

The benchmark defined by MeasureThat.net compares the performance of different methods for sorting and iterating over an array of objects in JavaScript. The array contains one million randomly generated objects, each with a `value` property. The four methods being compared are:

1. **Native JS sort**: This method uses the built-in `.sort()` function with a custom comparator `(a, b) => a.value - b.value` to sort the array based on the `value` property of each object.
   - **Pros**: 
     - Highly optimized in modern JavaScript engines, leading to faster performance for large datasets.
     - Straightforward and uses native functionality, making it easy for other developers to understand and maintain.
   - **Cons**:
     - Relies on the stability of the sorting algorithm implemented in the JavaScript engine, which may vary across browsers or versions.

2. **Lodash sort**: This method uses the Lodash library's `_.sortBy` function to sort the array.
   - **Library Purpose**: Lodash is a utility library that offers various functions for common programming tasks, including manipulating and iterating over arrays, objects, and strings.
   - **Pros**:
     - Provides additional flexibility and clarity, especially when dealing with complex sorting criteria.
     - Can be easier to read, especially for developers already familiar with the Lodash library.
   - **Cons**:
     - Typically slower than the native sort due to the overhead of an additional library.
     - Introduces a dependency on the Lodash library, which increases the bundle size if not used elsewhere.

3. **For loop**: This method employs a traditional `for` loop to iterate over the array and access each `value`.
   - **Pros**:
     - Offers the most control over the iteration process and can be optimized well by JavaScript engines.
     - Minimal overhead and no reliance on external libraries or functions.
   - **Cons**:
     - More verbose and can be less readable than array methods such as `forEach` or `map`.
     - Does not perform any action on the data unless explicitly coded to do so.

4. **ForEach loop**: This method uses the `.forEach()` array method to iterate through the array.
   - **Pros**:
     - Provides a clean and readable way to access each item in the array.
     - Automatically handles array bounds, reducing the chance of off-by-one errors.
   - **Cons**:
     - Slightly less efficient than a traditional `for` loop as it has overhead associated with function calls for each iteration.
     - Does not allow for breaking out of the loop early, which may be a limitation in some scenarios.

### Benchmark Results
Based on the results, the performance in terms of executions per second is as follows:

- **ForEach loop**: 20.88 executions per second (fastest)
- **Native JS sort**: 10.56 executions per second
- **Lodash sort**: 3.39 executions per second
- **For loop**: 2.91 executions per second (slowest)

### Summary of Considerations
When choosing among these approaches:
- Performance should be a primary consideration for large datasets, where the speed of the native sort method or forEach might be critical.
- Readability and maintainability are also important, especially in collaborative projects where team members may benefit from clear code.
- Dependency on external libraries like Lodash may be unnecessary if the application's scope does not require its extended functionality.
- Edge cases or specific scenarios (e.g., when break or return conditions are needed) might influence the choice of iteration method.

### Alternatives
- **Array.prototype.map()**: Useful for transforming an array rather than sorting.
- **Array.prototype.reduce()**: Good for reducing an array to a single value.
- **External Libraries**: Besides Lodash, libraries like Ramda or Underscore could be used for functional programming utilities, though they would also add overhead.

Latest run results:

Run details: (Test run date: 20 hours ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Native JS sort	10.6 Ops/sec
lodash sort	3.4 Ops/sec
for loop	2.9 Ops/sec
forEach loop	20.9 Ops/sec

Related benchmarks:

_.sortBy vs JS sort vs for vs forEach (version: 1)

Comparing performance of: Native JS sort vs lodash sort vs for loop vs forEach loop

Created: 20 hours ago by: Guest

Jump to the latest result

Native JS sort

lodash sort

for loop

forEach loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 19 hours ago):