Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
Feature Requests
FAQ
Register
Log In
JS array shallow copy and sort
(version: 0)
Benchmark.js
Comparing performance of:
Spread operator - sort vs slice - sort vs toSorted
Created:
2 years ago
by:
Guest
Go to the latest result
Script Preparation code:
params = 'qwertyuiopasdfghjklzxcvbnm'.repeat(1000).split('');
Tests:
Spread operator - sort
[...params].sort();
slice - sort
params.slice().sort();
toSorted
params.toSorted();
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (3)
Previous results
Fork
Test case name
Result
Spread operator - sort
slice - sort
toSorted
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
one year ago
)
User agent:
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36
Browser/OS:
Chrome 132 on Mac OS X 10.15.7
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=583656" width="100%" height="500px"></iframe>
toSorted
495/s
slice - sort
482/s
Spread operator - sort
479/s
View exact numbers
Test name
Executions per second
✓
toSorted
495 Ops/sec
slice - sort
482 Ops/sec
Spread operator - sort
479 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
I'll break down the provided JSON data to explain what's being tested and compare different approaches. **Benchmark Definition** The benchmark is testing the performance of three methods for sorting an array in JavaScript: 1. Shallow copying and sorting using the spread operator (`[...params].sort();`) 2. Using the `slice()` method followed by sorting (`params.slice().sort();`) 3. Using a custom `toSorted()` function (not shown in the provided code) **Options Compared** The benchmark is comparing three different approaches: 1. **Shallow copying and sorting using the spread operator**: This approach creates a new array by spreading the original array's elements into a new array (`[...params]`). The sorted array is then returned. 2. **Using the `slice()` method followed by sorting**: This approach creates a shallow copy of the original array using `slice()`, and then sorts the copied array. 3. **Custom `toSorted()` function**: This approach is not shown in the provided code, so we can't analyze it further. **Pros and Cons** * **Shallow copying and sorting using the spread operator**: + Pros: Simple and concise code, creates a new array without modifying the original, potentially faster execution due to reduced overhead. + Cons: May create unnecessary copies of large arrays, can be slower than other approaches for very large datasets. * **Using the `slice()` method followed by sorting**: + Pros: More efficient use of memory since only a shallow copy is created, can be faster for large datasets. + Cons: Can be slower than the spread operator approach for small to medium-sized arrays due to the overhead of creating a slice. * **Custom `toSorted()` function**: Not shown in the provided code, so we can't analyze its performance or pros/cons. **Library and Purpose** None are explicitly mentioned in the provided code. However, it's worth noting that the use of `slice()` suggests that the benchmark is targeting modern JavaScript engines that support this method. **Special JS Features or Syntax** None are mentioned in the provided code. **Other Alternatives** Some alternative approaches for sorting arrays in JavaScript include: * Using `Array.prototype.sort()`: This approach modifies the original array and can be slower than other approaches due to the overhead of sorting. * Using a library like Lodash (`_.sortBy()`): This approach uses an external library, which may have its own performance implications. **Benchmark Preparation Code** The script preparation code is a simple string literal that creates a long array by repeating the string `'qwertyuiopasdfghjklzxcvbnm'` 1000 times and splitting it into individual characters: ```javascript params = 'qwertyuiopasdfghjklzxcvbnm'.repeat(1000).split(''); ``` This code is designed to create a large array that can be sorted, allowing the benchmark to focus on the performance of each sorting approach.
Related benchmarks
Lodash orderBy vs array.prototype.sort vs vanila orderBy _ smart vs QuickSort add slice
Comments
Confirm delete:
Do you really want to delete benchmark?