Benchmark: array.sort vs array.toSorted

Script Preparation code:

var compareFn = (a, b) => a - b

Tests:

array.sort
var array = Array.from({ length: 500 }).map((_) => Math.random()); const result = array.sort(compareFn);
array.toSorted
var array = Array.from({ length: 500 }).map((_) => Math.random()); const result = array.toSorted(compareFn)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array.sort
array.toSorted

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 23 days ago)

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
array.sort	11684.2 Ops/sec
array.toSorted	11933.8 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 23 days ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON compares two different methods for sorting arrays in JavaScript: `array.sort()` and `array.toSorted()`. Both methods are tested for their performance when sorting an array of random numbers generated with a specific length.

### Comparison of Options

1. **array.sort()**
   - Implementation: `const result = array.sort(compareFn);`
   - **Description**: This is a built-in JavaScript method for sorting the elements of an array in place and returning the sorted array. The method modifies the original array and uses the compare function (`compareFn`) to determine the order of elements.
   - **Performance Result**: `ExecutionsPerSecond: 11684.25`
   - **Pros**:
     - Simple and widely used; it's a well-understood method in the JavaScript ecosystem.
     - Directly modifies the original array, which might save memory in some contexts since it avoids creating copies.
   - **Cons**:
     - Since it sorts in place, the original array is changed, which may not be desirable if you need to preserve the initial state of the array.
     - It can be subject to performance pitfalls, especially with large arrays or complex comparison functions.

2. **array.toSorted()**
   - Implementation: `const result = array.toSorted(compareFn);`
   - **Description**: This is a newer method (introduced in ECMAScript 2022) that creates a new sorted array from the elements of the original array, leaving the original array unchanged. It also uses the provided compare function to determine the order of elements.
   - **Performance Result**: `ExecutionsPerSecond: 11933.78515625`
   - **Pros**:
     - Non-destructive: It does not alter the original array, which is beneficial for functional programming practices and when immutability is preferred.
     - Can reduce bugs related to unintended side effects from mutating the original array.
   - **Cons**:
     - Slightly higher memory usage might occur due to the need to create a new array, particularly with very large datasets.
     - Since it is newer, codebases that need to support older browsers may not be able to use `toSorted()`.

### Additional Considerations
- **Library & Syntax Features**: There are no external libraries involved in this benchmark; both methods are part of standard JavaScript.
- **Performance Results**: The benchmark shows that `array.toSorted()` performs slightly better than `array.sort()` in this test case, indicating potential optimizations in newer JavaScript engines.
- **Browser Compatibility**: As of now, `array.toSorted()` may not be available in all environments. Developers should check compatibility with their target browsers or environments.

### Alternatives
- **Using Libraries**: Libraries such as Lodash provide utility functions like `_.sortBy()` which can be used for sorting. These libraries often come with additional features like chaining and handling edge cases.
- **Custom Sorting Algorithms**: Implementing custom sorting algorithms (like quicksort or mergesort) for specific cases can also be beneficial, though this requires more implementation effort and might not achieve performance gains over optimized built-in methods.
- **Typed Arrays**: When dealing with numerical data, JavaScript typed arrays (like `Float32Array`) can also be sorted utilizing their own methods, yielding potentially better performance in scenarios involving large datasets.

In conclusion, both `array.sort()` and `array.toSorted()` are useful depending on the context of the application. `array.sort()` is a legacy method with direct modification, while `array.toSorted()` offers a cleaner approach when immutability is essential. The performance benchmarks suggest that `toSorted()` is the preferable method in this particular test scenario, but context matters when deciding on the most appropriate option.

Related benchmarks:

array.sort vs array.toSorted (version: 1)

Comparing performance of: array.sort vs array.toSorted

Created: 23 days ago by: Guest

Jump to the latest result

array.sort

array.toSorted

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 23 days ago):